gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

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

@@ -92,9 +92,11 @@ test('handlePlanMilestone writes milestone and slice planning state and renders
     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\]`/);
+    assert.match(roadmap, /## Vision/);
+    assert.match(roadmap, /Make planning write through the database\./);
+    assert.match(roadmap, /## Slice Overview/);
+    assert.match(roadmap, /\| S01 \| Tool wiring \| medium \|/);
+    assert.match(roadmap, /\| S02 \| Prompt migration \| low \| S01 \|/);
   } finally {
     cleanup(base);
   }
@@ -152,9 +154,10 @@ test('handlePlanMilestone clears parse-visible roadmap state after successful re
     const result = await handlePlanMilestone(validParams(), base);
     assert.ok(!('error' in result));
 
-    const parsedAfter = parseRoadmap(readFileSync(roadmapPath, 'utf-8'));
-    assert.equal(parsedAfter.vision, 'Make planning write through the database.');
-    assert.equal(parsedAfter.slices.length, 2);
+    const contentAfter = readFileSync(roadmapPath, 'utf-8');
+    assert.match(contentAfter, /Make planning write through the database\./);
+    assert.match(contentAfter, /S01/);
+    assert.match(contentAfter, /S02/);
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/post-mutation-hook.test.ts

@@ -0,0 +1,171 @@
+// GSD Extension — post-mutation hook regression tests
+// Verifies that after a successful handleCompleteTask call, the post-mutation
+// hook fires: event-log.jsonl and state-manifest.json are both written.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { openDatabase, closeDatabase } from '../gsd-db.ts';
+import { handleCompleteTask } from '../tools/complete-task.ts';
+import { readEvents } from '../workflow-events.ts';
+import { readManifest } from '../workflow-manifest.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-post-hook-'));
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+/** Create a minimal project directory with a PLAN.md for complete-task to find. */
+function createProject(basePath: string): void {
+  const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+  const tasksDir = path.join(sliceDir, 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+  fs.writeFileSync(path.join(sliceDir, 'S01-PLAN.md'), `# S01: Test Slice
+
+## Tasks
+
+- [ ] **T01: Test task** \`est:30m\`
+  - Do: Implement the thing
+  - Verify: Run tests
+
+- [ ] **T02: Second task** \`est:1h\`
+  - Do: Implement more
+  - Verify: Run more tests
+`);
+}
+
+function makeCompleteTaskParams() {
+  return {
+    taskId: 'T01',
+    sliceId: 'S01',
+    milestoneId: 'M001',
+    oneLiner: 'Implemented auth middleware',
+    narrative: 'Added JWT validation middleware with proper error handling.',
+    verification: 'Ran npm test — all tests pass.',
+    deviations: 'None.',
+    knownIssues: 'None.',
+    keyFiles: ['src/middleware/auth.ts'],
+    keyDecisions: [],
+    blockerDiscovered: false,
+    verificationEvidence: [
+      { command: 'npm test', exitCode: 0, verdict: '✅ pass', durationMs: 2500 },
+    ],
+  };
+}
+
+// ─── Post-mutation hook: event log ───────────────────────────────────────
+
+test('post-mutation-hook: event-log.jsonl exists after handleCompleteTask', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    const result = await handleCompleteTask(makeCompleteTaskParams(), base);
+    assert.ok(!('error' in result), `handler should succeed, got: ${JSON.stringify(result)}`);
+
+    const logPath = path.join(base, '.gsd', 'event-log.jsonl');
+    assert.ok(fs.existsSync(logPath), 'event-log.jsonl should exist after handler completes');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('post-mutation-hook: event log contains complete-task event with correct params', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    await handleCompleteTask(makeCompleteTaskParams(), base);
+
+    const logPath = path.join(base, '.gsd', 'event-log.jsonl');
+    const events = readEvents(logPath);
+    assert.ok(events.length > 0, 'event log should have at least one event');
+
+    const ev = events.find((e) => e.cmd === 'complete-task');
+    assert.ok(ev !== undefined, 'should have a complete-task event');
+    assert.strictEqual((ev!.params as { milestoneId?: string }).milestoneId, 'M001');
+    assert.strictEqual((ev!.params as { sliceId?: string }).sliceId, 'S01');
+    assert.strictEqual((ev!.params as { taskId?: string }).taskId, 'T01');
+    assert.strictEqual(ev!.actor, 'agent');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── Post-mutation hook: manifest ────────────────────────────────────────
+
+test('post-mutation-hook: state-manifest.json exists after handleCompleteTask', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    const result = await handleCompleteTask(makeCompleteTaskParams(), base);
+    assert.ok(!('error' in result), `handler should succeed, got: ${JSON.stringify(result)}`);
+
+    const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist after handler completes');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('post-mutation-hook: manifest has version 1 and includes completed task', async () => {
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+  createProject(base);
+
+  try {
+    await handleCompleteTask(makeCompleteTaskParams(), base);
+
+    const manifest = readManifest(base);
+    assert.ok(manifest !== null, 'manifest should be readable');
+    assert.strictEqual(manifest!.version, 1);
+
+    const task = manifest!.tasks.find((t) => t.id === 'T01');
+    assert.ok(task !== undefined, 'T01 should appear in manifest');
+    assert.strictEqual(task!.status, 'complete');
+    assert.strictEqual(task!.milestone_id, 'M001');
+    assert.strictEqual(task!.slice_id, 'S01');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── Post-mutation hook: non-fatal on hook failure ───────────────────────
+
+test('post-mutation-hook: handler still returns success even if projections dir is missing', async () => {
+  // basePath with NO .gsd directory — projections will fail to find milestones
+  // but handler should still return a result (not throw)
+  const base = tempDir();
+  const dbPath = path.join(base, 'test.db');
+  openDatabase(dbPath);
+
+  // Create tasks dir but NO plan file (projections will soft-fail)
+  const tasksDir = path.join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+
+  try {
+    const result = await handleCompleteTask(makeCompleteTaskParams(), base);
+    // Handler should succeed (post-hook failures are non-fatal)
+    assert.ok(!('error' in result), `handler should not propagate hook errors, got: ${JSON.stringify(result)}`);
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});