@lovinka/vitrinka 1.7.1 → 1.9.0

package/skills/vitrinka/tests/dx.test.ts

@@ -1,264 +0,0 @@
-// dx.test.ts — the CLI developer-experience layer: the command registry (help +
-// completion single source of truth), the generated help/completion, the hidden
-// __complete dynamic candidates, and the AI assistance (proposal parse/validate,
-// askClaude degradation, fuzzy resolution) — all against stub claude bins and
-// loopback HTTP fixtures so nothing reaches the real network or the real claude.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { execFile } from 'node:child_process';
-import { createServer } from 'node:http';
-import { fileURLToPath } from 'node:url';
-import {
-  COMMANDS, COMMAND_NAMES, renderFullHelp, renderCmdHelp, renderCompactUsage,
-  completionScript, nearestCommand, levenshtein, extractCommandLine, tokenizeArgv,
-  validateProposal, askClaude, fetchCandidates, resolveFuzzy,
-} from '../../../pkg/src/cli.ts';
-import { CLI, makeTmp, writeFakeBin } from './_helpers.ts';
-
-const CLI_SRC = fileURLToPath(new URL('../../../pkg/src/cli.ts', import.meta.url));
-
-// ---------- registry completeness (enforced so a new command can't skip help) ----------
-
-test('registry: every dispatch case has a COMMANDS entry, and vice versa', () => {
-  const src = readFileSync(CLI_SRC, 'utf8');
-  const body = src.slice(src.indexOf('async function runSub'), src.indexOf('const IS_MAIN'));
-  const cases = [...body.matchAll(/cmd === '([a-z-]+)'/g)].map((m) => m[1]);
-  // Meta commands (help/completion/ai) are handled in the entrypoint, not runSub.
-  const dispatchable = COMMANDS.filter((c) => !['help', 'completion', 'ai'].includes(c.name)).map((c) => c.name);
-  assert.deepEqual([...new Set(cases)].sort(), [...dispatchable].sort(),
-    'runSub cases and the registry must match exactly');
-});
-
-test('registry: names are unique and every command documents a usage', () => {
-  assert.equal(new Set(COMMAND_NAMES).size, COMMAND_NAMES.length);
-  for (const c of COMMANDS) assert.ok(c.usage !== undefined && c.summary, `${c.name} needs summary+usage`);
-});
-
-// ---------- help rendering ----------
-
-test('renderFullHelp lists every non-meta command with its summary', () => {
-  const help = renderFullHelp();
-  for (const c of COMMANDS.filter((c) => !c.hidden)) {
-    assert.ok(help.includes(c.name), `full help missing ${c.name}`);
-    assert.ok(help.includes(c.summary), `full help missing summary for ${c.name}`);
-  }
-  assert.ok(/USAGE/.test(help) && /COMMANDS/.test(help));
-});
-
-test('renderCmdHelp renders flags + examples for a command', () => {
-  const h = renderCmdHelp('snap');
-  assert.ok(h.includes('vitrinka snap'));
-  assert.ok(h.includes('--route') && h.includes('--udid'), 'snap flags must appear');
-  assert.ok(h.includes('EXAMPLES'));
-});
-
-test('renderCompactUsage is Usage:-headed and names every command (shim + fallback contract)', () => {
-  const u = renderCompactUsage();
-  assert.match(u, /^Usage:/);
-  assert.ok(u.includes('artifact-from-set'), 'the compact usage must name the last command');
-});
-
-test('nearestCommand suggests a close miss and stays silent on a far one', () => {
-  assert.equal(nearestCommand('snpa'), 'snap');
-  assert.equal(nearestCommand('instal'), 'install');
-  assert.equal(levenshtein('abc', 'abc'), 0);
-  assert.equal(nearestCommand('zzzzzzzzzzzzz'), '');
-});
-
-// ---------- completion generation ----------
-
-for (const shell of ['bash', 'zsh'] as const) {
-  test(`completionScript(${shell}): command names + per-command flags + dynamic hook`, () => {
-    const s = completionScript(shell);
-    for (const c of COMMANDS.filter((c) => !c.hidden)) assert.ok(s.includes(c.name), `missing ${c.name}`);
-    assert.ok(s.includes('--route') && s.includes('--slug'), 'per-command flags embedded');
-    assert.ok(s.includes('__complete'), 'shells out to the dynamic endpoint');
-    assert.ok(s.includes(shell === 'bash' ? 'complete -F _vitrinka' : 'compdef _vitrinka'));
-  });
-}
-
-// ---------- __complete dynamic candidates (against a stub server) ----------
-
-function runCliAsync(cliArgs: string[], env: Record<string, string> = {}): Promise<{ status: number; stdout: string; stderr: string }> {
-  return new Promise((res) => {
-    execFile(process.execPath, [CLI, ...cliArgs], { encoding: 'utf8', env: { ...process.env, ...env } },
-      (err, stdout, stderr) => res({ status: err ? (err as { code?: number }).code ?? 1 : 0, stdout, stderr }));
-  });
-}
-
-function stubApi(projects: string[], boards: string[]) {
-  return createServer((req, res) => {
-    res.setHeader('content-type', 'application/json');
-    if (req.url === '/api/v1/projects') return res.end(JSON.stringify({ projects: projects.map((p) => ({ project: p })) }));
-    if (req.url === '/api/v1/boards') return res.end(JSON.stringify({ boards: boards.map((b) => ({ slug: b })) }));
-    res.statusCode = 404; res.end('{}');
-  });
-}
-
-test('__complete: prefix-filters server projects for a project-taking command', async () => {
-  const srv = stubApi(['fixit', 'flowik', 'reservine'], []);
-  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
-  const base = `http://127.0.0.1:${(srv.address() as { port: number }).port}`;
-  try {
-    const r = await runCliAsync(['__complete', 'index', 'fi'], { VITRINKA_URL: base });
-    assert.equal(r.status, 0, r.stderr);
-    assert.equal(r.stdout.trim(), 'fixit');
-    // A command with no dynamic source prints nothing (silent).
-    const none = await runCliAsync(['__complete', 'build', 'x'], { VITRINKA_URL: base });
-    assert.equal(none.stdout.trim(), '');
-  } finally { srv.close(); }
-});
-
-test('fetchCandidates + __complete stay silent when the server is unreachable', async () => {
-  // Reserved-doc port .0 → immediate failure; must yield [] not throw/hang.
-  const cands = await fetchCandidates('http://127.0.0.1:0', 'boards', 300);
-  assert.deepEqual(cands, []);
-});
-
-// ---------- AI: proposal parsing + validation (claude output is untrusted) ----------
-
-test('extractCommandLine: fenced block wins, else the first vitrinka line', () => {
-  assert.equal(extractCommandLine('sure!\n```sh\nvitrinka build --root .screenshots\n```\n'), 'vitrinka build --root .screenshots');
-  assert.equal(extractCommandLine('Run this:\n$ vitrinka push --root .screenshots'), 'vitrinka push --root .screenshots');
-});
-
-test('tokenizeArgv honors quotes, rejects unbalanced', () => {
-  assert.deepEqual(tokenizeArgv('vitrinka meta --title "Payout flow"'), ['vitrinka', 'meta', '--title', 'Payout flow']);
-  assert.equal(tokenizeArgv('vitrinka name "oops'), null);
-});
-
-test('validateProposal accepts a clean vitrinka command', () => {
-  const p = validateProposal('vitrinka build --root .screenshots');
-  assert.ok(p.ok && p.sub === 'build');
-});
-
-test('validateProposal REJECTS malicious / malformed suggestions', () => {
-  for (const [line, why] of [
-    ['rm -rf /', 'non-vitrinka argv0'],
-    ['vitrinka build; rm -rf /', 'shell metachar'],
-    ['vitrinka push --root . | sh', 'pipe'],
-    ['vitrinka push && curl evil', 'chain'],
-    ['vitrinka $(whoami)', 'command substitution'],
-    ['vitrinka frobnicate', 'unknown subcommand'],
-    ['vitrinka ai "loop"', 'no ai recursion'],
-    ['vitrinka build --exfiltrate http://evil', 'unknown flag for the subcommand'],
-    ['vitrinka name --clear=1 --frobnicate', 'unknown flag (with = form present)'],
-    ['', 'empty'],
-  ] as const) {
-    const p = validateProposal(line);
-    assert.equal(p.ok, false, `should reject (${why}): ${line}`);
-  }
-});
-
-// ---------- AI: askClaude degradation (stub bins) ----------
-
-function withEnv<T>(patch: Record<string, string | undefined>, fn: () => Promise<T>): Promise<T> {
-  const saved: Record<string, string | undefined> = {};
-  for (const k of Object.keys(patch)) { saved[k] = process.env[k]; if (patch[k] === undefined) delete process.env[k]; else process.env[k] = patch[k]!; }
-  return fn().finally(() => { for (const k of Object.keys(saved)) { if (saved[k] === undefined) delete process.env[k]; else process.env[k] = saved[k]!; } });
-}
-
-test('askClaude: clean stub → trimmed stdout', async () => {
-  const bin = join(makeTmp(), 'bin');
-  const stub = writeFakeBin(bin, 'claude-stub', `let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{process.stdout.write('  ok line  ');process.exit(0);});`);
-  const out = await withEnv({ CLAUDE_BIN: stub, VITRINKA_NO_AI: undefined }, () => askClaude('hi', { timeoutMs: 4000 }));
-  assert.equal(out, 'ok line');
-});
-
-test('askClaude: non-zero exit → null (degrade)', async () => {
-  const bin = join(makeTmp(), 'bin');
-  const stub = writeFakeBin(bin, 'claude-stub', `process.stdin.resume();process.stdin.on('end',()=>process.exit(3));`);
-  const out = await withEnv({ CLAUDE_BIN: stub, VITRINKA_NO_AI: undefined }, () => askClaude('hi', { timeoutMs: 4000 }));
-  assert.equal(out, null);
-});
-
-test('askClaude: TIMEOUT → null (slow stub, small cap)', async () => {
-  const bin = join(makeTmp(), 'bin');
-  const stub = writeFakeBin(bin, 'claude-stub', `setTimeout(()=>process.exit(0), 3000);`);
-  const out = await withEnv({ CLAUDE_BIN: stub, VITRINKA_NO_AI: undefined }, () => askClaude('hi', { timeoutMs: 150 }));
-  assert.equal(out, null);
-});
-
-test('askClaude: VITRINKA_NO_AI=1 → null without spawning', async () => {
-  const out = await withEnv({ VITRINKA_NO_AI: '1', CLAUDE_BIN: '/nonexistent/claude' }, () => askClaude('hi'));
-  assert.equal(out, null);
-});
-
-test('askClaude: missing binary → null (no crash)', async () => {
-  const out = await withEnv({ CLAUDE_BIN: '/nonexistent/definitely/claude', VITRINKA_NO_AI: undefined }, () => askClaude('hi', { timeoutMs: 2000 }));
-  assert.equal(out, null);
-});
-
-// ---------- AI: `ai` end-to-end — happy path dispatches internally, malicious rejected ----------
-
-test('ai --yes: stub proposes `vitrinka build` → dispatched INTERNALLY (index.html built)', async () => {
-  const root = join(makeTmp(), '.screenshots');
-  mkdirSync(root, { recursive: true });
-  writeFileSync(join(root, 'manifest.json'), JSON.stringify({ version: 1, shots: [] }) + '\n');
-  const bin = join(makeTmp(), 'bin');
-  const reply = '```sh\nvitrinka build --root ' + root + '\n```';
-  const stub = writeFakeBin(bin, 'claude-stub', `let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{process.stdout.write(process.env.STUB_REPLY||'');process.exit(0);});`);
-  const r = await runCliAsync(['ai', 'build the gallery', '--yes'], { CLAUDE_BIN: stub, STUB_REPLY: reply, VITRINKA_NO_AI: '' });
-  assert.equal(r.status, 0, r.stderr);
-  assert.match(r.stdout, /proposed: vitrinka build --root/);
-  assert.ok(existsSync(join(root, 'index.html')), 'the internal dispatch must have run `build`');
-});
-
-test('ai: a malicious `rm -rf` proposal is rejected (exit 1) and never runs a shell', async () => {
-  const sentinelDir = makeTmp();
-  const sentinel = join(sentinelDir, 'keep.txt');
-  writeFileSync(sentinel, 'do not delete');
-  const bin = join(makeTmp(), 'bin');
-  const stub = writeFakeBin(bin, 'claude-stub', `let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{process.stdout.write(process.env.STUB_REPLY||'');process.exit(0);});`);
-  const r = await runCliAsync(['ai', 'delete everything', '--yes'],
-    { CLAUDE_BIN: stub, STUB_REPLY: '```sh\nrm -rf ' + sentinelDir + '\n```', VITRINKA_NO_AI: '' });
-  assert.equal(r.status, 1);
-  assert.match(r.stderr, /rejected/);
-  assert.ok(existsSync(sentinel), 'the sentinel must survive — claude output is never shell-eval\'d');
-});
-
-test('ai: VITRINKA_NO_AI=1 disables the command', async () => {
-  const r = await runCliAsync(['ai', 'anything'], { VITRINKA_NO_AI: '1' });
-  assert.equal(r.status, 1);
-  assert.match(r.stderr, /disabled/);
-});
-
-// ---------- AI: fuzzy slug resolution (read auto-applies; write confirms) ----------
-
-test('resolveFuzzy: exact match returns as-is (no claude call)', async () => {
-  const srv = stubApi(['fixit', 'reservine'], []);
-  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
-  const base = `http://127.0.0.1:${(srv.address() as { port: number }).port}`;
-  try {
-    const got = await resolveFuzzy('fixit', 'projects', { base, write: false, yes: false });
-    assert.equal(got, 'fixit');
-  } finally { srv.close(); }
-});
-
-test('resolveFuzzy: READ command auto-applies the claude-picked slug', async () => {
-  const srv = stubApi(['fixit', 'reservine'], []);
-  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
-  const base = `http://127.0.0.1:${(srv.address() as { port: number }).port}`;
-  const bin = join(makeTmp(), 'bin');
-  const stub = writeFakeBin(bin, 'claude-stub', `let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{process.stdout.write('reservine');process.exit(0);});`);
-  try {
-    const got = await withEnv({ CLAUDE_BIN: stub, VITRINKA_NO_AI: undefined },
-      () => resolveFuzzy('reservin', 'projects', { base, write: false, yes: false }));
-    assert.equal(got, 'reservine');
-  } finally { srv.close(); }
-});
-
-test('resolveFuzzy: WRITE with --yes bypasses the confirm gate (returns the pick)', async () => {
-  const srv = stubApi([], ['payout-flow', 'onboarding']);
-  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
-  const base = `http://127.0.0.1:${(srv.address() as { port: number }).port}`;
-  const bin = join(makeTmp(), 'bin');
-  const stub = writeFakeBin(bin, 'claude-stub', `let s='';process.stdin.on('data',d=>s+=d);process.stdin.on('end',()=>{process.stdout.write('payout-flow');process.exit(0);});`);
-  try {
-    const got = await withEnv({ CLAUDE_BIN: stub, VITRINKA_NO_AI: undefined },
-      () => resolveFuzzy('payout', 'boards', { base, write: true, yes: true }));
-    assert.equal(got, 'payout-flow');
-  } finally { srv.close(); }
-});

