@izkac/forgekit 0.3.12 → 0.3.13

package/src/resolve-model.test.mjs

@@ -1,194 +1,194 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { Writable } from 'node:stream';
-import {
-  DEFAULTS_PATH,
-  deepMerge,
-  detectAgent,
-  parseArgs,
-  resolveFromConfig,
-  resolveModel,
-  runResolveModel,
-} from './resolve-model.mjs';
-import { getEffectiveBilling, runSetModels, writeLocalBilling } from './set-models.mjs';
-
-function tmp(prefix) {
-  return fs.mkdtempSync(path.join(tmpdir(), prefix));
-}
-
-function capture() {
-  let text = '';
-  const stream = new Writable({
-    write(chunk, _enc, cb) {
-      text += String(chunk);
-      cb();
-    },
-  });
-  return {
-    stream,
-    text: () => text,
-  };
-}
-
-test('parseArgs requires known flags', () => {
-  const opts = parseArgs(['--tier', 'fast', '--billing', 'included', '--agent', 'cursor']);
-  assert.equal(opts.tier, 'fast');
-  assert.equal(opts.billing, 'included');
-  assert.equal(opts.agent, 'cursor');
-  assert.throws(() => parseArgs(['--nope']), /Unknown argument/);
-});
-
-test('detectAgent prefers explicit host env', () => {
-  assert.equal(detectAgent({ CURSOR_AGENT: '1' }).agent, 'cursor');
-  assert.equal(detectAgent({ CLAUDE_CODE: '1' }).agent, 'claude-code');
-  assert.equal(detectAgent({ CODEX_HOME: '/tmp/codex' }).agent, 'codex');
-  assert.equal(detectAgent({}).detected, false);
-  assert.equal(detectAgent({}).agent, 'cursor');
-});
-
-test('deepMerge overlays nested agent maps', () => {
-  const merged = deepMerge(
-    { billing: 'included', agents: { cursor: { included: { fast: 'inherit' } } } },
-    { billing: 'metered', agents: { cursor: { included: { standard: 'inherit' } } } },
-  );
-  assert.equal(merged.billing, 'metered');
-  assert.deepEqual(merged.agents.cursor.included, {
-    fast: 'inherit',
-    standard: 'inherit',
-  });
-});
-
-test('cursor included resolves to omitModel', () => {
-  const result = resolveModel({
-    tier: 'standard',
-    agent: 'cursor',
-    billing: 'included',
-    defaultsPath: DEFAULTS_PATH,
-    env: {},
-  });
-  assert.equal(result.omitModel, true);
-  assert.equal(result.model, null);
-  assert.equal(result.billing, 'included');
-});
-
-test('cursor metered capable returns explicit slug', () => {
-  const result = resolveModel({
-    tier: 'capable',
-    agent: 'cursor',
-    billing: 'metered',
-    defaultsPath: DEFAULTS_PATH,
-    env: {},
-  });
-  assert.equal(result.omitModel, false);
-  assert.equal(result.model, 'claude-opus-4-8-thinking-high');
-});
-
-test('claude-code included fast uses haiku', () => {
-  const result = resolveModel({
-    tier: 'fast',
-    agent: 'claude-code',
-    billing: 'included',
-    defaultsPath: DEFAULTS_PATH,
-    env: {},
-  });
-  assert.equal(result.model, 'haiku');
-  assert.equal(result.omitModel, false);
-});
-
-test('local billing override changes default lane', () => {
-  const dir = tmp('forge-models-');
-  const forgeDir = path.join(dir, '.forge');
-  writeLocalBilling({ forgeDir, billing: 'metered' });
-
-  const result = resolveModel({
-    tier: 'standard',
-    agent: 'cursor',
-    defaultsPath: DEFAULTS_PATH,
-    forgeDir,
-    cwd: dir,
-    env: {},
-  });
-  assert.equal(result.billing, 'metered');
-  assert.equal(result.omitModel, false);
-  assert.equal(result.model, 'claude-sonnet-5-thinking-high');
-});
-
-test('missing cell fails clearly', () => {
-  assert.throws(
-    () =>
-      resolveFromConfig(
-        { agents: { cursor: { included: {} } } },
-        { agent: 'cursor', billing: 'included', tier: 'fast' },
-      ),
-    /Missing cell for \(cursor, included, fast\)/,
-  );
-});
-
-test('runResolveModel prints JSON', () => {
-  const out = capture();
-  const err = capture();
-  const code = runResolveModel(
-    ['--tier', 'fast', '--agent', 'codex', '--billing', 'included'],
-    { stdout: out.stream, stderr: err.stream },
-  );
-  assert.equal(code, 0);
-  const parsed = JSON.parse(out.text());
-  assert.equal(parsed.agent, 'codex');
-  assert.equal(parsed.omitModel, true);
-});
-
-test('set-models writes and getEffectiveBilling reads', () => {
-  const dir = tmp('forge-set-models-');
-  const forgeDir = path.join(dir, '.forge');
-  const out = capture();
-  const err = capture();
-  const code = runSetModels(['metered', '--forge-dir', forgeDir], {
-    cwd: dir,
-    stdout: out.stream,
-    stderr: err.stream,
-  });
-  assert.equal(code, 0);
-  assert.match(out.text(), /billing=metered/);
-
-  const effective = getEffectiveBilling({
-    forgeDir,
-    defaultsPath: DEFAULTS_PATH,
-    cwd: dir,
-  });
-  assert.equal(effective.billing, 'metered');
-  assert.equal(effective.localExists, true);
-});
-
-test('getEffectiveBilling defaults to included without local file', () => {
-  const dir = tmp('forge-get-billing-');
-  const forgeDir = path.join(dir, '.forge');
-  fs.mkdirSync(forgeDir, { recursive: true });
-  const effective = getEffectiveBilling({
-    forgeDir,
-    defaultsPath: DEFAULTS_PATH,
-    cwd: dir,
-  });
-  assert.equal(effective.billing, 'included');
-  assert.equal(effective.localExists, false);
-});
-
-test('forge:models get without local file explains no write', () => {
-  const dir = tmp('forge-models-get-');
-  const forgeDir = path.join(dir, '.forge');
-  fs.mkdirSync(forgeDir, { recursive: true });
-  const out = capture();
-  const err = capture();
-  const code = runSetModels(['--forge-dir', forgeDir], {
-    cwd: dir,
-    stdout: out.stream,
-    stderr: err.stream,
-  });
-  assert.equal(code, 0);
-  assert.match(out.text(), /billing=included/);
-  assert.match(out.text(), /local=\(none/);
-  assert.match(out.text(), /writes \.forge\/models\.local\.json/);
-  assert.equal(fs.existsSync(path.join(forgeDir, 'models.local.json')), false);
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { Writable } from 'node:stream';
+import {
+  DEFAULTS_PATH,
+  deepMerge,
+  detectAgent,
+  parseArgs,
+  resolveFromConfig,
+  resolveModel,
+  runResolveModel,
+} from './resolve-model.mjs';
+import { getEffectiveBilling, runSetModels, writeLocalBilling } from './set-models.mjs';
+
+function tmp(prefix) {
+  return fs.mkdtempSync(path.join(tmpdir(), prefix));
+}
+
+function capture() {
+  let text = '';
+  const stream = new Writable({
+    write(chunk, _enc, cb) {
+      text += String(chunk);
+      cb();
+    },
+  });
+  return {
+    stream,
+    text: () => text,
+  };
+}
+
+test('parseArgs requires known flags', () => {
+  const opts = parseArgs(['--tier', 'fast', '--billing', 'included', '--agent', 'cursor']);
+  assert.equal(opts.tier, 'fast');
+  assert.equal(opts.billing, 'included');
+  assert.equal(opts.agent, 'cursor');
+  assert.throws(() => parseArgs(['--nope']), /Unknown argument/);
+});
+
+test('detectAgent prefers explicit host env', () => {
+  assert.equal(detectAgent({ CURSOR_AGENT: '1' }).agent, 'cursor');
+  assert.equal(detectAgent({ CLAUDE_CODE: '1' }).agent, 'claude-code');
+  assert.equal(detectAgent({ CODEX_HOME: '/tmp/codex' }).agent, 'codex');
+  assert.equal(detectAgent({}).detected, false);
+  assert.equal(detectAgent({}).agent, 'cursor');
+});
+
+test('deepMerge overlays nested agent maps', () => {
+  const merged = deepMerge(
+    { billing: 'included', agents: { cursor: { included: { fast: 'inherit' } } } },
+    { billing: 'metered', agents: { cursor: { included: { standard: 'inherit' } } } },
+  );
+  assert.equal(merged.billing, 'metered');
+  assert.deepEqual(merged.agents.cursor.included, {
+    fast: 'inherit',
+    standard: 'inherit',
+  });
+});
+
+test('cursor included resolves to omitModel', () => {
+  const result = resolveModel({
+    tier: 'standard',
+    agent: 'cursor',
+    billing: 'included',
+    defaultsPath: DEFAULTS_PATH,
+    env: {},
+  });
+  assert.equal(result.omitModel, true);
+  assert.equal(result.model, null);
+  assert.equal(result.billing, 'included');
+});
+
+test('cursor metered capable returns explicit slug', () => {
+  const result = resolveModel({
+    tier: 'capable',
+    agent: 'cursor',
+    billing: 'metered',
+    defaultsPath: DEFAULTS_PATH,
+    env: {},
+  });
+  assert.equal(result.omitModel, false);
+  assert.equal(result.model, 'claude-opus-4-8-thinking-high');
+});
+
+test('claude-code included fast uses haiku', () => {
+  const result = resolveModel({
+    tier: 'fast',
+    agent: 'claude-code',
+    billing: 'included',
+    defaultsPath: DEFAULTS_PATH,
+    env: {},
+  });
+  assert.equal(result.model, 'haiku');
+  assert.equal(result.omitModel, false);
+});
+
+test('local billing override changes default lane', () => {
+  const dir = tmp('forge-models-');
+  const forgeDir = path.join(dir, '.forge');
+  writeLocalBilling({ forgeDir, billing: 'metered' });
+
+  const result = resolveModel({
+    tier: 'standard',
+    agent: 'cursor',
+    defaultsPath: DEFAULTS_PATH,
+    forgeDir,
+    cwd: dir,
+    env: {},
+  });
+  assert.equal(result.billing, 'metered');
+  assert.equal(result.omitModel, false);
+  assert.equal(result.model, 'claude-sonnet-5-thinking-high');
+});
+
+test('missing cell fails clearly', () => {
+  assert.throws(
+    () =>
+      resolveFromConfig(
+        { agents: { cursor: { included: {} } } },
+        { agent: 'cursor', billing: 'included', tier: 'fast' },
+      ),
+    /Missing cell for \(cursor, included, fast\)/,
+  );
+});
+
+test('runResolveModel prints JSON', () => {
+  const out = capture();
+  const err = capture();
+  const code = runResolveModel(
+    ['--tier', 'fast', '--agent', 'codex', '--billing', 'included'],
+    { stdout: out.stream, stderr: err.stream },
+  );
+  assert.equal(code, 0);
+  const parsed = JSON.parse(out.text());
+  assert.equal(parsed.agent, 'codex');
+  assert.equal(parsed.omitModel, true);
+});
+
+test('set-models writes and getEffectiveBilling reads', () => {
+  const dir = tmp('forge-set-models-');
+  const forgeDir = path.join(dir, '.forge');
+  const out = capture();
+  const err = capture();
+  const code = runSetModels(['metered', '--forge-dir', forgeDir], {
+    cwd: dir,
+    stdout: out.stream,
+    stderr: err.stream,
+  });
+  assert.equal(code, 0);
+  assert.match(out.text(), /billing=metered/);
+
+  const effective = getEffectiveBilling({
+    forgeDir,
+    defaultsPath: DEFAULTS_PATH,
+    cwd: dir,
+  });
+  assert.equal(effective.billing, 'metered');
+  assert.equal(effective.localExists, true);
+});
+
+test('getEffectiveBilling defaults to included without local file', () => {
+  const dir = tmp('forge-get-billing-');
+  const forgeDir = path.join(dir, '.forge');
+  fs.mkdirSync(forgeDir, { recursive: true });
+  const effective = getEffectiveBilling({
+    forgeDir,
+    defaultsPath: DEFAULTS_PATH,
+    cwd: dir,
+  });
+  assert.equal(effective.billing, 'included');
+  assert.equal(effective.localExists, false);
+});
+
+test('forge:models get without local file explains no write', () => {
+  const dir = tmp('forge-models-get-');
+  const forgeDir = path.join(dir, '.forge');
+  fs.mkdirSync(forgeDir, { recursive: true });
+  const out = capture();
+  const err = capture();
+  const code = runSetModels(['--forge-dir', forgeDir], {
+    cwd: dir,
+    stdout: out.stream,
+    stderr: err.stream,
+  });
+  assert.equal(code, 0);
+  assert.match(out.text(), /billing=included/);
+  assert.match(out.text(), /local=\(none/);
+  assert.match(out.text(), /writes \.forge\/models\.local\.json/);
+  assert.equal(fs.existsSync(path.join(forgeDir, 'models.local.json')), false);
+});

package/src/review/cli.test.mjs

@@ -1,117 +1,117 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { parseArgs as parseNewArgs, runNew } from './new-review.mjs';
-import { parseArgs as parseRenderArgs, runRender } from './render.mjs';
-import { validateReport } from './lib.mjs';
-
-const FIXED_NOW = new Date('2026-06-05T16:00:00.000Z');
-const stubGit = () => ({ baseSha: 'base000', headSha: 'head111' });
-
-function tmp(prefix) {
-  return fs.mkdtempSync(path.join(tmpdir(), prefix));
-}
-
-// --- new-review ---
-
-test('runNew scaffolds a schema-valid skeleton with git SHAs', () => {
-  const dir = tmp('tmp-new-');
-  try {
-    const opts = parseNewArgs(['mercury-vat', '--type', 'branch']);
-    const result = runNew(opts, { now: FIXED_NOW, cwd: dir, gitImpl: stubGit });
-    assert.equal(result.exitCode, 0, result.message);
-    assert.ok(result.jsonPath.endsWith('20260605T160000Z-mercury-vat-review.json'));
-    const report = JSON.parse(fs.readFileSync(result.jsonPath, 'utf8'));
-    assert.equal(report.review_id, '20260605T160000Z-mercury-vat');
-    assert.equal(report.scope.base_sha, 'base000');
-    assert.equal(report.scope.head_sha, 'head111');
-    assert.equal(report.lenses.length, 9);
-    assert.equal(validateReport(report).ok, true);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('runNew refuses to overwrite an existing report', () => {
-  const dir = tmp('tmp-new-');
-  try {
-    const opts = parseNewArgs(['dup-scope', '--no-git']);
-    assert.equal(runNew(opts, { now: FIXED_NOW, cwd: dir }).exitCode, 0);
-    const second = runNew(opts, { now: FIXED_NOW, cwd: dir });
-    assert.equal(second.exitCode, 1);
-    assert.ok(second.message.includes('refusing to overwrite'));
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('runNew rejects reverify without --parent', () => {
-  const dir = tmp('tmp-new-');
-  try {
-    const opts = parseNewArgs(['x', '--kind', 'reverify', '--no-git']);
-    const result = runNew(opts, { now: FIXED_NOW, cwd: dir });
-    assert.equal(result.exitCode, 1);
-    assert.ok(result.message.includes('reverify'));
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('new-review parseArgs splits comma lists and flags', () => {
-  const opts = parseNewArgs(['scope', '--lenses', 'security,correctness', '--paths', 'a.ts,b.ts', '--no-git']);
-  assert.deepEqual(opts.lenses, ['security', 'correctness']);
-  assert.deepEqual(opts.paths, ['a.ts', 'b.ts']);
-  assert.equal(opts.git, false);
-});
-
-// --- render ---
-
-test('runRender writes paired .md from JSON', () => {
-  const dir = tmp('tmp-render-');
-  try {
-    const report = {
-      review_id: '20260605T160000Z-x',
-      kind: 'review',
-      created_at: '2026-06-05T16:00:00.000Z',
-      scope: { type: 'file', description: 'x.ts' },
-      lenses: ['security'],
-      summary: { tentative_count: 1, confirmed: 1, headline: 'one confirmed' },
-      findings: [
-        {
-          id: 'F-001',
-          lens: 'security',
-          location: 'x.ts:1',
-          claim: 'auth bypass',
-          severity: 'critical',
-          verdict: 'confirmed',
-          verdict_reason: 'real',
-        },
-      ],
-    };
-    const jsonPath = path.join(dir, '20260605T160000Z-x-review.json');
-    fs.writeFileSync(jsonPath, JSON.stringify(report));
-    const opts = parseRenderArgs(['--file', jsonPath]);
-    const result = runRender(opts, dir);
-    assert.equal(result.exitCode, 0, result.message);
-    const md = fs.readFileSync(jsonPath.replace(/\.json$/, '.md'), 'utf8');
-    assert.ok(md.includes('## Critical'));
-    assert.ok(md.includes('one confirmed'));
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('runRender fails on an invalid report', () => {
-  const dir = tmp('tmp-render-');
-  try {
-    const jsonPath = path.join(dir, '20260605T160000Z-bad-review.json');
-    fs.writeFileSync(jsonPath, JSON.stringify({ kind: 'review' }));
-    const result = runRender(parseRenderArgs(['--file', jsonPath]), dir);
-    assert.equal(result.exitCode, 1);
-    assert.ok(result.message.includes('validation failed'));
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseArgs as parseNewArgs, runNew } from './new-review.mjs';
+import { parseArgs as parseRenderArgs, runRender } from './render.mjs';
+import { validateReport } from './lib.mjs';
+
+const FIXED_NOW = new Date('2026-06-05T16:00:00.000Z');
+const stubGit = () => ({ baseSha: 'base000', headSha: 'head111' });
+
+function tmp(prefix) {
+  return fs.mkdtempSync(path.join(tmpdir(), prefix));
+}
+
+// --- new-review ---
+
+test('runNew scaffolds a schema-valid skeleton with git SHAs', () => {
+  const dir = tmp('tmp-new-');
+  try {
+    const opts = parseNewArgs(['mercury-vat', '--type', 'branch']);
+    const result = runNew(opts, { now: FIXED_NOW, cwd: dir, gitImpl: stubGit });
+    assert.equal(result.exitCode, 0, result.message);
+    assert.ok(result.jsonPath.endsWith('20260605T160000Z-mercury-vat-review.json'));
+    const report = JSON.parse(fs.readFileSync(result.jsonPath, 'utf8'));
+    assert.equal(report.review_id, '20260605T160000Z-mercury-vat');
+    assert.equal(report.scope.base_sha, 'base000');
+    assert.equal(report.scope.head_sha, 'head111');
+    assert.equal(report.lenses.length, 9);
+    assert.equal(validateReport(report).ok, true);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('runNew refuses to overwrite an existing report', () => {
+  const dir = tmp('tmp-new-');
+  try {
+    const opts = parseNewArgs(['dup-scope', '--no-git']);
+    assert.equal(runNew(opts, { now: FIXED_NOW, cwd: dir }).exitCode, 0);
+    const second = runNew(opts, { now: FIXED_NOW, cwd: dir });
+    assert.equal(second.exitCode, 1);
+    assert.ok(second.message.includes('refusing to overwrite'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('runNew rejects reverify without --parent', () => {
+  const dir = tmp('tmp-new-');
+  try {
+    const opts = parseNewArgs(['x', '--kind', 'reverify', '--no-git']);
+    const result = runNew(opts, { now: FIXED_NOW, cwd: dir });
+    assert.equal(result.exitCode, 1);
+    assert.ok(result.message.includes('reverify'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('new-review parseArgs splits comma lists and flags', () => {
+  const opts = parseNewArgs(['scope', '--lenses', 'security,correctness', '--paths', 'a.ts,b.ts', '--no-git']);
+  assert.deepEqual(opts.lenses, ['security', 'correctness']);
+  assert.deepEqual(opts.paths, ['a.ts', 'b.ts']);
+  assert.equal(opts.git, false);
+});
+
+// --- render ---
+
+test('runRender writes paired .md from JSON', () => {
+  const dir = tmp('tmp-render-');
+  try {
+    const report = {
+      review_id: '20260605T160000Z-x',
+      kind: 'review',
+      created_at: '2026-06-05T16:00:00.000Z',
+      scope: { type: 'file', description: 'x.ts' },
+      lenses: ['security'],
+      summary: { tentative_count: 1, confirmed: 1, headline: 'one confirmed' },
+      findings: [
+        {
+          id: 'F-001',
+          lens: 'security',
+          location: 'x.ts:1',
+          claim: 'auth bypass',
+          severity: 'critical',
+          verdict: 'confirmed',
+          verdict_reason: 'real',
+        },
+      ],
+    };
+    const jsonPath = path.join(dir, '20260605T160000Z-x-review.json');
+    fs.writeFileSync(jsonPath, JSON.stringify(report));
+    const opts = parseRenderArgs(['--file', jsonPath]);
+    const result = runRender(opts, dir);
+    assert.equal(result.exitCode, 0, result.message);
+    const md = fs.readFileSync(jsonPath.replace(/\.json$/, '.md'), 'utf8');
+    assert.ok(md.includes('## Critical'));
+    assert.ok(md.includes('one confirmed'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('runRender fails on an invalid report', () => {
+  const dir = tmp('tmp-render-');
+  try {
+    const jsonPath = path.join(dir, '20260605T160000Z-bad-review.json');
+    fs.writeFileSync(jsonPath, JSON.stringify({ kind: 'review' }));
+    const result = runRender(parseRenderArgs(['--file', jsonPath]), dir);
+    assert.equal(result.exitCode, 1);
+    assert.ok(result.message.includes('validation failed'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});