gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/paths.test.ts

@@ -1,13 +1,11 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 
 import { gsdRoot, _clearGsdRootCache } from "../paths.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
 /** Create a tmp dir and resolve symlinks + 8.3 short names (macOS /var→/private/var, Windows RUNNER~1→runneradmin). */
 function tmp(): string {
   const p = mkdtempSync(join(tmpdir(), "gsd-paths-test-"));
@@ -23,91 +21,78 @@ function initGit(dir: string): void {
   spawnSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: dir });
 }
 
-// ── tests ──────────────────────────────────────────────────────────────────
-
-{
-  // Case 1: .gsd exists at basePath — fast path
-  const root = tmp();
-  try {
-    mkdirSync(join(root, ".gsd"));
-    _clearGsdRootCache();
-    const result = gsdRoot(root);
-    assertEq(result, join(root, ".gsd"), "fast path: returns basePath/.gsd");
-  } finally { cleanup(root); }
-}
-
-{
-  // Case 2: .gsd exists at git root, cwd is a subdirectory
-  const root = tmp();
-  try {
-    initGit(root);
-    mkdirSync(join(root, ".gsd"));
-    const sub = join(root, "src", "deep");
-    mkdirSync(sub, { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(sub);
-    assertEq(result, join(root, ".gsd"), "git-root probe: finds .gsd at git root from subdirectory");
-  } finally { cleanup(root); }
-}
+describe('paths', () => {
+  test('Case 1: .gsd exists at basePath — fast path', () => {
+    const root = tmp();
+    try {
+      mkdirSync(join(root, ".gsd"));
+      _clearGsdRootCache();
+      const result = gsdRoot(root);
+      assert.deepStrictEqual(result, join(root, ".gsd"), "fast path: returns basePath/.gsd");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 3: .gsd in an ancestor — walk-up finds it (git repo with no .gsd at root)
-  const root = tmp();
-  try {
-    // Init a git repo so git probe returns root — but put .gsd one level deeper
-    // to force the walk-up path: root/project/.gsd, cwd = root/project/src/deep
-    initGit(root);
-    const project = join(root, "project");
-    mkdirSync(join(project, ".gsd"), { recursive: true });
-    const deep = join(project, "src", "deep");
-    mkdirSync(deep, { recursive: true });
-    _clearGsdRootCache();
-    // git probe returns root (no .gsd there), so walk-up takes over and finds project/.gsd
-    const result = gsdRoot(deep);
-    assertEq(result, join(project, ".gsd"), "walk-up: finds .gsd in ancestor when git root has none");
-  } finally { cleanup(root); }
-}
+  test('Case 2: .gsd exists at git root, cwd is a subdirectory', () => {
+    const root = tmp();
+    try {
+      initGit(root);
+      mkdirSync(join(root, ".gsd"));
+      const sub = join(root, "src", "deep");
+      mkdirSync(sub, { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(sub);
+      assert.deepStrictEqual(result, join(root, ".gsd"), "git-root probe: finds .gsd at git root from subdirectory");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 4: .gsd nowhere — fallback returns original basePath/.gsd
-  // Use an isolated git repo so we fully control the environment above basePath
-  const root = tmp();
-  try {
-    initGit(root);                          // git root = root, no .gsd anywhere
-    const sub = join(root, "src");
-    mkdirSync(sub, { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(sub);
-    // git probe finds root (no .gsd), walk-up finds nothing → fallback = sub/.gsd
-    assertEq(result, join(sub, ".gsd"), "fallback: returns basePath/.gsd when .gsd not found anywhere");
-  } finally { cleanup(root); }
-}
+  test('Case 3: .gsd in an ancestor — walk-up finds it', () => {
+    const root = tmp();
+    try {
+      initGit(root);
+      const project = join(root, "project");
+      mkdirSync(join(project, ".gsd"), { recursive: true });
+      const deep = join(project, "src", "deep");
+      mkdirSync(deep, { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(deep);
+      assert.deepStrictEqual(result, join(project, ".gsd"), "walk-up: finds .gsd in ancestor when git root has none");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 5: cache — second call returns same value without re-probing
-  const root = tmp();
-  try {
-    mkdirSync(join(root, ".gsd"));
-    _clearGsdRootCache();
-    const first = gsdRoot(root);
-    const second = gsdRoot(root);
-    assertEq(first, second, "cache: same result returned on second call");
-    assertTrue(first === second, "cache: identity check (same string)");
-  } finally { cleanup(root); }
-}
+  test('Case 4: .gsd nowhere — fallback returns original basePath/.gsd', () => {
+    const root = tmp();
+    try {
+      initGit(root);
+      const sub = join(root, "src");
+      mkdirSync(sub, { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(sub);
+      assert.deepStrictEqual(result, join(sub, ".gsd"), "fallback: returns basePath/.gsd when .gsd not found anywhere");
+    } finally { cleanup(root); }
+  });
 
-{
-  // Case 6: .gsd at basePath takes precedence over ancestor .gsd
-  const outer = tmp();
-  try {
-    initGit(outer);
-    mkdirSync(join(outer, ".gsd"));
-    const inner = join(outer, "nested");
-    mkdirSync(join(inner, ".gsd"), { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(inner);
-    assertEq(result, join(inner, ".gsd"), "precedence: nearest .gsd wins over ancestor");
-  } finally { cleanup(outer); }
-}
+  test('Case 5: cache — second call returns same value without re-probing', () => {
+    const root = tmp();
+    try {
+      mkdirSync(join(root, ".gsd"));
+      _clearGsdRootCache();
+      const first = gsdRoot(root);
+      const second = gsdRoot(root);
+      assert.deepStrictEqual(first, second, "cache: same result returned on second call");
+      assert.ok(first === second, "cache: identity check (same string)");
+    } finally { cleanup(root); }
+  });
 
-report();
+  test('Case 6: .gsd at basePath takes precedence over ancestor .gsd', () => {
+    const outer = tmp();
+    try {
+      initGit(outer);
+      mkdirSync(join(outer, ".gsd"));
+      const inner = join(outer, "nested");
+      mkdirSync(join(inner, ".gsd"), { recursive: true });
+      _clearGsdRootCache();
+      const result = gsdRoot(inner);
+      assert.deepStrictEqual(result, join(inner, ".gsd"), "precedence: nearest .gsd wins over ancestor");
+    } finally { cleanup(outer); }
+  });
+});

package/src/resources/extensions/gsd/tests/plan-milestone.test.ts

@@ -1,133 +1,196 @@
-// Tests for inlinePriorMilestoneSummary — the cross-milestone context bridging helper.
-//
-// Scenarios covered:
-//   (A) M002 with M001-SUMMARY.md present → returns string containing "Prior Milestone Summary" and summary content
-//   (B) M001 (no prior milestone in dir) → returns null
-//   (C) M002 with no M001-SUMMARY.md written → returns null
-//   (D) M003 with M002 dir present but no M002-SUMMARY.md → returns null
-
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { fileURLToPath } from 'node:url';
 
-import { inlinePriorMilestoneSummary } from '../files.ts';
-import { createTestContext } from './test-helpers.ts';
+import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices } from '../gsd-db.ts';
+import { handlePlanMilestone } from '../tools/plan-milestone.ts';
+import { parseRoadmap } from '../parsers-legacy.ts';
 
-// ─── Worktree-aware prompt loader ──────────────────────────────────────────
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-
-const { assertEq, assertTrue, report } = createTestContext();
-// ─── Fixture helpers ───────────────────────────────────────────────────────
-
-function createFixtureBase(): string {
-  const base = mkdtempSync(join(tmpdir(), 'gsd-plan-ms-test-'));
-  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-plan-milestone-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
   return base;
 }
 
-function writeMilestoneDir(base: string, mid: string): void {
-  mkdirSync(join(base, '.gsd', 'milestones', mid), { recursive: true });
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
 }
 
-function writeMilestoneSummary(base: string, mid: string, content: string): void {
-  const dir = join(base, '.gsd', 'milestones', mid);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, `${mid}-SUMMARY.md`), content);
+function validParams() {
+  return {
+    milestoneId: 'M001',
+    title: 'DB-backed planning',
+    vision: 'Make planning write through the database.',
+    successCriteria: ['Planning persists', 'Roadmap renders from DB'],
+    keyRisks: [
+      { risk: 'Renderer mismatch', whyItMatters: 'Rendered roadmap may stop round-tripping.' },
+    ],
+    proofStrategy: [
+      { riskOrUnknown: 'Render correctness', retireIn: 'S01', whatWillBeProven: 'ROADMAP output matches DB state.' },
+    ],
+    verificationContract: 'Contract verification text',
+    verificationIntegration: 'Integration verification text',
+    verificationOperational: 'Operational verification text',
+    verificationUat: 'UAT verification text',
+    definitionOfDone: ['Tests pass', 'Tool reruns cleanly'],
+    requirementCoverage: 'Covers R015.',
+    boundaryMapMarkdown: '| From | To | Produces | Consumes |\n|------|----|----------|----------|\n| S01 | terminal | roadmap | nothing |',
+    slices: [
+      {
+        sliceId: 'S01',
+        title: 'Tool wiring',
+        risk: 'medium',
+        depends: [],
+        demo: 'The tool writes roadmap state.',
+        goal: 'Wire the handler.',
+        successCriteria: 'Handler persists state and renders markdown.',
+        proofLevel: 'integration',
+        integrationClosure: 'Downstream callers read rendered roadmap output.',
+        observabilityImpact: 'Tests expose render and validation failures.',
+      },
+      {
+        sliceId: 'S02',
+        title: 'Prompt migration',
+        risk: 'low',
+        depends: ['S01'],
+        demo: 'Prompts call the tool.',
+        goal: 'Migrate prompts to DB-backed path.',
+        successCriteria: 'Prompt contracts reference the new tool.',
+        proofLevel: 'integration',
+        integrationClosure: 'Prompt tests cover the new planning route.',
+        observabilityImpact: 'Prompt and rogue-write failures become explicit.',
+      },
+    ],
+  };
 }
 
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
-}
+test('handlePlanMilestone writes milestone and slice planning state and renders roadmap', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const result = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const milestone = getMilestone('M001');
+    assert.ok(milestone, 'milestone should exist');
+    assert.equal(milestone?.vision, 'Make planning write through the database.');
+    assert.deepEqual(milestone?.success_criteria, ['Planning persists', 'Roadmap renders from DB']);
+    assert.equal(milestone?.verification_contract, 'Contract verification text');
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices.length, 2);
+    assert.equal(slices[0]?.id, 'S01');
+    assert.equal(slices[0]?.goal, 'Wire the handler.');
+    assert.equal(slices[1]?.depends[0], 'S01');
+
+    const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    assert.ok(existsSync(roadmapPath), 'roadmap should be rendered to disk');
+    const roadmap = readFileSync(roadmapPath, 'utf-8');
+    assert.match(roadmap, /# M001: DB-backed planning/);
+    assert.match(roadmap, /\*\*Vision:\*\* Make planning write through the database\./);
+    assert.match(roadmap, /- \[ \] \*\*S01: Tool wiring\*\* `risk:medium` `depends:\[\]`/);
+    assert.match(roadmap, /- \[ \] \*\*S02: Prompt migration\*\* `risk:low` `depends:\[S01\]`/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanMilestone rejects invalid payloads', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const params = validParams();
+    const result = await handlePlanMilestone({ ...params, slices: [] }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: slices must be a non-empty array/);
+  } finally {
+    cleanup(base);
+  }
+});
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-async function main(): Promise<void> {
-
-  // ─── (A) M002 with M001-SUMMARY.md present ────────────────────────────────
-  console.log('\n── (A) M002 with M001-SUMMARY.md present → string containing "Prior Milestone Summary"');
-  {
-    const base = createFixtureBase();
-    try {
-      writeMilestoneDir(base, 'M001');
-      writeMilestoneDir(base, 'M002');
-      writeMilestoneSummary(base, 'M001', '# M001 Summary\n\nKey decisions: used TypeScript throughout.\n');
-
-      const result = await inlinePriorMilestoneSummary('M002', base);
-
-      assertTrue(result !== null, '(A) result is not null when prior milestone has SUMMARY');
-      assertTrue(
-        typeof result === 'string' && result.includes('Prior Milestone Summary'),
-        '(A) result contains "Prior Milestone Summary" label',
-      );
-      assertTrue(
-        typeof result === 'string' && result.includes('Key decisions: used TypeScript throughout.'),
-        '(A) result contains the summary file content',
-      );
-    } finally {
-      cleanup(base);
-    }
+test('handlePlanMilestone surfaces render failures and does not clear parse-visible state on failure', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const fallbackRoadmapPath = join(base, '.gsd', 'milestones', 'MISSING', 'MISSING-ROADMAP.md');
+    mkdirSync(fallbackRoadmapPath, { recursive: true });
+
+    const result = await handlePlanMilestone({ ...validParams(), milestoneId: 'MISSING' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /render failed:/);
+
+    const existingRoadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    writeFileSync(existingRoadmapPath, '# M001: Cached roadmap\n\n**Vision:** old value\n\n## Slices\n\n', 'utf-8');
+    const cachedAfter = parseRoadmap(readFileSync(existingRoadmapPath, 'utf-8'));
+    assert.equal(cachedAfter.vision, 'old value');
+  } finally {
+    cleanup(base);
   }
+});
 
-  // ─── (B) M001 (no prior milestone in dir) ─────────────────────────────────
-  console.log('\n── (B) M001 — first milestone, no prior → null');
-  {
-    const base = createFixtureBase();
-    try {
-      writeMilestoneDir(base, 'M001');
+test('handlePlanMilestone clears parse-visible roadmap state after successful render', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
 
-      const result = await inlinePriorMilestoneSummary('M001', base);
+  try {
+    const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    writeFileSync(roadmapPath, '# M001: Cached roadmap\n\n**Vision:** old value\n\n## Slices\n\n', 'utf-8');
 
-      assertEq(result, null, '(B) M001 with no prior milestone → null');
-    } finally {
-      cleanup(base);
-    }
-  }
+    const cachedBefore = parseRoadmap(readFileSync(roadmapPath, 'utf-8'));
+    assert.equal(cachedBefore.vision, 'old value');
 
-  // ─── (C) M002 with no M001-SUMMARY.md ────────────────────────────────────
-  console.log('\n── (C) M002 with M001 dir but no M001-SUMMARY.md → null');
-  {
-    const base = createFixtureBase();
-    try {
-      writeMilestoneDir(base, 'M001');
-      writeMilestoneDir(base, 'M002');
-      // Intentionally do NOT write M001-SUMMARY.md
-
-      const result = await inlinePriorMilestoneSummary('M002', base);
-
-      assertEq(result, null, '(C) M002 when M001 has no SUMMARY file → null');
-    } finally {
-      cleanup(base);
-    }
-  }
+    const result = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in result));
 
-  // ─── (D) M003 with M002 dir but no M002-SUMMARY.md ───────────────────────
-  console.log('\n── (D) M003, M002 is immediately prior but has no SUMMARY → null');
-  {
-    const base = createFixtureBase();
-    try {
-      writeMilestoneDir(base, 'M001');
-      writeMilestoneDir(base, 'M002');
-      writeMilestoneDir(base, 'M003');
-      // M001 has a summary — but M002 (the immediately prior to M003) does NOT
-      writeMilestoneSummary(base, 'M001', '# M001 Summary\n\nOld context.\n');
-      // Intentionally do NOT write M002-SUMMARY.md
-
-      const result = await inlinePriorMilestoneSummary('M003', base);
-
-      assertEq(result, null, '(D) M003 when M002 (immediately prior) has no SUMMARY → null');
-    } finally {
-      cleanup(base);
-    }
+    const parsedAfter = parseRoadmap(readFileSync(roadmapPath, 'utf-8'));
+    assert.equal(parsedAfter.vision, 'Make planning write through the database.');
+    assert.equal(parsedAfter.slices.length, 2);
+  } finally {
+    cleanup(base);
   }
+});
 
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+test('handlePlanMilestone reruns idempotently and updates existing planning state', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const first = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in first));
+
+    const second = await handlePlanMilestone({
+      ...validParams(),
+      vision: 'Updated vision',
+      slices: [
+        {
+          ...validParams().slices[0],
+          goal: 'Updated goal',
+          observabilityImpact: 'Updated observability',
+        },
+        validParams().slices[1],
+      ],
+    }, base);
+    assert.ok(!('error' in second));
+
+    const milestone = getMilestone('M001');
+    assert.equal(milestone?.vision, 'Updated vision');
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices.length, 2);
+    assert.equal(slices[0]?.goal, 'Updated goal');
+    assert.equal(slices[0]?.observability_impact, 'Updated observability');
+  } finally {
+    cleanup(base);
+  }
 });

package/src/resources/extensions/gsd/tests/plan-slice-prompt.test.ts

@@ -54,6 +54,13 @@ test("plan-slice prompt: all variables substituted", () => {
   assert.ok(result.includes("S01"));
 });
 
+test("plan-slice prompt: DB-backed tool names survive template substitution", () => {
+  const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
+  assert.ok(result.includes("gsd_plan_slice"), "gsd_plan_slice should appear in rendered prompt");
+  assert.ok(result.includes("gsd_plan_task"), "gsd_plan_task should appear in rendered prompt");
+  assert.ok(result.includes("canonical write path"), "canonical write path language should survive substitution");
+});
+
 test("domain-work prompts use skillActivation placeholder", () => {
   const prompts = [
     "research-milestone",