package/skills/vitrinka/tests/embed.test.ts

@@ -1,96 +0,0 @@
-// embed.test.ts — embed-shots output shape, --select subsetting, missing-sips fallback.
-// sips is mocked via a PATH-prefixed fake (copies input → --out) so no real resize runs.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { makeTmp, runCli, writeFakeSips, writeShotsFixture, PNG } from './_helpers.ts';
-
-function envWithFakeSips(tmp: string): Record<string, string> {
-  const bin = writeFakeSips(join(tmp, 'fakebin'));
-  return { PATH: `${bin}:${process.env.PATH}` };
-}
-
-test('embed-shots: all shots → data.json with journey header + jpeg data URIs', () => {
-  const tmp = makeTmp();
-  const root = join(tmp, '.screenshots');
-  writeShotsFixture(root, 3);
-  const out = join(tmp, 'artifact', 'data.json');
-  const r = runCli(['embed-shots', '--root', root, '--out', out], { env: envWithFakeSips(tmp) });
-  assert.equal(r.status, 0);
-  assert.match(r.stdout, /embedded 3 shots → /);
-
-  const data = JSON.parse(readFileSync(out, 'utf8'));
-  assert.deepEqual(data.journey, {
-    kicker: 'TEST · FLOW', title: 'Test journey', accent: 'journey',
-    intro: 'Intro sentence.', chips: [{ k: 'Persona', v: 'Dev' }],
-  });
-  assert.equal(data.shots.length, 3);
-  for (const [i, s] of data.shots.entries()) {
-    assert.equal(s.label, `STEP ${i + 1}`);
-    assert.equal(s.title, `Step ${i + 1}`);
-    assert.equal(s.note, `note ${i + 1}`);
-    assert.equal(typeof s.ts, 'string');
-    assert.match(s.src, /^data:image\/jpeg;base64,/);
-    // fake sips copies the PNG bytes through — payload must round-trip
-    assert.deepEqual(Buffer.from(s.src.split(',')[1], 'base64'), PNG);
-  }
-  assert.equal(data.shots[0].route, '/home');
-  assert.equal(data.shots[2].route, '/end');
-});
-
-test('embed-shots: --select picks a 1-based subset in manifest order', () => {
-  const tmp = makeTmp();
-  const root = join(tmp, '.screenshots');
-  writeShotsFixture(root, 3);
-  const out = join(tmp, 'data.json');
-  const r = runCli(['embed-shots', '--root', root, '--select', '1,3', '--out', out], { env: envWithFakeSips(tmp) });
-  assert.equal(r.status, 0);
-  const data = JSON.parse(readFileSync(out, 'utf8'));
-  assert.deepEqual(data.shots.map((s: { route: string }) => s.route), ['/home', '/end']);
-});
-
-test('embed-shots: bad --select exits 2 with a clear error', () => {
-  const tmp = makeTmp();
-  const root = join(tmp, '.screenshots');
-  writeShotsFixture(root, 2);
-  const r = runCli(['embed-shots', '--root', root, '--select', '9', '--out', join(tmp, 'd.json')], { env: envWithFakeSips(tmp) });
-  assert.equal(r.status, 2);
-  assert.match(r.stderr, /out of range/);
-});
-
-test('embed-shots: --out is required', () => {
-  const tmp = makeTmp();
-  const root = join(tmp, '.screenshots');
-  writeShotsFixture(root, 1);
-  const r = runCli(['embed-shots', '--root', root]);
-  assert.equal(r.status, 2);
-  assert.match(r.stderr, /--out .*is required/);
-});
-
-test('embed-shots: missing sips → embeds originals + warns once', () => {
-  const tmp = makeTmp();
-  const root = join(tmp, '.screenshots');
-  writeShotsFixture(root, 2);
-  const out = join(tmp, 'data.json');
-  // PATH without sips (the CLI itself is spawned via absolute node path)
-  const r = runCli(['embed-shots', '--root', root, '--out', out], { env: { PATH: '/var/empty' } });
-  assert.equal(r.status, 0);
-  assert.equal(r.stderr.match(/sips not found/g)?.length, 1); // warned exactly once
-  const data = JSON.parse(readFileSync(out, 'utf8'));
-  assert.equal(data.shots.length, 2);
-  for (const s of data.shots) {
-    assert.match(s.src, /^data:image\/png;base64,/); // original bytes, original mime
-    assert.deepEqual(Buffer.from(s.src.split(',')[1], 'base64'), PNG);
-  }
-});
-
-test('embed-shots: manifest entry pointing at a deleted file fails loudly', () => {
-  const tmp = makeTmp();
-  const root = join(tmp, '.screenshots');
-  writeShotsFixture(root, 2);
-  rmSync(join(root, '2026-07-03', '02-web-step2.png'));
-  const r = runCli(['embed-shots', '--root', root, '--out', join(tmp, 'd.json')], { env: { PATH: '/var/empty' } });
-  assert.equal(r.status, 1);
-  assert.match(r.stderr, /file missing/);
-});

