gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/quick-branch-lifecycle.test.ts

@@ -7,17 +7,16 @@
  * Relates to #1269, #1293.
  */
 
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createTestContext } from './test-helpers.ts';
 import { captureIntegrationBranch, getCurrentBranch } from "../worktree.ts";
 import { readIntegrationBranch, QUICK_BRANCH_RE } from "../git-service.ts";
 
-const { assertEq, assertTrue, report } = createTestContext();
-
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -35,68 +34,59 @@ function createTestRepo(): string {
   return repo;
 }
 
-async function main(): Promise<void> {
-
   // ═══════════════════════════════════════════════════════════════════════
   // QUICK_BRANCH_RE
   // ═══════════════════════════════════════════════════════════════════════
 
-  console.log("\n=== QUICK_BRANCH_RE: matches quick-task branches ===");
 
-  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/1-fix-typo"), "matches standard quick branch");
-  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/42-some-long-slug-name"), "matches multi-digit quick branch");
-  assertTrue(!QUICK_BRANCH_RE.test("main"), "rejects main");
-  assertTrue(!QUICK_BRANCH_RE.test("gsd/M001/S01"), "rejects slice branch");
-  assertTrue(!QUICK_BRANCH_RE.test("gsd/quickly-something"), "rejects non-quick prefix");
-  assertTrue(!QUICK_BRANCH_RE.test("feature/gsd/quick/1"), "rejects nested prefix");
+describe('quick-branch-lifecycle', () => {
+test('QUICK_BRANCH_RE: matches quick-task branches', () => {
+  assert.ok(QUICK_BRANCH_RE.test("gsd/quick/1-fix-typo"), "matches standard quick branch");
+});
 
+  assert.ok(QUICK_BRANCH_RE.test("gsd/quick/42-some-long-slug-name"), "matches multi-digit quick branch");
+  assert.ok(!QUICK_BRANCH_RE.test("main"), "rejects main");
+  assert.ok(!QUICK_BRANCH_RE.test("gsd/M001/S01"), "rejects slice branch");
+  assert.ok(!QUICK_BRANCH_RE.test("gsd/quickly-something"), "rejects non-quick prefix");
+  assert.ok(!QUICK_BRANCH_RE.test("feature/gsd/quick/1"), "rejects nested prefix");
   // ═══════════════════════════════════════════════════════════════════════
   // captureIntegrationBranch: guard against quick-task branches
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== captureIntegrationBranch: skips quick-task branches ===");
-
-  {
+test('captureIntegrationBranch: skips quick-task branches', () => {
     const repo = createTestRepo();
 
     // Create and checkout a quick-task branch
     run("git checkout -b gsd/quick/1-fix-typo", repo);
-    assertEq(getCurrentBranch(repo), "gsd/quick/1-fix-typo", "on quick branch");
+    assert.deepStrictEqual(getCurrentBranch(repo), "gsd/quick/1-fix-typo", "on quick branch");
 
     captureIntegrationBranch(repo, "M001");
 
-    assertEq(readIntegrationBranch(repo, "M001"), null,
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null,
       "captureIntegrationBranch is a no-op on quick-task branches");
 
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ─── Verify main is still recorded correctly ─────────────────────────
-
-  console.log("\n=== captureIntegrationBranch: records main correctly ===");
-
-  {
+test('captureIntegrationBranch: records main correctly', () => {
     const repo = createTestRepo();
 
     // Capture from main — should work normally
     captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
       "main is recorded as integration branch");
 
     // Switch to quick branch — capture should be no-op (doesn't overwrite main)
     run("git checkout -b gsd/quick/1-fix-typo", repo);
     captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
       "quick branch does not overwrite existing integration branch");
 
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ─── Sequence: main → quick → back to main → capture ────────────────
-
-  console.log("\n=== captureIntegrationBranch: correct after quick branch round-trip ===");
-
-  {
+test('captureIntegrationBranch: correct after quick branch round-trip', () => {
     const repo = createTestRepo();
 
     // Simulate quick-task lifecycle: branch off, do work, return to main
@@ -111,19 +101,16 @@ async function main(): Promise<void> {
 
     // Now capture — should get main, not the deleted quick branch
     captureIntegrationBranch(repo, "M002");
-    assertEq(readIntegrationBranch(repo, "M002"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), "main",
       "after quick round-trip, main is captured correctly");
 
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // cleanupQuickBranch: in-memory path (same session)
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== cleanupQuickBranch: merges back and cleans up (same session) ===");
-
-  {
+test('cleanupQuickBranch: merges back and cleans up (same session)', async () => {
     const repo = createTestRepo();
     const origCwd = process.cwd();
 
@@ -155,30 +142,27 @@ async function main(): Promise<void> {
     const { cleanupQuickBranch } = await import("../quick.ts");
     const result = cleanupQuickBranch();
 
-    assertTrue(result, "cleanupQuickBranch returns true");
-    assertEq(getCurrentBranch(repo), "main", "back on main after cleanup");
+    assert.ok(result, "cleanupQuickBranch returns true");
+    assert.deepStrictEqual(getCurrentBranch(repo), "main", "back on main after cleanup");
 
     // Verify merge happened — fix.txt should exist on main
-    assertTrue(existsSync(join(repo, "fix.txt")), "fix.txt merged to main");
+    assert.ok(existsSync(join(repo, "fix.txt")), "fix.txt merged to main");
 
     // Verify quick branch deleted
     const branches = run("git branch", repo);
-    assertTrue(!branches.includes("gsd/quick/1-fix-typo"), "quick branch deleted");
+    assert.ok(!branches.includes("gsd/quick/1-fix-typo"), "quick branch deleted");
 
     // Verify disk state cleaned up
-    assertTrue(!existsSync(join(runtimeDir, "quick-return.json")), "quick-return.json removed");
+    assert.ok(!existsSync(join(runtimeDir, "quick-return.json")), "quick-return.json removed");
 
     process.chdir(origCwd);
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // cleanupQuickBranch: cross-session recovery from disk
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== cleanupQuickBranch: recovers from disk state (cross-session) ===");
-
-  {
+test('cleanupQuickBranch: recovers from disk state (cross-session)', async () => {
     const repo = createTestRepo();
     const origCwd = process.cwd();
 
@@ -206,22 +190,19 @@ async function main(): Promise<void> {
     const { cleanupQuickBranch } = await import("../quick.ts");
     const result = cleanupQuickBranch();
 
-    assertTrue(result, "cross-session recovery returns true");
-    assertEq(getCurrentBranch(repo), "main", "back on main after cross-session recovery");
-    assertTrue(existsSync(join(repo, "docs.md")), "docs.md merged to main");
-    assertTrue(!existsSync(join(runtimeDir, "quick-return.json")), "disk state cleaned up");
+    assert.ok(result, "cross-session recovery returns true");
+    assert.deepStrictEqual(getCurrentBranch(repo), "main", "back on main after cross-session recovery");
+    assert.ok(existsSync(join(repo, "docs.md")), "docs.md merged to main");
+    assert.ok(!existsSync(join(runtimeDir, "quick-return.json")), "disk state cleaned up");
 
     process.chdir(origCwd);
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // cleanupQuickBranch: no-op when no pending state
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== cleanupQuickBranch: no-op without pending state ===");
-
-  {
+test('cleanupQuickBranch: no-op without pending state', async () => {
     const repo = createTestRepo();
     const origCwd = process.cwd();
     process.chdir(repo);
@@ -229,32 +210,29 @@ async function main(): Promise<void> {
     const { cleanupQuickBranch } = await import("../quick.ts");
     const result = cleanupQuickBranch();
 
-    assertTrue(!result, "returns false when no pending state");
-    assertEq(getCurrentBranch(repo), "main", "stays on main");
+    assert.ok(!result, "returns false when no pending state");
+    assert.deepStrictEqual(getCurrentBranch(repo), "main", "stays on main");
 
     process.chdir(origCwd);
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // End-to-end: quick branch does NOT contaminate integration branch
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== E2E: quick branch does not contaminate integration branch ===");
-
-  {
+test('E2E: quick branch does not contaminate integration branch', () => {
     const repo = createTestRepo();
 
     // 1. Record main as integration branch for M001
     captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "main", "M001 integration = main");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main", "M001 integration = main");
 
     // 2. Start a quick task (branch off)
     run("git checkout -b gsd/quick/1-fix-typo", repo);
 
     // 3. Try to capture integration branch for M002 while on quick branch
     captureIntegrationBranch(repo, "M002");
-    assertEq(readIntegrationBranch(repo, "M002"), null,
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), null,
       "M002 integration NOT recorded from quick branch");
 
     // 4. Return to main (simulate cleanupQuickBranch)
@@ -262,20 +240,14 @@ async function main(): Promise<void> {
 
     // 5. Now capture M002 from main — should work
     captureIntegrationBranch(repo, "M002");
-    assertEq(readIntegrationBranch(repo, "M002"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), "main",
       "M002 integration = main after returning from quick branch");
 
     // 6. Verify M001 still intact
-    assertEq(readIntegrationBranch(repo, "M001"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
       "M001 integration unchanged");
 
     rmSync(repo, { recursive: true, force: true });
-  }
-
-  report();
-}
+});
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/reassess-handler.test.ts

@@ -0,0 +1,325 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  getSlice,
+  getMilestoneSlices,
+  getAssessment,
+  _getAdapter,
+} from '../gsd-db.ts';
+import { handleReassessRoadmap } from '../tools/reassess-roadmap.ts';
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-reassess-'));
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S03'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+function seedMilestoneWithSlices(opts?: {
+  s01Status?: string;
+  s02Status?: string;
+  s03Status?: string;
+}): void {
+  insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice One', status: opts?.s01Status ?? 'complete', demo: 'Demo one.' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Slice Two', status: opts?.s02Status ?? 'pending', demo: 'Demo two.' });
+  insertSlice({ id: 'S03', milestoneId: 'M001', title: 'Slice Three', status: opts?.s03Status ?? 'pending', demo: 'Demo three.' });
+}
+
+function validReassessParams() {
+  return {
+    milestoneId: 'M001',
+    completedSliceId: 'S01',
+    verdict: 'confirmed',
+    assessment: 'S01 completed successfully. Roadmap is on track.',
+    sliceChanges: {
+      modified: [
+        {
+          sliceId: 'S02',
+          title: 'Updated Slice Two',
+          risk: 'high',
+          depends: ['S01'],
+          demo: 'Updated demo two.',
+        },
+      ],
+      added: [
+        {
+          sliceId: 'S04',
+          title: 'New Slice Four',
+          risk: 'low',
+          depends: ['S02'],
+          demo: 'Demo four.',
+        },
+      ],
+      removed: ['S03'],
+    },
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+test('handleReassessRoadmap rejects invalid payloads (missing milestoneId)', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices();
+    const result = await handleReassessRoadmap({ ...validReassessParams(), milestoneId: '' }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed/);
+    assert.match(result.error, /milestoneId/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap rejects missing milestone', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    // No milestone seeded
+    const result = await handleReassessRoadmap(validReassessParams(), base);
+    assert.ok('error' in result);
+    assert.match(result.error, /not found/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap rejects structural violation: modifying a completed slice', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices({ s01Status: 'complete', s02Status: 'pending', s03Status: 'pending' });
+
+    const result = await handleReassessRoadmap({
+      ...validReassessParams(),
+      sliceChanges: {
+        modified: [{ sliceId: 'S01', title: 'Trying to modify completed S01' }],
+        added: [],
+        removed: [],
+      },
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /completed slice/);
+    assert.match(result.error, /S01/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap rejects structural violation: removing a completed slice', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices({ s01Status: 'complete', s02Status: 'pending', s03Status: 'pending' });
+
+    const result = await handleReassessRoadmap({
+      ...validReassessParams(),
+      sliceChanges: {
+        modified: [],
+        added: [],
+        removed: ['S01'],
+      },
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /completed slice/);
+    assert.match(result.error, /S01/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap succeeds when modifying only pending slices', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices({ s01Status: 'complete', s02Status: 'pending', s03Status: 'pending' });
+
+    const params = validReassessParams();
+    const result = await handleReassessRoadmap(params, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    // Verify assessments row exists in DB
+    const assessmentPath = join('.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-ASSESSMENT.md');
+    const assessment = getAssessment(assessmentPath);
+    assert.ok(assessment, 'assessment row should exist in DB');
+    assert.equal(assessment['milestone_id'], 'M001');
+    assert.equal(assessment['status'], 'confirmed');
+    assert.equal(assessment['scope'], 'roadmap');
+    assert.ok((assessment['full_content'] as string).includes('S01 completed successfully'), 'assessment content should be stored');
+
+    // Verify S02 was updated
+    const s02 = getSlice('M001', 'S02');
+    assert.ok(s02, 'S02 should still exist');
+    assert.equal(s02?.title, 'Updated Slice Two');
+    assert.equal(s02?.risk, 'high');
+    assert.equal(s02?.demo, 'Updated demo two.');
+
+    // Verify S03 was deleted
+    const s03 = getSlice('M001', 'S03');
+    assert.equal(s03, null, 'S03 should have been deleted');
+
+    // Verify S04 was inserted
+    const s04 = getSlice('M001', 'S04');
+    assert.ok(s04, 'S04 should exist as a new slice');
+    assert.equal(s04?.title, 'New Slice Four');
+    assert.equal(s04?.status, 'pending');
+
+    // Verify S01 (completed) was NOT touched
+    const s01 = getSlice('M001', 'S01');
+    assert.ok(s01, 'S01 should still exist');
+    assert.equal(s01?.status, 'complete');
+
+    // Verify ROADMAP.md re-rendered on disk
+    const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    assert.ok(existsSync(roadmapPath), 'ROADMAP.md should be rendered to disk');
+    const roadmapContent = readFileSync(roadmapPath, 'utf-8');
+    assert.ok(roadmapContent.includes('Updated Slice Two'), 'ROADMAP.md should contain updated S02 title');
+
+    // Verify ASSESSMENT.md exists on disk
+    const assessmentDiskPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-ASSESSMENT.md');
+    assert.ok(existsSync(assessmentDiskPath), 'ASSESSMENT.md should be rendered to disk');
+    const assessmentContent = readFileSync(assessmentDiskPath, 'utf-8');
+    assert.ok(assessmentContent.includes('confirmed'), 'ASSESSMENT.md should contain verdict');
+    assert.ok(assessmentContent.includes('S01'), 'ASSESSMENT.md should reference completed slice');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap cache invalidation: getMilestoneSlices reflects mutations', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices({ s01Status: 'complete', s02Status: 'pending', s03Status: 'pending' });
+
+    const params = validReassessParams();
+    const result = await handleReassessRoadmap(params, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    // After cache invalidation, DB queries should reflect mutations
+    const slices = getMilestoneSlices('M001');
+    const sliceIds = slices.map(s => s.id);
+
+    // S01 should remain (completed, untouched)
+    assert.ok(sliceIds.includes('S01'), 'S01 should still exist after reassess');
+
+    // S02 should remain (modified, not removed)
+    assert.ok(sliceIds.includes('S02'), 'S02 should still exist after reassess');
+
+    // S03 should be gone (removed)
+    assert.ok(!sliceIds.includes('S03'), 'S03 should be gone after removal');
+
+    // S04 should exist (added)
+    assert.ok(sliceIds.includes('S04'), 'S04 should exist after addition');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap is idempotent: calling twice with same params succeeds', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices({ s01Status: 'complete', s02Status: 'pending', s03Status: 'pending' });
+
+    // First call with full mutations
+    const params = validReassessParams();
+    const first = await handleReassessRoadmap(params, base);
+    assert.ok(!('error' in first), `first call error: ${'error' in first ? first.error : ''}`);
+
+    // Second call — S03 already deleted, S04 already exists (INSERT OR IGNORE), S02 already updated
+    // This should still succeed because:
+    // - assessments uses INSERT OR REPLACE (path PK)
+    // - S04 insert uses INSERT OR IGNORE
+    // - S02 update is idempotent
+    // - S03 delete on nonexistent is a no-op
+    const second = await handleReassessRoadmap(params, base);
+    assert.ok(!('error' in second), `second call error: ${'error' in second ? second.error : ''}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap rejects slice with status "done" (alias for complete)', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices({ s01Status: 'done', s02Status: 'pending', s03Status: 'pending' });
+
+    const result = await handleReassessRoadmap({
+      ...validReassessParams(),
+      sliceChanges: {
+        modified: [{ sliceId: 'S01', title: 'Trying to modify done S01' }],
+        added: [],
+        removed: [],
+      },
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /completed slice/);
+    assert.match(result.error, /S01/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReassessRoadmap returns structured error payloads with actionable messages', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedMilestoneWithSlices({ s01Status: 'complete', s02Status: 'complete', s03Status: 'pending' });
+
+    // Try to modify S01 (completed)
+    const modifyResult = await handleReassessRoadmap({
+      ...validReassessParams(),
+      sliceChanges: {
+        modified: [{ sliceId: 'S01', title: 'x' }],
+        added: [],
+        removed: [],
+      },
+    }, base);
+    assert.ok('error' in modifyResult);
+    assert.ok(typeof modifyResult.error === 'string', 'error should be a string');
+    assert.ok(modifyResult.error.includes('S01'), 'error should name the specific slice ID S01');
+
+    // Try to remove S02 (completed)
+    const removeResult = await handleReassessRoadmap({
+      ...validReassessParams(),
+      sliceChanges: {
+        modified: [],
+        added: [],
+        removed: ['S02'],
+      },
+    }, base);
+    assert.ok('error' in removeResult);
+    assert.ok(removeResult.error.includes('S02'), 'error should name the specific slice ID S02');
+  } finally {
+    cleanup(base);
+  }
+});