Commit ed802d0

**What:** Run eval suite in CI, upload result JSON as artifact, post summary comment on PR.

**Why:** Currently evals only run locally. CI integration would catch quality regressions before merge and provide a persistent record of eval results per PR.

**Context:** Requires `ANTHROPIC_API_KEY` in CI secrets. Cost is ~$4/run. The eval persistence system (v0.3.6) writes JSON to `~/.gstack-dev/evals/` — CI would upload these as GitHub Actions artifacts and use `eval:compare` to post a delta comment on the PR.

**Depends on:** Eval persistence shipping (v0.3.6).

**Effort:** M (medium)

**Priority:** P2

**What:** `bun run eval:dashboard` serves local HTML with charts: cost trending, detection rate over time, pass/fail history.

**Why:** The CLI tools (`eval:list`, `eval:compare`, `eval:summary`) are good for quick checks but visual charts are better for spotting trends over many runs.

**Context:** Reads the same `~/.gstack-dev/evals/*.json` files. ~200 lines HTML + chart.js code served via a simple Bun HTTP server. No external dependencies beyond what's already installed.

**Depends on:** Eval persistence + eval:list shipping (v0.3.6).

**Effort:** M (medium)

**Priority:** P3 (nice-to-have, revisit after eval system sees regular use)

"start": "bun run browse/src/server.ts",

"eval:list": "bun run scripts/eval-list.ts",

"eval:compare": "bun run scripts/eval-compare.ts",

"eval:summary": "bun run scripts/eval-summary.ts"

#!/usr/bin/env bun

import * as fs from 'fs';

import * as path from 'path';

import * as os from 'os';

import {

findPreviousRun,

compareEvalResults,

formatComparison,

} from '../test/helpers/eval-store';

import type { EvalResult } from '../test/helpers/eval-store';

const EVAL_DIR = path.join(os.homedir(), '.gstack-dev', 'evals');

function loadResult(filepath: string): EvalResult {

// Resolve relative to EVAL_DIR if not absolute

const resolved = path.isAbsolute(filepath) ? filepath : path.join(EVAL_DIR, filepath);

if (!fs.existsSync(resolved)) {

console.error(`File not found: ${resolved}`);

process.exit(1);

}

return JSON.parse(fs.readFileSync(resolved, 'utf-8'));

const args = process.argv.slice(2);

let beforeFile: string;

let afterFile: string;

if (args.length === 2) {

// Two explicit files

beforeFile = args[0];

afterFile = args[1];

} else if (args.length === 1) {

// One file — find its predecessor

afterFile = args[0];

const resolved = path.isAbsolute(afterFile) ? afterFile : path.join(EVAL_DIR, afterFile);

const afterResult = loadResult(resolved);

const prev = findPreviousRun(EVAL_DIR, afterResult.tier, afterResult.branch, resolved);

if (!prev) {

console.log('No previous run found to compare against.');

process.exit(0);

}

beforeFile = prev;

} else {

// No args — find two most recent of the same tier

let files: string[];

try {

files = fs.readdirSync(EVAL_DIR)

.filter(f => f.endsWith('.json'))

.sort()

.reverse();

} catch {

console.log('No eval runs yet. Run: EVALS=1 bun run test:evals');

process.exit(0);

}

if (files.length < 2) {

console.log('Need at least 2 eval runs to compare. Run evals again.');

process.exit(0);

}

// Most recent file

afterFile = path.join(EVAL_DIR, files[0]);

const afterResult = loadResult(afterFile);

const prev = findPreviousRun(EVAL_DIR, afterResult.tier, afterResult.branch, afterFile);

if (!prev) {

console.log('No previous run of the same tier found to compare against.');

process.exit(0);

}

beforeFile = prev;

const beforeResult = loadResult(beforeFile);

const afterResult = loadResult(afterFile);

if (beforeResult.tier !== afterResult.tier) {

console.warn(`Warning: comparing different tiers (${beforeResult.tier} vs ${afterResult.tier})`);

if (beforeResult.schema_version !== afterResult.schema_version) {

console.warn(`Warning: schema version mismatch (${beforeResult.schema_version} vs ${afterResult.schema_version})`);

const comparison = compareEvalResults(beforeResult, afterResult, beforeFile, afterFile);

#!/usr/bin/env bun

import * as fs from 'fs';

import * as path from 'path';

import * as os from 'os';

const EVAL_DIR = path.join(os.homedir(), '.gstack-dev', 'evals');

const args = process.argv.slice(2);

let filterBranch: string | null = null;

let filterTier: string | null = null;

let limit = 20;

for (let i = 0; i < args.length; i++) {

if (args[i] === '--branch' && args[i + 1]) { filterBranch = args[++i]; }

else if (args[i] === '--tier' && args[i + 1]) { filterTier = args[++i]; }

else if (args[i] === '--limit' && args[i + 1]) { limit = parseInt(args[++i], 10); }

let files: string[];

try {

files = fs.readdirSync(EVAL_DIR).filter(f => f.endsWith('.json'));

} catch {

console.log('No eval runs yet. Run: EVALS=1 bun run test:evals');

process.exit(0);

if (files.length === 0) {

console.log('No eval runs yet. Run: EVALS=1 bun run test:evals');

process.exit(0);

interface RunSummary {

file: string;

timestamp: string;

branch: string;

tier: string;

version: string;

passed: number;

total: number;

cost: number;

const runs: RunSummary[] = [];

for (const file of files) {

try {

const data = JSON.parse(fs.readFileSync(path.join(EVAL_DIR, file), 'utf-8'));

if (filterBranch && data.branch !== filterBranch) continue;

if (filterTier && data.tier !== filterTier) continue;

runs.push({

file,

timestamp: data.timestamp || '',

branch: data.branch || 'unknown',

tier: data.tier || 'unknown',

version: data.version || '?',

passed: data.passed || 0,

total: data.total_tests || 0,

cost: data.total_cost_usd || 0,

});

} catch { continue; }

runs.sort((a, b) => b.timestamp.localeCompare(a.timestamp));

const displayed = runs.slice(0, limit);

' ' +

'Date'.padEnd(17) +

'Branch'.padEnd(28) +

'Tier'.padEnd(12) +

'Pass'.padEnd(8) +

'Cost'.padEnd(8) +

'Version'

for (const run of displayed) {

const date = run.timestamp.replace('T', ' ').slice(0, 16);

const branch = run.branch.length > 26 ? run.branch.slice(0, 23) + '...' : run.branch.padEnd(28);

const pass = `${run.passed}/${run.total}`.padEnd(8);

const cost = `$${run.cost.toFixed(2)}`.padEnd(8);

console.log(` ${date.padEnd(17)}${branch}${run.tier.padEnd(12)}${pass}${cost}v${run.version}`);

const totalCost = runs.reduce((s, r) => s + r.cost, 0);