gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/doctor-runtime.test.ts

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 /**
  * doctor-runtime.test.ts — Tests for doctor runtime health checks.
  *
@@ -15,6 +13,10 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { runGSDDoctor } from "../doctor.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -55,12 +57,13 @@ function createGitProject(): string {
   return dir;
 }
 
-describe('doctor-runtime', async () => {
+async function main(): Promise<void> {
   const cleanups: string[] = [];
 
   try {
     // ─── Test 1: Stale crash lock detection & fix ─────────────────────
-    test('stale_crash_lock', async () => {
+    console.log("\n=== stale_crash_lock ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -77,27 +80,29 @@ describe('doctor-runtime', async () => {
 
       const detect = await runGSDDoctor(dir);
       const lockIssues = detect.issues.filter(i => i.code === "stale_crash_lock");
-      assert.ok(lockIssues.length > 0, "detects stale crash lock");
-      assert.ok(lockIssues[0]?.message.includes("9999999"), "message includes PID");
-      assert.ok(lockIssues[0]?.fixable === true, "stale lock is fixable");
+      assertTrue(lockIssues.length > 0, "detects stale crash lock");
+      assertTrue(lockIssues[0]?.message.includes("9999999"), "message includes PID");
+      assertTrue(lockIssues[0]?.fixable === true, "stale lock is fixable");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "fix clears stale lock");
-      assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock removed after fix");
-    });
+      assertTrue(fixed.fixesApplied.some(f => f.includes("cleared stale auto.lock")), "fix clears stale lock");
+      assertTrue(!existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock removed after fix");
+    }
 
     // ─── Test 2: No false positive for missing lock ───────────────────
-    test('stale_crash_lock — no false positive', async () => {
+    console.log("\n=== stale_crash_lock — no false positive ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
       const detect = await runGSDDoctor(dir);
       const lockIssues = detect.issues.filter(i => i.code === "stale_crash_lock");
-      assert.deepStrictEqual(lockIssues.length, 0, "no stale lock issue when no lock file exists");
-    });
+      assertEq(lockIssues.length, 0, "no stale lock issue when no lock file exists");
+    }
 
     // ─── Test 3: Stale hook state detection & fix ─────────────────────
-    test('stale_hook_state', async () => {
+    console.log("\n=== stale_hook_state ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -113,19 +118,20 @@ describe('doctor-runtime', async () => {
 
       const detect = await runGSDDoctor(dir);
       const hookIssues = detect.issues.filter(i => i.code === "stale_hook_state");
-      assert.ok(hookIssues.length > 0, "detects stale hook state");
-      assert.ok(hookIssues[0]?.message.includes("2 residual cycle count"), "message includes count");
+      assertTrue(hookIssues.length > 0, "detects stale hook state");
+      assertTrue(hookIssues[0]?.message.includes("2 residual cycle count"), "message includes count");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("cleared stale hook-state.json")), "fix clears hook state");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("cleared stale hook-state.json")), "fix clears hook state");
 
       // Verify the file was cleaned
       const content = JSON.parse(readFileSync(join(dir, ".gsd", "hook-state.json"), "utf-8"));
-      assert.deepStrictEqual(Object.keys(content.cycleCounts).length, 0, "hook state cycle counts cleared");
-    });
+      assertEq(Object.keys(content.cycleCounts).length, 0, "hook state cycle counts cleared");
+    }
 
     // ─── Test 4: Activity log bloat detection ─────────────────────────
-    test('activity_log_bloat', async () => {
+    console.log("\n=== activity_log_bloat ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -138,37 +144,39 @@ describe('doctor-runtime', async () => {
 
       const detect = await runGSDDoctor(dir);
       const bloatIssues = detect.issues.filter(i => i.code === "activity_log_bloat");
-      assert.ok(bloatIssues.length > 0, "detects activity log bloat");
-      assert.ok(bloatIssues[0]?.message.includes("510 files"), "message includes file count");
-    });
+      assertTrue(bloatIssues.length > 0, "detects activity log bloat");
+      assertTrue(bloatIssues[0]?.message.includes("510 files"), "message includes file count");
+    }
 
     // ─── Test 5: STATE.md missing detection & fix ─────────────────────
-    test('state_file_missing', async () => {
+    console.log("\n=== state_file_missing ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
       // No STATE.md exists by default in our minimal setup
       const stateFilePath = join(dir, ".gsd", "STATE.md");
-      assert.ok(!existsSync(stateFilePath), "STATE.md does not exist initially");
+      assertTrue(!existsSync(stateFilePath), "STATE.md does not exist initially");
 
       const detect = await runGSDDoctor(dir);
       const stateIssues = detect.issues.filter(i => i.code === "state_file_missing");
-      assert.ok(stateIssues.length > 0, "detects missing STATE.md");
-      assert.ok(stateIssues[0]?.fixable === true, "missing STATE.md is fixable");
-      assert.deepStrictEqual(stateIssues[0]?.severity, "warning", "missing STATE.md is a warning (derived file)");
+      assertTrue(stateIssues.length > 0, "detects missing STATE.md");
+      assertTrue(stateIssues[0]?.fixable === true, "missing STATE.md is fixable");
+      assertEq(stateIssues[0]?.severity, "warning", "missing STATE.md is a warning (derived file)");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("created STATE.md")), "fix creates STATE.md");
-      assert.ok(existsSync(stateFilePath), "STATE.md exists after fix");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("created STATE.md")), "fix creates STATE.md");
+      assertTrue(existsSync(stateFilePath), "STATE.md exists after fix");
 
       // Verify content has expected structure
       const content = readFileSync(stateFilePath, "utf-8");
-      assert.ok(content.includes("# GSD State"), "STATE.md has header");
-      assert.ok(content.includes("M001"), "STATE.md references milestone");
-    });
+      assertTrue(content.includes("# GSD State"), "STATE.md has header");
+      assertTrue(content.includes("M001"), "STATE.md references milestone");
+    }
 
     // ─── Test 6: STATE.md stale detection & fix ───────────────────────
-    test('state_file_stale', async () => {
+    console.log("\n=== state_file_stale ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -194,20 +202,21 @@ None
 
       const detect = await runGSDDoctor(dir);
       const staleIssues = detect.issues.filter(i => i.code === "state_file_stale");
-      assert.ok(staleIssues.length > 0, "detects stale STATE.md");
-      assert.ok(staleIssues[0]?.message.includes("idle"), "message references old phase");
+      assertTrue(staleIssues.length > 0, "detects stale STATE.md");
+      assertTrue(staleIssues[0]?.message.includes("idle"), "message references old phase");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("rebuilt STATE.md")), "fix rebuilds STATE.md");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("rebuilt STATE.md")), "fix rebuilds STATE.md");
 
       // Verify updated content matches derived state
       const content = readFileSync(stateFilePath, "utf-8");
-      assert.ok(content.includes("M001"), "rebuilt STATE.md references milestone");
-    });
+      assertTrue(content.includes("M001"), "rebuilt STATE.md references milestone");
+    }
 
     // ─── Test 7: Gitignore missing patterns detection & fix ───────────
     if (process.platform !== "win32") {
-    test('gitignore_missing_patterns', async () => {
+    console.log("\n=== gitignore_missing_patterns ===");
+    {
       const dir = createGitProject();
       cleanups.push(dir);
 
@@ -221,22 +230,24 @@ None
 
       const detect = await runGSDDoctor(dir);
       const gitignoreIssues = detect.issues.filter(i => i.code === "gitignore_missing_patterns");
-      assert.ok(gitignoreIssues.length > 0, "detects missing gitignore patterns");
-      assert.ok(gitignoreIssues[0]?.message.includes(".gsd"), "message lists missing .gsd pattern");
+      assertTrue(gitignoreIssues.length > 0, "detects missing gitignore patterns");
+      assertTrue(gitignoreIssues[0]?.message.includes(".gsd"), "message lists missing .gsd pattern");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("added missing GSD runtime patterns")), "fix adds patterns");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("added missing GSD runtime patterns")), "fix adds patterns");
 
       // Verify .gsd entry was added (external state symlink)
       const content = readFileSync(join(dir, ".gitignore"), "utf-8");
-      assert.ok(content.includes(".gsd"), "gitignore now has .gsd entry");
-    });
+      assertTrue(content.includes(".gsd"), "gitignore now has .gsd entry");
+    }
     } else {
+      console.log("\n=== gitignore_missing_patterns (skipped on Windows) ===");
     }
 
     // ─── Test 8: No false positive when gitignore has blanket .gsd/ ───
     if (process.platform !== "win32") {
-    test('gitignore — blanket .gsd/', async () => {
+    console.log("\n=== gitignore — blanket .gsd/ ===");
+    {
       const dir = createGitProject();
       cleanups.push(dir);
 
@@ -247,13 +258,15 @@ node_modules/
 
       const detect = await runGSDDoctor(dir);
       const gitignoreIssues = detect.issues.filter(i => i.code === "gitignore_missing_patterns");
-      assert.deepStrictEqual(gitignoreIssues.length, 0, "no missing patterns when blanket .gsd/ present");
-    });
+      assertEq(gitignoreIssues.length, 0, "no missing patterns when blanket .gsd/ present");
+    }
     } else {
+      console.log("\n=== gitignore — blanket .gsd/ (skipped on Windows) ===");
     }
 
     // ─── Test 9: Orphaned completed-units detection & fix ─────────────
-    test('orphaned_completed_units', async () => {
+    console.log("\n=== orphaned_completed_units ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -266,23 +279,24 @@ node_modules/
 
       const detect = await runGSDDoctor(dir);
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_completed_units");
-      assert.ok(orphanIssues.length > 0, "detects orphaned completed-unit keys");
-      assert.ok(orphanIssues[0]?.message.includes("2 completed-unit key"), "message includes count");
+      assertTrue(orphanIssues.length > 0, "detects orphaned completed-unit keys");
+      assertTrue(orphanIssues[0]?.message.includes("2 completed-unit key"), "message includes count");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(fixed.fixesApplied.some(f => f.includes("removed") && f.includes("orphaned")), "fix removes orphaned keys");
+      assertTrue(fixed.fixesApplied.some(f => f.includes("removed") && f.includes("orphaned")), "fix removes orphaned keys");
 
       // Verify keys were cleaned
       const content = JSON.parse(readFileSync(join(dir, ".gsd", "completed-units.json"), "utf-8"));
-      assert.deepStrictEqual(content.length, 0, "all orphaned keys removed");
-    });
+      assertEq(content.length, 0, "all orphaned keys removed");
+    }
 
     // ─── Test: Stranded lock directory detection & fix ────────────────
     // Skip on Windows: proper-lockfile uses advisory file locking on Windows,
     // not the directory-based mechanism. The .gsd.lock/ directory pattern is
     // a POSIX-specific lockfile implementation detail.
     if (process.platform !== "win32") {
-    test('stranded_lock_directory', async () => {
+    console.log("\n=== stranded_lock_directory ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -293,20 +307,21 @@ node_modules/
 
       const detect = await runGSDDoctor(dir);
       const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
-      assert.ok(strandedIssues.length > 0, "detects stranded lock directory");
-      assert.ok(strandedIssues[0]?.message.includes("lock directory"), "message describes stranded lock directory");
-      assert.ok(strandedIssues[0]?.fixable === true, "stranded lock dir is fixable");
+      assertTrue(strandedIssues.length > 0, "detects stranded lock directory");
+      assertTrue(strandedIssues[0]?.message.includes("lock directory"), "message describes stranded lock directory");
+      assertTrue(strandedIssues[0]?.fixable === true, "stranded lock dir is fixable");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
-      assert.ok(
+      assertTrue(
         fixed.fixesApplied.some(f => f.includes("removed stranded lock directory")),
         "fix removes stranded lock directory",
       );
-      assert.ok(!existsSync(lockDir), "lock directory removed after fix");
-    });
+      assertTrue(!existsSync(lockDir), "lock directory removed after fix");
+    }
 
     // ─── Test: Stranded lock dir with live lock holder — NOT flagged ───
-    test('stranded_lock_directory (live holder not flagged)', async () => {
+    console.log("\n=== stranded_lock_directory (live holder not flagged) ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -325,16 +340,18 @@ node_modules/
 
       const detect = await runGSDDoctor(dir);
       const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
-      assert.deepStrictEqual(strandedIssues.length, 0, "live lock holder: stranded_lock_directory NOT detected");
-    });
+      assertEq(strandedIssues.length, 0, "live lock holder: stranded_lock_directory NOT detected");
+    }
     } else {
+      console.log("\n=== stranded_lock_directory (skipped on Windows) ===");
     }
 
     // ─── Test: orphaned_completed_units NOT auto-fixed at fixLevel="task" (#1809) ──
     // Regression: task-level doctor was removing completed-unit keys whose artifacts
     // were temporarily missing, causing deriveState to revert the user to S01 and
     // effectively discarding hours of work.
-    test('orphaned_completed_units protected at fixLevel=task (#1809)', async () => {
+    console.log("\n=== orphaned_completed_units protected at fixLevel=task (#1809) ===");
+    {
       const dir = createMinimalProject();
       cleanups.push(dir);
 
@@ -349,29 +366,33 @@ node_modules/
       // fixLevel="task" — the level used by auto-post-unit after every task
       const taskLevelFix = await runGSDDoctor(dir, { fix: true, fixLevel: "task" });
       const taskLevelOrphan = taskLevelFix.issues.filter(i => i.code === "orphaned_completed_units");
-      assert.ok(taskLevelOrphan.length > 0, "orphaned_completed_units detected at task fixLevel");
+      assertTrue(taskLevelOrphan.length > 0, "orphaned_completed_units detected at task fixLevel");
 
       // Verify keys were NOT removed — the fix must be suppressed at task level
       const afterTaskFix = JSON.parse(readFileSync(join(dir, ".gsd", "completed-units.json"), "utf-8"));
-      assert.deepStrictEqual(afterTaskFix.length, 2, "completed-unit keys preserved at fixLevel=task (data loss prevention)");
-      assert.ok(
+      assertEq(afterTaskFix.length, 2, "completed-unit keys preserved at fixLevel=task (data loss prevention)");
+      assertTrue(
         !taskLevelFix.fixesApplied.some(f => f.includes("orphaned")),
         "no orphaned-units fix applied at fixLevel=task",
       );
 
       // fixLevel="all" (explicit manual doctor) — fix SHOULD apply
       const allLevelFix = await runGSDDoctor(dir, { fix: true, fixLevel: "all" });
-      assert.ok(
+      assertTrue(
         allLevelFix.fixesApplied.some(f => f.includes("orphaned")),
         "orphaned-units fix applied at fixLevel=all (manual doctor)",
       );
       const afterAllFix = JSON.parse(readFileSync(join(dir, ".gsd", "completed-units.json"), "utf-8"));
-      assert.deepStrictEqual(afterAllFix.length, 0, "orphaned keys removed at fixLevel=all");
-    });
+      assertEq(afterAllFix.length, 0, "orphaned keys removed at fixLevel=all");
+    }
 
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-});
+
+  report();
+}
+
+main();