gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,11 +1,13 @@
-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-"));
@@ -21,78 +23,91 @@ function initGit(dir: string): void {
   spawnSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: dir });
 }
 
-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); }
-  });
+// ── 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); }
+}
 
-  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 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 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 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 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 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 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); }
-  });
+{
+  // 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 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); }
-  });
-});
+report();

package/src/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -1,10 +1,9 @@
 // GSD Extension — Hook Engine Tests (Post-Unit, Pre-Dispatch, State Persistence)
 
-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 { createTestContext } from "./test-helpers.ts";
 import {
   checkPostUnitHooks,
   getActiveHook,
@@ -21,6 +20,8 @@ import {
   triggerHookManually,
 } from "../post-unit-hooks.ts";
 
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -35,14 +36,14 @@ function createFixtureBase(): string {
 
 // ─── resolveHookArtifactPath ───────────────────────────────────────────────
 
+console.log("\n=== resolveHookArtifactPath ===");
 
-describe('post-unit-hooks', () => {
-test('resolveHookArtifactPath', () => {
+{
   const base = "/project";
 
   // Task-level
   const taskPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-PASS.md");
-  assert.deepStrictEqual(
+  assertEq(
     taskPath,
     join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-REVIEW-PASS.md"),
     "task-level artifact path",
@@ -50,7 +51,7 @@ test('resolveHookArtifactPath', () => {
 
   // Slice-level
   const slicePath = resolveHookArtifactPath(base, "M001/S01", "REVIEW-PASS.md");
-  assert.deepStrictEqual(
+  assertEq(
     slicePath,
     join(base, ".gsd", "milestones", "M001", "slices", "S01", "REVIEW-PASS.md"),
     "slice-level artifact path",
@@ -58,106 +59,129 @@ test('resolveHookArtifactPath', () => {
 
   // Milestone-level
   const milestonePath = resolveHookArtifactPath(base, "M001", "REVIEW-PASS.md");
-  assert.deepStrictEqual(
+  assertEq(
     milestonePath,
     join(base, ".gsd", "milestones", "M001", "REVIEW-PASS.md"),
     "milestone-level artifact path",
   );
-});
+}
 
 // ─── resetHookState ────────────────────────────────────────────────────────
-test('resetHookState', () => {
+
+console.log("\n=== resetHookState ===");
+
+{
   resetHookState();
-  assert.deepStrictEqual(getActiveHook(), null, "no active hook after reset");
-  assert.ok(!isRetryPending(), "no retry pending after reset");
-  assert.deepStrictEqual(consumeRetryTrigger(), null, "no retry trigger after reset");
-});
+  assertEq(getActiveHook(), null, "no active hook after reset");
+  assertTrue(!isRetryPending(), "no retry pending after reset");
+  assertEq(consumeRetryTrigger(), null, "no retry trigger after reset");
+}
 
 // ─── checkPostUnitHooks with no hooks configured ───────────────────────────
-test('No hooks configured', () => {
+
+console.log("\n=== No hooks configured ===");
+
+{
   resetHookState();
   const base = createFixtureBase();
   try {
     const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
-    assert.deepStrictEqual(result, null, "returns null when no hooks configured");
+    assertEq(result, null, "returns null when no hooks configured");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ─── Hook units don't trigger hooks (no hook-on-hook) ──────────────────────
-test('Hook-on-hook prevention', () => {
+
+console.log("\n=== Hook-on-hook prevention ===");
+
+{
   resetHookState();
   const base = createFixtureBase();
   try {
     const result = checkPostUnitHooks("hook/code-review", "M001/S01/T01", base);
-    assert.deepStrictEqual(result, null, "hook units don't trigger other hooks");
+    assertEq(result, null, "hook units don't trigger other hooks");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ─── consumeRetryTrigger clears state ──────────────────────────────────────
-test('consumeRetryTrigger clears state', () => {
+
+console.log("\n=== consumeRetryTrigger clears state ===");
+
+{
   resetHookState();
-  assert.deepStrictEqual(consumeRetryTrigger(), null, "no trigger initially");
-  assert.ok(!isRetryPending(), "no retry initially");
-});
+  assertEq(consumeRetryTrigger(), null, "no trigger initially");
+  assertTrue(!isRetryPending(), "no retry initially");
+}
 
 // ─── Variable substitution in prompts ──────────────────────────────────────
-test('Variable substitution', () => {
+
+console.log("\n=== Variable substitution ===");
+
+{
   const base = "/project";
 
   // 3-part ID
   const path3 = resolveHookArtifactPath(base, "M002/S03/T05", "result.md");
-  assert.ok(path3.includes("M002"), "3-part ID extracts milestoneId");
-  assert.ok(path3.includes("S03"), "3-part ID extracts sliceId");
-  assert.ok(path3.includes("T05"), "3-part ID extracts taskId");
-  assert.ok(path3.includes("milestones"), "3-part ID includes milestones/ segment");
+  assertTrue(path3.includes("M002"), "3-part ID extracts milestoneId");
+  assertTrue(path3.includes("S03"), "3-part ID extracts sliceId");
+  assertTrue(path3.includes("T05"), "3-part ID extracts taskId");
+  assertTrue(path3.includes("milestones"), "3-part ID includes milestones/ segment");
 
   // 2-part ID
   const path2 = resolveHookArtifactPath(base, "M002/S03", "result.md");
-  assert.ok(path2.includes("M002"), "2-part ID extracts milestoneId");
-  assert.ok(path2.includes("S03"), "2-part ID extracts sliceId");
-  assert.ok(path2.includes("milestones"), "2-part ID includes milestones/ segment");
+  assertTrue(path2.includes("M002"), "2-part ID extracts milestoneId");
+  assertTrue(path2.includes("S03"), "2-part ID extracts sliceId");
+  assertTrue(path2.includes("milestones"), "2-part ID includes milestones/ segment");
 
   // 1-part ID
   const path1 = resolveHookArtifactPath(base, "M002", "result.md");
-  assert.ok(path1.includes("M002"), "1-part ID extracts milestoneId");
-  assert.ok(path1.includes("milestones"), "1-part ID includes milestones/ segment");
-});
+  assertTrue(path1.includes("M002"), "1-part ID extracts milestoneId");
+  assertTrue(path1.includes("milestones"), "1-part ID includes milestones/ segment");
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 2: Pre-Dispatch Hook Tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('Pre-dispatch: no hooks configured', () => {
+
+console.log("\n=== Pre-dispatch: no hooks configured ===");
+
+{
   const base = createFixtureBase();
   try {
     const result = runPreDispatchHooks("execute-task", "M001/S01/T01", "original prompt", base);
-    assert.deepStrictEqual(result.action, "proceed", "proceeds when no hooks");
-    assert.deepStrictEqual(result.prompt, "original prompt", "prompt unchanged");
-    assert.deepStrictEqual(result.firedHooks.length, 0, "no hooks fired");
+    assertEq(result.action, "proceed", "proceeds when no hooks");
+    assertEq(result.prompt, "original prompt", "prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
+
+console.log("\n=== Pre-dispatch: hook units bypass ===");
 
-test('Pre-dispatch: hook units bypass', () => {
+{
   const base = createFixtureBase();
   try {
     const result = runPreDispatchHooks("hook/review", "M001/S01/T01", "hook prompt", base);
-    assert.deepStrictEqual(result.action, "proceed", "hook units always proceed");
-    assert.deepStrictEqual(result.prompt, "hook prompt", "hook prompt unchanged");
-    assert.deepStrictEqual(result.firedHooks.length, 0, "no hooks fired for hook units");
+    assertEq(result.action, "proceed", "hook units always proceed");
+    assertEq(result.prompt, "hook prompt", "hook prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired for hook units");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 3: State Persistence Tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('State persistence: persist and restore', () => {
+
+console.log("\n=== State persistence: persist and restore ===");
+
+{
   const base = createFixtureBase();
   try {
     resetHookState();
@@ -165,17 +189,19 @@ test('State persistence: persist and restore', () => {
     // Persist empty state
     persistHookState(base);
     const filePath = join(base, ".gsd", "hook-state.json");
-    assert.ok(existsSync(filePath), "hook-state.json created");
+    assertTrue(existsSync(filePath), "hook-state.json created");
 
     const content = JSON.parse(readFileSync(filePath, "utf-8"));
-    assert.deepStrictEqual(typeof content.savedAt, "string", "savedAt is a string");
-    assert.deepStrictEqual(Object.keys(content.cycleCounts).length, 0, "empty cycle counts");
+    assertEq(typeof content.savedAt, "string", "savedAt is a string");
+    assertEq(Object.keys(content.cycleCounts).length, 0, "empty cycle counts");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
+
+console.log("\n=== State persistence: restore from disk ===");
 
-test('State persistence: restore from disk', () => {
+{
   const base = createFixtureBase();
   try {
     resetHookState();
@@ -196,14 +222,16 @@ test('State persistence: restore from disk', () => {
     // Verify by persisting and reading back
     persistHookState(base);
     const restored = JSON.parse(readFileSync(stateFile, "utf-8"));
-    assert.deepStrictEqual(restored.cycleCounts["review/execute-task/M001/S01/T01"], 2, "cycle count restored for review");
-    assert.deepStrictEqual(restored.cycleCounts["simplify/execute-task/M001/S01/T02"], 1, "cycle count restored for simplify");
+    assertEq(restored.cycleCounts["review/execute-task/M001/S01/T01"], 2, "cycle count restored for review");
+    assertEq(restored.cycleCounts["simplify/execute-task/M001/S01/T02"], 1, "cycle count restored for simplify");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
+
+console.log("\n=== State persistence: clear ===");
 
-test('State persistence: clear', () => {
+{
   const base = createFixtureBase();
   try {
     resetHookState();
@@ -218,65 +246,77 @@ test('State persistence: clear', () => {
     clearPersistedHookState(base);
 
     const cleared = JSON.parse(readFileSync(stateFile, "utf-8"));
-    assert.deepStrictEqual(Object.keys(cleared.cycleCounts).length, 0, "cycle counts cleared");
+    assertEq(Object.keys(cleared.cycleCounts).length, 0, "cycle counts cleared");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
-test('State persistence: restore handles missing file', () => {
+console.log("\n=== State persistence: restore handles missing file ===");
+
+{
   const base = createFixtureBase();
   try {
     resetHookState();
     // Should not throw
     restoreHookState(base);
-    assert.deepStrictEqual(getActiveHook(), null, "no active hook after restore from missing file");
+    assertEq(getActiveHook(), null, "no active hook after restore from missing file");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
-test('State persistence: restore handles corrupt file', () => {
+console.log("\n=== State persistence: restore handles corrupt file ===");
+
+{
   const base = createFixtureBase();
   try {
     resetHookState();
     writeFileSync(join(base, ".gsd", "hook-state.json"), "not json", "utf-8");
     // Should not throw
     restoreHookState(base);
-    assert.deepStrictEqual(getActiveHook(), null, "no active hook after corrupt restore");
+    assertEq(getActiveHook(), null, "no active hook after corrupt restore");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 3: Hook Status Reporting Tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('Hook status: no hooks', () => {
+
+console.log("\n=== Hook status: no hooks ===");
+
+{
   resetHookState();
   const entries = getHookStatus();
   // No preferences file = no hooks
-  assert.deepStrictEqual(entries.length, 0, "no entries when no hooks configured");
+  assertEq(entries.length, 0, "no entries when no hooks configured");
 
   const formatted = formatHookStatus();
-  assert.match(formatted, /No hooks configured/, "status message says no hooks");
-});
+  assertMatch(formatted, /No hooks configured/, "status message says no hooks");
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 4: Manual Hook Trigger Tests
 // ═══════════════════════════════════════════════════════════════════════════
-test('triggerHookManually: hook not found', () => {
+
+console.log("\n=== triggerHookManually: hook not found ===");
+
+{
   resetHookState();
   const base = createFixtureBase();
   try {
     const result = triggerHookManually("nonexistent-hook", "execute-task", "M001/S01/T01", base);
-    assert.deepStrictEqual(result, null, "returns null when hook not found");
+    assertEq(result, null, "returns null when hook not found");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
-test('triggerHookManually: with configured hook', () => {
+console.log("\n=== triggerHookManually: with configured hook ===");
+
+{
   resetHookState();
   const base = createFixtureBase();
   try {
@@ -285,16 +325,16 @@ test('triggerHookManually: with configured hook', () => {
     const result = triggerHookManually("code-review", "execute-task", "M001/S01/T01", base);
     // Result depends on whether code-review hook is configured in preferences
     // The function should either return null or a valid HookDispatchResult
-    assert.ok(result === null || typeof result === "object", "returns null or object");
+    assertTrue(result === null || typeof result === "object", "returns null or object");
     if (result) {
-      assert.deepStrictEqual(result.hookName, "code-review", "hook name in result");
-      assert.deepStrictEqual(result.unitType, "hook/code-review", "unit type is hook-prefixed");
-      assert.deepStrictEqual(result.unitId, "M001/S01/T01", "unit ID preserved");
-      assert.ok(typeof result.prompt === "string", "prompt is a string");
+      assertEq(result.hookName, "code-review", "hook name in result");
+      assertEq(result.unitType, "hook/code-review", "unit type is hook-prefixed");
+      assertEq(result.unitId, "M001/S01/T01", "unit ID preserved");
+      assertTrue(typeof result.prompt === "string", "prompt is a string");
     }
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
-});
+report();