package/skills/vitrinka/tests/index.test.ts

@@ -1,250 +0,0 @@
-// index.test.ts — project index builder (project-index design 2026-07-05):
-// route extraction per convention, file exclusion, hash-gated push.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { execSync, execFile } from 'node:child_process';
-import { createServer } from 'node:http';
-import { extractRoutes, buildProjectIndex } from '../../../pkg/src/cli.ts';
-import { CLI, makeTmp } from './_helpers.ts';
-
-test('extractRoutes: Expo Router — groups stripped, index collapsed, _layout/+not-found skipped', () => {
-  const routes = extractRoutes([
-    'app/_layout.tsx',
-    'app/+not-found.tsx',
-    'app/(tabs)/index.tsx',
-    'app/(tabs)/jobs/[id].tsx',
-    'app/payouts/index.tsx',
-    'src/components/JobCard.tsx',
-    'assets/logo.svg',
-  ]);
-  assert.deepEqual(routes, [
-    { p: '/', f: 'app/(tabs)/index.tsx' },
-    { p: '/jobs/[id]', f: 'app/(tabs)/jobs/[id].tsx' },
-    { p: '/payouts', f: 'app/payouts/index.tsx' },
-  ]);
-});
-
-test('extractRoutes: Next.js app router — only page.* files are routes', () => {
-  const routes = extractRoutes([
-    'app/layout.tsx',
-    'app/page.tsx',
-    'app/jobs/[id]/page.tsx',
-    'app/jobs/[id]/loading.tsx',
-    'app/api/route.ts',
-  ]);
-  assert.deepEqual(routes, [
-    { p: '/', f: 'app/page.tsx' },
-    { p: '/jobs/[id]', f: 'app/jobs/[id]/page.tsx' },
-  ]);
-});
-
-test('extractRoutes: Next.js pages router — _app and api/ skipped, src/ prefix ok', () => {
-  const routes = extractRoutes([
-    'src/pages/_app.tsx',
-    'src/pages/api/webhook.ts',
-    'src/pages/index.tsx',
-    'src/pages/jobs/[id].tsx',
-  ]);
-  assert.deepEqual(routes, [
-    { p: '/', f: 'src/pages/index.tsx' },
-    { p: '/jobs/[id]', f: 'src/pages/jobs/[id].tsx' },
-  ]);
-});
-
-test('extractRoutes: unrecognized layout yields no routes, never throws', () => {
-  assert.deepEqual(extractRoutes(['cmd/main.go', 'internal/web/server.go']), []);
-});
-
-function seedRepo(): string {
-  const repo = join(makeTmp(), 'FixIt');
-  mkdirSync(join(repo, 'app'), { recursive: true });
-  execSync('git init -q -b main', { cwd: repo });
-  writeFileSync(join(repo, 'app/index.tsx'), 'export default 1;');
-  writeFileSync(join(repo, 'logo.png'), 'x'); // binary-excluded
-  writeFileSync(join(repo, '.gitignore'), 'secret.ts\n');
-  writeFileSync(join(repo, 'secret.ts'), 'nope'); // gitignored
-  execSync('git add -A && git -c user.email=t@t -c user.name=t commit -qm init', { cwd: repo });
-  writeFileSync(join(repo, 'app/fresh.tsx'), 'export default 2;'); // untracked, unignored
-  return repo;
-}
-
-test('buildProjectIndex: tracked + untracked-unignored files, binaries and ignored files out', () => {
-  const repo = seedRepo();
-  const built = buildProjectIndex(repo);
-  assert.ok(built);
-  const body = JSON.parse(built.body);
-  assert.equal(body.v, 1);
-  assert.deepEqual(body.files, ['.gitignore', 'app/fresh.tsx', 'app/index.tsx']);
-  assert.deepEqual(body.routes, [{ p: '/', f: 'app/index.tsx' }, { p: '/fresh', f: 'app/fresh.tsx' }]);
-  assert.equal(built.hash.length, 64);
-  // Outside a repo → null, no throw.
-  assert.equal(buildProjectIndex(makeTmp()), null);
-});
-
-// runCliAsync: the fake vitrinka server lives in THIS process, so the CLI
-// must run async — spawnSync would block the event loop and the server could
-// never answer (the fetch would only ever time out).
-function runCliAsync(cliArgs: string[], cwd: string, env: Record<string, string> = {}): Promise<{ status: number; stdout: string; stderr: string }> {
-  return new Promise((res) => {
-    execFile(process.execPath, [CLI, ...cliArgs], { cwd, encoding: 'utf8', env: { ...process.env, ...env } },
-      (err, stdout, stderr) => res({ status: err ? (err as { code?: number }).code ?? 1 : 0, stdout, stderr }));
-  });
-}
-
-// A stateful fake vitrinka: remembers the pushed index like the real server
-// (hash per PUT), serves conditional GETs (304 on ETag match, 404 when the
-// row is gone), and can be wiped mid-test to simulate a server reset.
-function fakeVitrinka() {
-  let stored: string | null = null;
-  let seq = 0;
-  const requests: string[] = [];
-  const srv = createServer((req, res) => {
-    let body = '';
-    req.on('data', (c) => { body += c; });
-    req.on('end', () => {
-      requests.push(`${req.method} ${req.url}`);
-      if (req.url === '/wipe') { stored = null; res.writeHead(200); return res.end(); }
-      if (req.method === 'PUT') {
-        stored = `srv-hash-${++seq}`;
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        return res.end(JSON.stringify({ hash: stored }));
-      }
-      if (!stored) { res.writeHead(404); return res.end('{"error":"no index"}'); }
-      if (req.headers['if-none-match'] === `"${stored}"`) { res.writeHead(304); return res.end(); }
-      res.writeHead(200, { ETag: `"${stored}"`, 'Content-Type': 'application/json' });
-      res.end('{}');
-    });
-  });
-  return { srv, requests };
-}
-
-test('index command: pushes once, hash-gates re-runs, and re-pushes after a server wipe', async () => {
-  const repo = seedRepo();
-  const { srv, requests } = fakeVitrinka();
-  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
-  const port = (srv.address() as { port: number }).port;
-  const base = `http://127.0.0.1:${port}`;
-  // Hermetic HOME: the real ~/.claude palette must not leak into the index hash.
-  const home = makeTmp();
-  const run = () => runCliAsync(['index', '--root', join(repo, '.screenshots'), '--base', base], repo, { HOME: home });
-  try {
-    const r1 = await run();
-    assert.equal(r1.status, 0, r1.stderr);
-    assert.match(r1.stdout, /index ↑ fixit: 2 routes, 3 files, 0 commands/);
-    assert.deepEqual(requests, ['PUT /api/v1/projects/fixit/index']);
-    assert.ok(existsSync(join(repo, '.git', 'vitrinka-index.cache')));
-
-    // Unchanged re-run: the explicit command VERIFIES the server still holds
-    // the index — one conditional GET (304, zero body), never a re-upload.
-    const r2 = await run();
-    assert.equal(r2.status, 0, r2.stderr);
-    assert.deepEqual(requests.slice(1), ['GET /api/v1/projects/fixit/index']);
-
-    // Server-side loss (DB reset): the local stamp alone must NOT report
-    // success — the 404 invalidates it and the index is re-pushed.
-    await fetch(`${base}/wipe`);
-    const r3 = await run();
-    assert.equal(r3.status, 0, r3.stderr);
-    assert.deepEqual(requests.slice(3), ['GET /api/v1/projects/fixit/index', 'PUT /api/v1/projects/fixit/index']);
-
-    // A new file invalidates the content gate directly (straight to PUT).
-    writeFileSync(join(repo, 'app/more.tsx'), 'export default 3;');
-    const r4 = await run();
-    assert.equal(r4.status, 0, r4.stderr);
-    assert.deepEqual(requests.slice(5), ['PUT /api/v1/projects/fixit/index']);
-  } finally {
-    srv.close();
-  }
-});
-
-test('shotContext: src repeat/comma forms, state, device + viewport', async () => {
-  const { shotContext, parseArgs } = await import('../../../pkg/src/cli.ts');
-  const args = parseArgs(['--src', 'app/payouts/index.tsx', '--src', 'a.ts,b.ts',
-    '--state', 'courier · cs', '--device', 'iPhone 15', '--viewport', '393x852@3']);
-  assert.deepEqual(shotContext(args), {
-    src: ['app/payouts/index.tsx', 'a.ts', 'b.ts'],
-    state: 'courier · cs',
-    device: { device: 'iPhone 15', w: 393, h: 852, scale: 3 },
-  });
-  assert.deepEqual(shotContext(parseArgs([])), {}); // all optional
-});
-
-test('add: v2 manifest carries src/state and the session commit/branch', async () => {
-  const repo = seedRepo();
-  const root = join(repo, '.screenshots');
-  mkdirSync(root, { recursive: true });
-  writeFileSync(join(root, 'shot.png'), 'x');
-  const { execFileSync } = await import('node:child_process');
-  execFileSync(process.execPath, [CLI, 'add', '--root', root, '--file', 'shot.png',
-    '--surface', 'ios', '--route', '/payouts', '--note', 'n',
-    '--src', 'app/index.tsx', '--state', 'seed user A'], { cwd: repo });
-  const m = JSON.parse(readFileSync(join(root, 'manifest.json'), 'utf8'));
-  assert.equal(m.version, 2);
-  assert.match(m.commit, /^[0-9a-f]{7,}$/);
-  assert.equal(m.branch, 'main');
-  assert.deepEqual(m.shots[0].src, ['app/index.tsx']);
-  assert.equal(m.shots[0].state, 'seed user A');
-});
-
-test('collectCommands: project + home palettes, ns from dirs, _internals skipped, project wins', async () => {
-  const { collectCommands } = await import('../../../pkg/src/cli.ts');
-  const proj = join(makeTmp(), 'app');
-  const home = join(makeTmp(), '.claude');
-  const md = (p: string, desc?: string) => {
-    mkdirSync(join(p, '..'), { recursive: true });
-    writeFileSync(p, desc ? `---\nname: x\ndescription: "${desc}"\n---\nbody\n` : 'no frontmatter\n');
-  };
-  md(join(proj, '.claude/commands/deploy.md'), 'Deploy the app');
-  md(join(proj, '.claude/commands/db/reset.md'));
-  md(join(proj, '.claude/skills/review/SKILL.md'), 'Project review');
-  md(join(proj, '.claude/skills/git/_shared/SKILL.md'), 'internal');   // _dir → skipped
-  md(join(home, 'commands/prc.md'), 'Ensure an open PR exists');
-  md(join(home, 'skills/git/merge/SKILL.md'), 'Merge the current PR');
-  md(join(home, 'commands/deploy.md'), 'HOME deploy (must lose to project'); // collision → project wins
-  const cmds = collectCommands(proj, home);
-  assert.deepEqual(cmds, [
-    { c: '/db:reset' },
-    { c: '/deploy', d: 'Deploy the app' },
-    { c: '/git:merge', d: 'Merge the current PR', s: 'home' },
-    { c: '/prc', d: 'Ensure an open PR exists', s: 'home' },
-    { c: '/review', d: 'Project review' },
-  ]);
-  // Absent roots are fine (no .claude anywhere).
-  assert.deepEqual(collectCommands(makeTmp(), join(makeTmp(), 'nope')), []);
-});
-
-test('extractRoutes: monorepo workspace roots (apps/<name>/app, packages/<name>/src/app)', () => {
-  const routes = extractRoutes([
-    'apps/client/app/(tabs)/home.tsx',
-    'apps/client/app/payouts/index.tsx',
-    'apps/client/app/_layout.tsx',
-    'apps/client/lib/app/util.ts', // NOT a router root (app/ not at container root)
-    'packages/kiosk/src/app/scan.tsx',
-  ]);
-  const paths = routes.map((r) => r.p);
-  assert.deepEqual(paths, ['/home', '/payouts', '/scan']);
-});
-
-test('extractRoutes: per-root next mode — Next app beside an Expo app in one monorepo', () => {
-  const routes = extractRoutes([
-    'apps/web/app/pricing/page.tsx',   // Next app-router: only page.* are routes
-    'apps/web/app/pricing/layout.tsx', // not a route in next mode
-    'apps/client/app/jobs/[id].tsx',   // Expo root must NOT inherit next mode
-  ]);
-  const paths = routes.map((r) => r.p).sort();
-  assert.deepEqual(paths, ['/jobs/[id]', '/pricing']);
-});
-
-test('extractRoutes: cross-root route collision — first file in input order wins, duplicate dropped', () => {
-  const routes = extractRoutes([
-    'apps/web/app/index.tsx',
-    'apps/client/app/index.tsx', // same "/" — dropped
-    'apps/client/app/jobs.tsx',
-  ]);
-  assert.deepEqual(routes.map((r) => ({ p: r.p, f: r.f })), [
-    { p: '/', f: 'apps/web/app/index.tsx' },
-    { p: '/jobs', f: 'apps/client/app/jobs.tsx' },
-  ]);
-});