gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/tests/routing-history.test.ts

@@ -1,240 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import {
-  initRoutingHistory,
-  resetRoutingHistory,
-  recordOutcome,
-  recordFeedback,
-  getAdaptiveTierAdjustment,
-  clearRoutingHistory,
-  getRoutingHistory,
-} from "../routing-history.js";
-
-// ─── Test Setup ──────────────────────────────────────────────────────────────
-
-function makeTmpDir(): string {
-  const dir = join(tmpdir(), `gsd-routing-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-  return dir;
-}
-
-function cleanup(dir: string): void {
-  try { rmSync(dir, { recursive: true, force: true }); } catch {}
-  resetRoutingHistory();
-}
-
-// ─── recordOutcome ───────────────────────────────────────────────────────────
-
-test("recordOutcome tracks success and failure counts", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordOutcome("execute-task", "standard", true);
-    recordOutcome("execute-task", "standard", true);
-    recordOutcome("execute-task", "standard", false);
-
-    const history = getRoutingHistory();
-    assert.ok(history);
-    const pattern = history.patterns["execute-task"];
-    assert.ok(pattern);
-    assert.equal(pattern.standard.success, 2);
-    assert.equal(pattern.standard.fail, 1);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-test("recordOutcome tracks tag-specific patterns", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordOutcome("execute-task", "light", true, ["docs"]);
-
-    const history = getRoutingHistory();
-    assert.ok(history);
-    assert.ok(history.patterns["execute-task:docs"]);
-    assert.equal(history.patterns["execute-task:docs"].light.success, 1);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-test("recordOutcome applies rolling window", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    // Record 60 successes — should be capped to 50
-    for (let i = 0; i < 60; i++) {
-      recordOutcome("execute-task", "standard", true);
-    }
-
-    const history = getRoutingHistory();
-    assert.ok(history);
-    const total = history.patterns["execute-task"].standard.success +
-                  history.patterns["execute-task"].standard.fail;
-    assert.ok(total <= 50, `total ${total} should be <= 50`);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-// ─── getAdaptiveTierAdjustment ───────────────────────────────────────────────
-
-test("no adjustment when insufficient data", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordOutcome("execute-task", "light", false);
-    // Only 1 data point — not enough
-    const adj = getAdaptiveTierAdjustment("execute-task", "light");
-    assert.equal(adj, null);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-test("bumps tier when failure rate exceeds threshold", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    // Record high failure rate at light tier
-    recordOutcome("execute-task", "light", false);
-    recordOutcome("execute-task", "light", false);
-    recordOutcome("execute-task", "light", true);
-    // 2/3 = 66% failure rate > 20% threshold
-
-    const adj = getAdaptiveTierAdjustment("execute-task", "light");
-    assert.equal(adj, "standard");
-  } finally {
-    cleanup(dir);
-  }
-});
-
-test("no adjustment when success rate is high", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    for (let i = 0; i < 10; i++) {
-      recordOutcome("execute-task", "light", true);
-    }
-    const adj = getAdaptiveTierAdjustment("execute-task", "light");
-    assert.equal(adj, null);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-test("tag-specific patterns take precedence", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    // Base pattern has high success rate (tagged calls also count toward base)
-    for (let i = 0; i < 15; i++) {
-      recordOutcome("execute-task", "light", true);
-    }
-    // But docs-tagged tasks fail at light
-    recordOutcome("execute-task", "light", false, ["docs"]);
-    recordOutcome("execute-task", "light", false, ["docs"]);
-    recordOutcome("execute-task", "light", true, ["docs"]);
-
-    // With tags, should bump (docs pattern: 1/3 success = 66% failure)
-    const adj = getAdaptiveTierAdjustment("execute-task", "light", ["docs"]);
-    assert.equal(adj, "standard");
-
-    // Without tags, should not bump (base: 16/18 success = 11% failure)
-    const adjBase = getAdaptiveTierAdjustment("execute-task", "light");
-    assert.equal(adjBase, null);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-// ─── recordFeedback ──────────────────────────────────────────────────────────
-
-test("recordFeedback stores feedback entries", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
-
-    const history = getRoutingHistory();
-    assert.ok(history);
-    assert.equal(history.feedback.length, 1);
-    assert.equal(history.feedback[0].rating, "over");
-    assert.equal(history.feedback[0].tier, "standard");
-  } finally {
-    cleanup(dir);
-  }
-});
-
-test("recordFeedback 'under' increases failure count at tier", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordFeedback("execute-task", "M001/S01/T01", "light", "under");
-
-    const history = getRoutingHistory();
-    assert.ok(history);
-    // "under" adds 2 (FEEDBACK_WEIGHT) failures
-    assert.equal(history.patterns["execute-task"].light.fail, 2);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-test("recordFeedback 'over' increases success count at lower tier", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
-
-    const history = getRoutingHistory();
-    assert.ok(history);
-    // "over" at standard → adds 2 successes at light
-    assert.equal(history.patterns["execute-task"].light.success, 2);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-// ─── clearRoutingHistory ─────────────────────────────────────────────────────
-
-test("clearRoutingHistory resets all data", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordOutcome("execute-task", "light", true);
-    clearRoutingHistory(dir);
-
-    const history = getRoutingHistory();
-    assert.ok(history);
-    assert.deepEqual(history.patterns, {});
-    assert.deepEqual(history.feedback, []);
-  } finally {
-    cleanup(dir);
-  }
-});
-
-// ─── Persistence ─────────────────────────────────────────────────────────────
-
-test("routing history persists to disk and reloads", () => {
-  const dir = makeTmpDir();
-  try {
-    initRoutingHistory(dir);
-    recordOutcome("execute-task", "standard", true);
-    recordOutcome("execute-task", "standard", true);
-    resetRoutingHistory();
-
-    // Reload from disk
-    initRoutingHistory(dir);
-    const history = getRoutingHistory();
-    assert.ok(history);
-    assert.equal(history.patterns["execute-task"].standard.success, 2);
-  } finally {
-    cleanup(dir);
-  }
-});

package/dist/resources/extensions/gsd/tests/run-uat.test.ts

@@ -1,416 +0,0 @@
-// Tests for extractUatType — the core UAT classification primitive — plus
-// prompt template loading and dispatch precondition assertions (via
-// resolveSliceFile / extractUatType on real fixture files).
-//
-// Sections:
-//   (a)–(j)  extractUatType classification (17 assertions from T01)
-//   (k)      run-uat prompt template loading and content integrity (8 assertions)
-//   (l)      dispatch precondition assertions via resolveSliceFile (4 assertions)
-//   (m)      non-artifact UAT skip: human-experience UATs are not dispatched (1 assertion)
-//   (n)      stale replay guard: existing UAT-RESULT never re-dispatches (1 assertion)
-
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { tmpdir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-
-import { extractUatType } from '../files.ts';
-import { resolveSliceFile } from '../paths.ts';
-import { checkNeedsRunUat } from '../auto-prompts.ts';
-import { createTestContext } from './test-helpers.ts';
-
-// ─── Worktree-aware prompt loader ──────────────────────────────────────────
-// Resolves prompts relative to this test file so the worktree copy is used
-// instead of the main checkout copy (matches complete-milestone.test.ts pattern).
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const worktreePromptsDir = join(__dirname, '..', 'prompts');
-
-function loadPromptFromWorktree(name: string, vars: Record<string, string> = {}): string {
-  const path = join(worktreePromptsDir, `${name}.md`);
-  let content = readFileSync(path, 'utf-8');
-  for (const [key, value] of Object.entries(vars)) {
-    content = content.replaceAll(`{{${key}}}`, value);
-  }
-  return content.trim();
-}
-
-
-const { assertEq, assertTrue, report } = createTestContext();
-// ─── Fixture helpers ───────────────────────────────────────────────────────
-
-function createFixtureBase(): string {
-  const base = mkdtempSync(join(tmpdir(), 'gsd-run-uat-test-'));
-  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
-  return base;
-}
-
-function writeSliceFile(
-  base: string,
-  mid: string,
-  sid: string,
-  suffix: string,
-  content: string,
-): void {
-  const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, `${sid}-${suffix}.md`), content);
-}
-
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
-}
-
-function makeUatContent(mode: string): string {
-  return `# UAT File\n\n## UAT Type\n\n- UAT mode: ${mode}\n- Some other bullet: value\n`;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-async function main(): Promise<void> {
-
-  // ─── (a) artifact-driven ──────────────────────────────────────────────────
-  console.log('\n── (a) artifact-driven');
-
-  assertEq(
-    extractUatType(makeUatContent('artifact-driven')),
-    'artifact-driven',
-    'plain artifact-driven → artifact-driven',
-  );
-
-  assertEq(
-    extractUatType('## UAT Type\n\n- UAT mode: artifact-driven\n'),
-    'artifact-driven',
-    'minimal content, artifact-driven',
-  );
-
-  // ─── (b) live-runtime ─────────────────────────────────────────────────────
-  console.log('\n── (b) live-runtime');
-
-  assertEq(
-    extractUatType(makeUatContent('live-runtime')),
-    'live-runtime',
-    'plain live-runtime → live-runtime',
-  );
-
-  // ─── (c) human-experience ─────────────────────────────────────────────────
-  console.log('\n── (c) human-experience');
-
-  assertEq(
-    extractUatType(makeUatContent('human-experience')),
-    'human-experience',
-    'plain human-experience → human-experience',
-  );
-
-  // ─── (d) mixed standalone ─────────────────────────────────────────────────
-  console.log('\n── (d) mixed standalone');
-
-  assertEq(
-    extractUatType(makeUatContent('mixed')),
-    'mixed',
-    'plain mixed → mixed',
-  );
-
-  // ─── (e) mixed with parenthetical ─────────────────────────────────────────
-  console.log('\n── (e) mixed parenthetical');
-
-  assertEq(
-    extractUatType(makeUatContent('mixed (artifact-driven + live-runtime)')),
-    'mixed',
-    'mixed (artifact-driven + live-runtime) → mixed (leading keyword only)',
-  );
-
-  assertEq(
-    extractUatType(makeUatContent('mixed (some other description)')),
-    'mixed',
-    'mixed with arbitrary parenthetical → mixed',
-  );
-
-  // ─── (f) missing ## UAT Type section ──────────────────────────────────────
-  console.log('\n── (f) missing UAT Type section');
-
-  assertEq(
-    extractUatType('# UAT File\n\n## Overview\n\nSome content.\n'),
-    undefined,
-    'no ## UAT Type section → undefined',
-  );
-
-  assertEq(
-    extractUatType(''),
-    undefined,
-    'empty content → undefined',
-  );
-
-  // ─── (g) ## UAT Type present but no UAT mode: bullet ─────────────────────
-  console.log('\n── (g) UAT Type section present, no UAT mode: bullet');
-
-  assertEq(
-    extractUatType('## UAT Type\n\n- Some other bullet: value\n- Another bullet\n'),
-    undefined,
-    'section present but no UAT mode: bullet → undefined',
-  );
-
-  assertEq(
-    extractUatType('## UAT Type\n\n'),
-    undefined,
-    'section present but empty → undefined',
-  );
-
-  // ─── (h) unknown keyword ──────────────────────────────────────────────────
-  console.log('\n── (h) unknown keyword');
-
-  assertEq(
-    extractUatType(makeUatContent('automated')),
-    undefined,
-    'unknown keyword automated → undefined',
-  );
-
-  assertEq(
-    extractUatType(makeUatContent('fully-automated')),
-    undefined,
-    'unknown keyword fully-automated → undefined',
-  );
-
-  // ─── (i) extra whitespace around value ────────────────────────────────────
-  console.log('\n── (i) extra whitespace');
-
-  assertEq(
-    extractUatType('## UAT Type\n\n- UAT mode:   artifact-driven   \n'),
-    'artifact-driven',
-    'leading/trailing whitespace around value → still classified correctly',
-  );
-
-  assertEq(
-    extractUatType('## UAT Type\n\n- UAT mode:  mixed (artifact-driven + live-runtime)  \n'),
-    'mixed',
-    'whitespace around mixed parenthetical → mixed',
-  );
-
-  // ─── (j) case sensitivity ─────────────────────────────────────────────────
-  console.log('\n── (j) case sensitivity');
-
-  assertEq(
-    extractUatType(makeUatContent('Artifact-Driven')),
-    'artifact-driven',
-    'Artifact-Driven (title case) → artifact-driven (function lowercases before matching)',
-  );
-
-  assertEq(
-    extractUatType(makeUatContent('MIXED')),
-    'mixed',
-    'MIXED (upper case) → mixed (function lowercases before matching)',
-  );
-
-  // ─── (k) prompt template loading and content integrity ────────────────────
-  console.log('\n── (k) run-uat prompt template');
-
-  const milestoneId = 'M001';
-  const sliceId = 'S01';
-  const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
-  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
-  const uatType = 'artifact-driven';
-  const inlinedContext = '<!-- no context -->';
-
-  let promptResult: string | undefined;
-  let promptThrew = false;
-  try {
-    promptResult = loadPromptFromWorktree('run-uat', {
-      workingDirectory: '/tmp/test-project',
-      milestoneId,
-      sliceId,
-      uatPath,
-      uatResultPath,
-      uatType,
-      inlinedContext,
-    });
-  } catch {
-    promptThrew = true;
-  }
-
-  assertTrue(!promptThrew, 'loadPromptFromWorktree("run-uat", vars) does not throw');
-  assertTrue(
-    typeof promptResult === 'string' && promptResult.length > 0,
-    'run-uat prompt result is a non-empty string',
-  );
-  assertTrue(
-    promptResult?.includes(milestoneId) ?? false,
-    `prompt contains milestoneId value "${milestoneId}" after substitution`,
-  );
-  assertTrue(
-    promptResult?.includes(sliceId) ?? false,
-    `prompt contains sliceId value "${sliceId}" after substitution`,
-  );
-  assertTrue(
-    promptResult?.includes(uatResultPath) ?? false,
-    `prompt contains uatResultPath value after substitution`,
-  );
-  assertTrue(
-    !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
-    'no unreplaced {{...}} tokens remain after variable substitution',
-  );
-  assertTrue(
-    /artifact|execute|run/i.test(promptResult ?? ''),
-    'prompt contains artifact-driven execution language (artifact/execute/run)',
-  );
-  assertTrue(
-    !/surfaced for human review/i.test(promptResult ?? ''),
-    'prompt does not contain "surfaced for human review" (non-artifact UATs are skipped, not dispatched)',
-  );
-
-  // ─── (l) dispatch precondition assertions via resolveSliceFile ────────────
-  console.log('\n── (l) dispatch preconditions via resolveSliceFile');
-
-  // State A: UAT file exists, UAT-RESULT file does NOT — triggers dispatch
-  {
-    const base = createFixtureBase();
-    const uatContent = makeUatContent('artifact-driven');
-    try {
-      writeSliceFile(base, 'M001', 'S01', 'UAT', uatContent);
-
-      const uatFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT');
-      assertTrue(
-        uatFilePath !== null,
-        'resolveSliceFile(..., "UAT") returns non-null when UAT file exists (dispatch trigger state)',
-      );
-
-      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assertEq(
-        uatResultFilePath,
-        null,
-        'resolveSliceFile(..., "UAT-RESULT") returns null when result file missing (dispatch trigger state)',
-      );
-
-      // End-to-end: file content → parse → classify
-      const rawContent = readFileSync(uatFilePath!, 'utf-8');
-      assertEq(
-        extractUatType(rawContent),
-        'artifact-driven',
-        'extractUatType on fixture UAT file returns expected type (end-to-end data flow)',
-      );
-    } finally {
-      cleanup(base);
-    }
-  }
-
-  // State B: UAT-RESULT file exists — dispatch is skipped (idempotent)
-  {
-    const base = createFixtureBase();
-    try {
-      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '# UAT Result\n\nverdict: PASS\n');
-
-      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assertTrue(
-        uatResultFilePath !== null,
-        'resolveSliceFile(..., "UAT-RESULT") returns non-null when result file exists (idempotent skip state)',
-      );
-    } finally {
-      cleanup(base);
-    }
-  }
-
-  // ─── (m) non-artifact UATs are skipped (not dispatched) ─────────────────
-  console.log('\n── (m) non-artifact UAT skip');
-
-  {
-    const base = createFixtureBase();
-    try {
-      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
-      mkdirSync(roadmapDir, { recursive: true });
-      writeFileSync(
-        join(roadmapDir, 'M001-ROADMAP.md'),
-        [
-          '# M001: Test roadmap',
-          '',
-          '## Slices',
-          '',
-          '- [x] **S01: First slice** `risk:low` `depends:[]`',
-          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
-          '',
-          '## Boundary Map',
-          '',
-        ].join('\n'),
-      );
-
-      // human-experience UAT — should not dispatch
-      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('human-experience'));
-
-      const state = {
-        activeMilestone: { id: 'M001', title: 'Test roadmap' },
-        activeSlice: { id: 'S02', title: 'Next slice' },
-        activeTask: null,
-        phase: 'planning',
-        recentDecisions: [],
-        blockers: [],
-        nextAction: 'Plan S02',
-        registry: [],
-      } as const;
-
-      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
-      assertEq(
-        result,
-        null,
-        'human-experience UAT is skipped — auto-mode only dispatches artifact-driven UATs',
-      );
-    } finally {
-      cleanup(base);
-    }
-  }
-
-  // ─── (n) existing UAT-RESULT never re-dispatches ──────────────────────
-  console.log('\n── (n) stale replay guard');
-
-  {
-    const base = createFixtureBase();
-    try {
-      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
-      mkdirSync(roadmapDir, { recursive: true });
-      writeFileSync(
-        join(roadmapDir, 'M001-ROADMAP.md'),
-        [
-          '# M001: Test roadmap',
-          '',
-          '## Slices',
-          '',
-          '- [x] **S01: First slice** `risk:low` `depends:[]`',
-          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
-          '',
-          '## Boundary Map',
-          '',
-        ].join('\n'),
-      );
-
-      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '---\nverdict: FAIL\n---\n');
-
-      const state = {
-        activeMilestone: { id: 'M001', title: 'Test roadmap' },
-        activeSlice: { id: 'S02', title: 'Next slice' },
-        activeTask: null,
-        phase: 'planning',
-        recentDecisions: [],
-        blockers: [],
-        nextAction: 'Plan S02',
-        registry: [],
-      } as const;
-
-      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
-      assertEq(
-        result,
-        null,
-        'existing UAT-RESULT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
-      );
-    } finally {
-      cleanup(base);
-    }
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});