gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,15 +1,15 @@
-import { describe, test, after } from 'node:test';
-import assert from 'node:assert/strict';
 import { parseRequirementCounts } from "../files.ts";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { deriveState } from "../state.ts";
 import { runGSDDoctor } from "../doctor.ts";
+import { createTestContext } from './test-helpers.ts';
 
-describe('requirements', () => {
-  test('requirement counts parser', () => {
-    const counts = parseRequirementCounts(`# Requirements
+const { assertEq, assertTrue, report } = createTestContext();
+console.log("\n=== requirement counts parser ===");
+{
+  const counts = parseRequirementCounts(`# Requirements
 
 ## Active
 
@@ -34,68 +34,73 @@ describe('requirements', () => {
 ### R030 — No
 - Status: out-of-scope
 `);
-    assert.deepStrictEqual(counts.active, 2, "counts active requirements by section");
-    assert.deepStrictEqual(counts.validated, 1, "counts validated requirements");
-    assert.deepStrictEqual(counts.deferred, 1, "counts deferred requirements");
-    assert.deepStrictEqual(counts.outOfScope, 1, "counts out of scope requirements");
-    assert.deepStrictEqual(counts.blocked, 1, "counts blocked statuses");
-  });
-
-  const base = mkdtempSync(join(tmpdir(), "gsd-requirements-test-"));
-  const gsd = join(base, ".gsd");
-  const mDir = join(gsd, "milestones", "M001");
-  const sDir = join(mDir, "slices", "S01");
-  const tDir = join(sDir, "tasks");
-  mkdirSync(tDir, { recursive: true });
-  writeFileSync(join(gsd, "REQUIREMENTS.md"), [
-    "# Requirements",
-    "## Active",
-    "### R001 — Missing owner",
-    "- Class: core-capability",
-    "- Status: active",
-    "- Description: thing",
-    "- Why it matters: thing",
-    "- Source: user",
-    "- Primary owning slice: none yet",
-    "- Supporting slices: none",
-    "- Validation: unmapped",
-    "- Notes: none",
-    "## Validated",
-    "## Deferred",
-    "## Out of Scope",
-    "## Traceability",
-    "",
-  ].join("\n"), "utf-8");
-  writeFileSync(join(mDir, "M001-ROADMAP.md"), [
-    "# M001: Demo",
-    "## Slices",
-    "- [ ] **S01: Demo Slice** `risk:low` `depends:[]`",
-    "  > After this: demo works",
-    "",
-  ].join("\n"), "utf-8");
-  writeFileSync(join(sDir, "S01-PLAN.md"), [
-    "# S01: Demo Slice",
-    "**Goal:** Demo",
-    "**Demo:** Demo",
-    "## Must-Haves",
-    "- done",
-    "## Tasks",
-    "- [ ] **T01: Implement thing** `est:10m`",
-    "  Task is in progress.",
-    "",
-  ].join("\n"), "utf-8");
-  test('deriveState includes requirements counts', async () => {
-    const state = await deriveState(base);
-    assert.ok(state.requirements !== undefined, "state includes requirements summary");
-    assert.deepStrictEqual(state.requirements?.active, 1, "state reports active requirement count");
-  });
-
-  test('doctor flags orphaned active requirement', async () => {
-    const report = await runGSDDoctor(base);
-    assert.ok(report.issues.some(issue => issue.code === "active_requirement_missing_owner"), "doctor flags missing owner");
-  });
-
-  after(() => {
-    rmSync(base, { recursive: true, force: true });
-  });
-});
+  assertEq(counts.active, 2, "counts active requirements by section");
+  assertEq(counts.validated, 1, "counts validated requirements");
+  assertEq(counts.deferred, 1, "counts deferred requirements");
+  assertEq(counts.outOfScope, 1, "counts out of scope requirements");
+  assertEq(counts.blocked, 1, "counts blocked statuses");
+}
+
+const base = mkdtempSync(join(tmpdir(), "gsd-requirements-test-"));
+const gsd = join(base, ".gsd");
+const mDir = join(gsd, "milestones", "M001");
+const sDir = join(mDir, "slices", "S01");
+const tDir = join(sDir, "tasks");
+mkdirSync(tDir, { recursive: true });
+writeFileSync(join(gsd, "REQUIREMENTS.md"), `# Requirements
+
+## Active
+
+### R001 — Missing owner
+- Class: core-capability
+- Status: active
+- Description: thing
+- Why it matters: thing
+- Source: user
+- Primary owning slice: none yet
+- Supporting slices: none
+- Validation: unmapped
+- Notes: none
+
+## Validated
+
+## Deferred
+
+## Out of Scope
+
+## Traceability
+`, "utf-8");
+writeFileSync(join(mDir, "M001-ROADMAP.md"), `# M001: Demo
+
+## Slices
+- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`
+  > After this: demo works
+`, "utf-8");
+writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Demo Slice
+
+**Goal:** Demo
+**Demo:** Demo
+
+## Must-Haves
+- done
+
+## Tasks
+- [ ] **T01: Implement thing** \`est:10m\`
+  Task is in progress.
+`, "utf-8");
+
+console.log("\n=== deriveState includes requirements counts ===");
+{
+  const state = await deriveState(base);
+  assertTrue(state.requirements !== undefined, "state includes requirements summary");
+  assertEq(state.requirements?.active, 1, "state reports active requirement count");
+}
+
+console.log("\n=== doctor flags orphaned active requirement ===");
+{
+  const report = await runGSDDoctor(base);
+  assertTrue(report.issues.some(issue => issue.code === "active_requirement_missing_owner"), "doctor flags missing owner");
+}
+
+rmSync(base, { recursive: true, force: true });
+report();

package/src/resources/extensions/gsd/tests/retry-state-reset.test.ts

@@ -4,11 +4,10 @@
 // consuming code properly resets all completion state so deriveState
 // re-derives the task on the next loop iteration.
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { createTestContext } from "./test-helpers.ts";
 import {
   resetHookState,
   consumeRetryTrigger,
@@ -17,6 +16,8 @@ import {
 } from "../post-unit-hooks.ts";
 import { uncheckTaskInPlan } from "../undo.ts";
 
+const { assertEq, assertTrue, report } = createTestContext();
+
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createRetryFixture(): { base: string; cleanup: () => void } {
@@ -64,65 +65,74 @@ function createRetryFixture(): { base: string; cleanup: () => void } {
 // Test: consumeRetryTrigger returns retryArtifact field
 // ═══════════════════════════════════════════════════════════════════════════
 
+console.log("\n=== consumeRetryTrigger: returns null when no retry pending ===");
 
-describe('retry-state-reset', () => {
-test('consumeRetryTrigger: returns null when no retry pending', () => {
+{
   resetHookState();
   const trigger = consumeRetryTrigger();
-  assert.deepStrictEqual(trigger, null, "returns null when no retry pending");
-});
+  assertEq(trigger, null, "returns null when no retry pending");
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: uncheckTaskInPlan reverses doctor's [x] mark
 // ═══════════════════════════════════════════════════════════════════════════
-test('Retry reset step 1: uncheck [x] → [ ] in PLAN.md', () => {
+
+console.log("\n=== Retry reset step 1: uncheck [x] → [ ] in PLAN.md ===");
+
+{
   const { base, cleanup } = createRetryFixture();
   try {
     const planFile = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
 
     // Precondition: T01 is checked
     const before = readFileSync(planFile, "utf-8");
-    assert.ok(before.includes("- [x] **T01:"), "precondition: T01 is checked [x]");
+    assertTrue(before.includes("- [x] **T01:"), "precondition: T01 is checked [x]");
 
     // Step 1: Uncheck T01
     const result = uncheckTaskInPlan(base, "M001", "S01", "T01");
-    assert.ok(result, "uncheckTaskInPlan returns true");
+    assertTrue(result, "uncheckTaskInPlan returns true");
 
     // Verify T01 is now unchecked
     const after = readFileSync(planFile, "utf-8");
-    assert.ok(after.includes("- [ ] **T01:"), "T01 is now unchecked [ ]");
-    assert.ok(!after.includes("- [x] **T01:"), "T01 no longer has [x]");
+    assertTrue(after.includes("- [ ] **T01:"), "T01 is now unchecked [ ]");
+    assertTrue(!after.includes("- [x] **T01:"), "T01 no longer has [x]");
 
     // T02 is unaffected
-    assert.ok(after.includes("- [ ] **T02:"), "T02 remains unchanged");
+    assertTrue(after.includes("- [ ] **T02:"), "T02 remains unchanged");
   } finally {
     cleanup();
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Delete SUMMARY.md for the task
 // ═══════════════════════════════════════════════════════════════════════════
-test('Retry reset step 2: delete SUMMARY.md', () => {
+
+console.log("\n=== Retry reset step 2: delete SUMMARY.md ===");
+
+{
   const { base, cleanup } = createRetryFixture();
   try {
     const summaryFile = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
 
     // Precondition: SUMMARY exists
-    assert.ok(existsSync(summaryFile), "precondition: SUMMARY.md exists");
+    assertTrue(existsSync(summaryFile), "precondition: SUMMARY.md exists");
 
     // Step 2: Delete SUMMARY.md
     unlinkSync(summaryFile);
-    assert.ok(!existsSync(summaryFile), "SUMMARY.md deleted");
+    assertTrue(!existsSync(summaryFile), "SUMMARY.md deleted");
   } finally {
     cleanup();
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Remove from completedUnits array and flush
 // ═══════════════════════════════════════════════════════════════════════════
-test('Retry reset step 3: remove from completedUnits', () => {
+
+console.log("\n=== Retry reset step 3: remove from completedUnits ===");
+
+{
   const { base, cleanup } = createRetryFixture();
   try {
     // Simulate the completedUnits array (as AutoSession would have it)
@@ -136,8 +146,8 @@ test('Retry reset step 3: remove from completedUnits', () => {
       u => !(u.type === "execute-task" && u.id === "M001/S01/T01"),
     );
 
-    assert.deepStrictEqual(filtered.length, 1, "one unit removed from completedUnits");
-    assert.deepStrictEqual(filtered[0].id, "M001/S01/T02", "T02 still in completedUnits");
+    assertEq(filtered.length, 1, "one unit removed from completedUnits");
+    assertEq(filtered[0].id, "M001/S01/T02", "T02 still in completedUnits");
 
     // Flush to completed-units.json
     const completedKeysPath = join(base, ".gsd", "completed-units.json");
@@ -145,36 +155,42 @@ test('Retry reset step 3: remove from completedUnits', () => {
     writeFileSync(completedKeysPath, JSON.stringify(keys, null, 2), "utf-8");
 
     const onDisk = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-    assert.deepStrictEqual(onDisk.length, 1, "completed-units.json has one entry");
-    assert.deepStrictEqual(onDisk[0], "execute-task/M001/S01/T02", "only T02 remains in completed-units.json");
+    assertEq(onDisk.length, 1, "completed-units.json has one entry");
+    assertEq(onDisk[0], "execute-task/M001/S01/T02", "only T02 remains in completed-units.json");
   } finally {
     cleanup();
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Delete the retry_on artifact
 // ═══════════════════════════════════════════════════════════════════════════
-test('Retry reset step 4: delete retry_on artifact', () => {
+
+console.log("\n=== Retry reset step 4: delete retry_on artifact ===");
+
+{
   const { base, cleanup } = createRetryFixture();
   try {
     const retryArtifactPath = resolveHookArtifactPath(base, "M001/S01/T01", "NEEDS-REWORK.md");
 
     // Precondition: artifact exists
-    assert.ok(existsSync(retryArtifactPath), "precondition: retry artifact exists");
+    assertTrue(existsSync(retryArtifactPath), "precondition: retry artifact exists");
 
     // Step 4: Delete retry artifact
     unlinkSync(retryArtifactPath);
-    assert.ok(!existsSync(retryArtifactPath), "retry artifact deleted");
+    assertTrue(!existsSync(retryArtifactPath), "retry artifact deleted");
   } finally {
     cleanup();
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Full retry reset sequence (all steps together)
 // ═══════════════════════════════════════════════════════════════════════════
-test('Full retry reset: all steps combined', () => {
+
+console.log("\n=== Full retry reset: all steps combined ===");
+
+{
   const { base, cleanup } = createRetryFixture();
   try {
     const trigger = {
@@ -226,27 +242,30 @@ test('Full retry reset: all steps combined', () => {
     // PLAN.md: T01 unchecked
     const planFile = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
     const planContent = readFileSync(planFile, "utf-8");
-    assert.ok(planContent.includes("- [ ] **T01:"), "after reset: T01 unchecked in PLAN");
-    assert.ok(!planContent.includes("- [x] **T01:"), "after reset: T01 not checked in PLAN");
+    assertTrue(planContent.includes("- [ ] **T01:"), "after reset: T01 unchecked in PLAN");
+    assertTrue(!planContent.includes("- [x] **T01:"), "after reset: T01 not checked in PLAN");
 
     // SUMMARY.md: deleted
-    assert.ok(!existsSync(summaryFile), "after reset: SUMMARY.md deleted");
+    assertTrue(!existsSync(summaryFile), "after reset: SUMMARY.md deleted");
 
     // completed-units.json: empty
     const onDisk = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-    assert.deepStrictEqual(onDisk.length, 0, "after reset: completed-units.json is empty");
+    assertEq(onDisk.length, 0, "after reset: completed-units.json is empty");
 
     // Retry artifact: deleted
-    assert.ok(!existsSync(retryArtifactPath), "after reset: retry artifact deleted");
+    assertTrue(!existsSync(retryArtifactPath), "after reset: retry artifact deleted");
   } finally {
     cleanup();
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Reset is idempotent — no crash when artifacts are already missing
 // ═══════════════════════════════════════════════════════════════════════════
-test('Retry reset: idempotent when artifacts already missing', () => {
+
+console.log("\n=== Retry reset: idempotent when artifacts already missing ===");
+
+{
   const base = mkdtempSync(join(tmpdir(), "gsd-retry-idempotent-"));
   try {
     // Create minimal structure — NO summary, NO retry artifact, NO plan
@@ -269,38 +288,41 @@ test('Retry reset: idempotent when artifacts already missing', () => {
 
     // Uncheck — returns false because no PLAN file
     const uncheckResult = uncheckTaskInPlan(base, mid, sid, tid);
-    assert.ok(!uncheckResult, "uncheck returns false when no PLAN exists");
+    assertTrue(!uncheckResult, "uncheck returns false when no PLAN exists");
 
     // Summary does not exist — no crash
     const summaryFile = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", `${tid}-SUMMARY.md`);
-    assert.ok(!existsSync(summaryFile), "no summary to delete — safe");
+    assertTrue(!existsSync(summaryFile), "no summary to delete — safe");
 
     // Retry artifact does not exist — no crash
     const retryPath = resolveHookArtifactPath(base, trigger.unitId, trigger.retryArtifact);
-    assert.ok(!existsSync(retryPath), "no retry artifact to delete — safe");
+    assertTrue(!existsSync(retryPath), "no retry artifact to delete — safe");
 
     // completed-units.json filter on empty array — safe
     const completedUnits: Array<{ type: string; id: string }> = [];
     const filtered = completedUnits.filter(
       u => !(u.type === trigger.unitType && u.id === trigger.unitId),
     );
-    assert.deepStrictEqual(filtered.length, 0, "filter on empty array is safe");
+    assertEq(filtered.length, 0, "filter on empty array is safe");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: resolveHookArtifactPath produces correct path for retry artifacts
 // ═══════════════════════════════════════════════════════════════════════════
-test('resolveHookArtifactPath: correct path for retry artifacts', () => {
+
+console.log("\n=== resolveHookArtifactPath: correct path for retry artifacts ===");
+
+{
   const base = "/project";
   const path = resolveHookArtifactPath(base, "M001/S01/T01", "NEEDS-REWORK.md");
-  assert.deepStrictEqual(
+  assertEq(
     path,
     join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-NEEDS-REWORK.md"),
     "retry artifact path resolves to task directory with task prefix",
   );
-});
+}
 
-});
+report();