gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/prompt-db.test.ts

@@ -5,8 +5,7 @@
 // (b) Helpers fall back to non-null output when DB unavailable
 // (c) Scoped filtering actually reduces content
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 import {
   openDatabase,
   closeDatabase,
@@ -23,6 +22,8 @@ import {
   formatRequirementsForPrompt,
 } from '../context-store.ts';
 
+const { assertEq, assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
+
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: DB-aware decisions helper returns scoped content
 // ═══════════════════════════════════════════════════════════════════════════
@@ -49,23 +50,23 @@ console.log('\n=== prompt-db: scoped decisions from DB ===');
 
   // Query scoped to M001
   const m001Decisions = queryDecisions({ milestoneId: 'M001' });
-  assert.ok(m001Decisions.length > 0, 'M001 decisions should exist');
-  assert.ok(m001Decisions.length < 10, `scoped query should return fewer than 10 (got ${m001Decisions.length})`);
+  assertTrue(m001Decisions.length > 0, 'M001 decisions should exist');
+  assertTrue(m001Decisions.length < 10, `scoped query should return fewer than 10 (got ${m001Decisions.length})`);
 
   // Verify all returned decisions are for M001
   for (const d of m001Decisions) {
-    assert.match(d.when_context, /M001/, `decision ${d.id} should be for M001`);
+    assertMatch(d.when_context, /M001/, `decision ${d.id} should be for M001`);
   }
 
   // Format and verify wrapping
   const formatted = formatDecisionsForPrompt(m001Decisions);
-  assert.ok(formatted.length > 0, 'formatted decisions should be non-empty');
-  assert.match(formatted, /\| # \| When \| Scope/, 'formatted decisions have table header');
+  assertTrue(formatted.length > 0, 'formatted decisions should be non-empty');
+  assertMatch(formatted, /\| # \| When \| Scope/, 'formatted decisions have table header');
 
   // Verify the expected wrapper format that inlineDecisionsFromDb would produce
   const wrapped = `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${formatted}`;
-  assert.match(wrapped, /^### Decisions/, 'wrapped decisions start with ### Decisions');
-  assert.match(wrapped, /Source:.*DECISIONS\.md/, 'wrapped decisions have source path');
+  assertMatch(wrapped, /^### Decisions/, 'wrapped decisions start with ### Decisions');
+  assertMatch(wrapped, /Source:.*DECISIONS\.md/, 'wrapped decisions have source path');
 
   closeDatabase();
 }
@@ -100,25 +101,25 @@ console.log('\n=== prompt-db: scoped requirements from DB ===');
 
   // Query scoped to S01 — should get R001 (primary) and R002 (supporting)
   const s01Reqs = queryRequirements({ sliceId: 'S01' });
-  assert.deepStrictEqual(s01Reqs.length, 2, 'S01 requirements should be 2 (primary + supporting)');
+  assertEq(s01Reqs.length, 2, 'S01 requirements should be 2 (primary + supporting)');
   const ids = s01Reqs.map(r => r.id).sort();
-  assert.deepStrictEqual(ids, ['R001', 'R002'], 'S01 owns R001 and supports R002');
+  assertEq(ids, ['R001', 'R002'], 'S01 owns R001 and supports R002');
 
   // Unscoped query returns all 3
   const allReqs = queryRequirements();
-  assert.deepStrictEqual(allReqs.length, 3, 'unscoped requirements should return all 3');
+  assertEq(allReqs.length, 3, 'unscoped requirements should return all 3');
 
   // Format and verify wrapping
   const formatted = formatRequirementsForPrompt(s01Reqs);
-  assert.ok(formatted.length > 0, 'formatted requirements should be non-empty');
-  assert.match(formatted, /### R001/, 'formatted requirements include R001');
-  assert.match(formatted, /### R002/, 'formatted requirements include R002');
-  assert.doesNotMatch(formatted, /### R003/, 'formatted requirements exclude R003');
+  assertTrue(formatted.length > 0, 'formatted requirements should be non-empty');
+  assertMatch(formatted, /### R001/, 'formatted requirements include R001');
+  assertMatch(formatted, /### R002/, 'formatted requirements include R002');
+  assertNoMatch(formatted, /### R003/, 'formatted requirements exclude R003');
 
   // Verify the expected wrapper format that inlineRequirementsFromDb would produce
   const wrapped = `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${formatted}`;
-  assert.match(wrapped, /^### Requirements/, 'wrapped requirements start with ### Requirements');
-  assert.match(wrapped, /Source:.*REQUIREMENTS\.md/, 'wrapped requirements have source path');
+  assertMatch(wrapped, /^### Requirements/, 'wrapped requirements start with ### Requirements');
+  assertMatch(wrapped, /Source:.*REQUIREMENTS\.md/, 'wrapped requirements have source path');
 
   closeDatabase();
 }
@@ -141,13 +142,13 @@ console.log('\n=== prompt-db: project content from DB ===');
   });
 
   const content = queryProject();
-  assert.deepStrictEqual(content, '# Test Project\n\nThis is the project description.', 'queryProject returns content');
+  assertEq(content, '# Test Project\n\nThis is the project description.', 'queryProject returns content');
 
   // Verify the expected wrapper format that inlineProjectFromDb would produce
   const wrapped = `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${content}`;
-  assert.match(wrapped, /^### Project/, 'wrapped project starts with ### Project');
-  assert.match(wrapped, /Source:.*PROJECT\.md/, 'wrapped project has source path');
-  assert.match(wrapped, /# Test Project/, 'wrapped project includes content');
+  assertMatch(wrapped, /^### Project/, 'wrapped project starts with ### Project');
+  assertMatch(wrapped, /Source:.*PROJECT\.md/, 'wrapped project has source path');
+  assertMatch(wrapped, /# Test Project/, 'wrapped project includes content');
 
   closeDatabase();
 }
@@ -159,27 +160,27 @@ console.log('\n=== prompt-db: project content from DB ===');
 console.log('\n=== prompt-db: fallback when DB unavailable ===');
 {
   closeDatabase();
-  assert.ok(!isDbAvailable(), 'DB should not be available');
+  assertTrue(!isDbAvailable(), 'DB should not be available');
 
   // queryDecisions returns [] when DB closed — helper would fall back
   const decisions = queryDecisions({ milestoneId: 'M001' });
-  assert.deepStrictEqual(decisions, [], 'queryDecisions returns [] when DB closed');
+  assertEq(decisions, [], 'queryDecisions returns [] when DB closed');
 
   // queryRequirements returns [] when DB closed — helper would fall back
   const requirements = queryRequirements({ sliceId: 'S01' });
-  assert.deepStrictEqual(requirements, [], 'queryRequirements returns [] when DB closed');
+  assertEq(requirements, [], 'queryRequirements returns [] when DB closed');
 
   // queryProject returns null when DB closed — helper would fall back
   const project = queryProject();
-  assert.deepStrictEqual(project, null, 'queryProject returns null when DB closed');
+  assertEq(project, null, 'queryProject returns null when DB closed');
 
   // formatDecisionsForPrompt returns '' for empty input
   const formatted = formatDecisionsForPrompt([]);
-  assert.deepStrictEqual(formatted, '', 'formatDecisionsForPrompt returns empty for empty input');
+  assertEq(formatted, '', 'formatDecisionsForPrompt returns empty for empty input');
 
   // formatRequirementsForPrompt returns '' for empty input
   const formattedReqs = formatRequirementsForPrompt([]);
-  assert.deepStrictEqual(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
+  assertEq(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -209,15 +210,15 @@ console.log('\n=== prompt-db: scoped filtering reduces content ===');
   const allDecisions = queryDecisions();
   const m001Decisions = queryDecisions({ milestoneId: 'M001' });
 
-  assert.deepStrictEqual(allDecisions.length, 10, 'unscoped returns all 10 decisions');
-  assert.ok(m001Decisions.length < 10, `M001-scoped returns fewer than 10 (got ${m001Decisions.length})`);
-  assert.ok(m001Decisions.length > 0, 'M001-scoped returns at least 1');
+  assertEq(allDecisions.length, 10, 'unscoped returns all 10 decisions');
+  assertTrue(m001Decisions.length < 10, `M001-scoped returns fewer than 10 (got ${m001Decisions.length})`);
+  assertTrue(m001Decisions.length > 0, 'M001-scoped returns at least 1');
 
   // Format both and compare sizes — scoped should be shorter
   const allFormatted = formatDecisionsForPrompt(allDecisions);
   const scopedFormatted = formatDecisionsForPrompt(m001Decisions);
 
-  assert.ok(
+  assertTrue(
     scopedFormatted.length < allFormatted.length,
     `scoped content (${scopedFormatted.length} chars) should be shorter than unscoped (${allFormatted.length} chars)`,
   );
@@ -244,14 +245,14 @@ console.log('\n=== prompt-db: scoped filtering reduces content ===');
   const allReqs = queryRequirements();
   const s01Reqs = queryRequirements({ sliceId: 'S01' });
 
-  assert.deepStrictEqual(allReqs.length, 8, 'unscoped returns all 8 requirements');
-  assert.ok(s01Reqs.length < 8, `S01-scoped returns fewer than 8 (got ${s01Reqs.length})`);
-  assert.ok(s01Reqs.length > 0, 'S01-scoped returns at least 1');
+  assertEq(allReqs.length, 8, 'unscoped returns all 8 requirements');
+  assertTrue(s01Reqs.length < 8, `S01-scoped returns fewer than 8 (got ${s01Reqs.length})`);
+  assertTrue(s01Reqs.length > 0, 'S01-scoped returns at least 1');
 
   const allReqsFormatted = formatRequirementsForPrompt(allReqs);
   const scopedReqsFormatted = formatRequirementsForPrompt(s01Reqs);
 
-  assert.ok(
+  assertTrue(
     scopedReqsFormatted.length < allReqsFormatted.length,
     `scoped requirements (${scopedReqsFormatted.length} chars) should be shorter than unscoped (${allReqsFormatted.length} chars)`,
   );
@@ -291,23 +292,23 @@ console.log('\n=== prompt-db: DB helpers wrapper format matches expected pattern
 
   // Simulate what inlineDecisionsFromDb does
   const decisions = queryDecisions({ milestoneId: 'M001' });
-  assert.ok(decisions.length === 1, 'got 1 decision for M001');
+  assertTrue(decisions.length === 1, 'got 1 decision for M001');
   const dFormatted = formatDecisionsForPrompt(decisions);
   const dWrapped = `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${dFormatted}`;
-  assert.match(dWrapped, /^### Decisions\nSource: `.gsd\/DECISIONS\.md`\n\n\| #/, 'decisions wrapper format correct');
+  assertMatch(dWrapped, /^### Decisions\nSource: `.gsd\/DECISIONS\.md`\n\n\| #/, 'decisions wrapper format correct');
 
   // Simulate what inlineRequirementsFromDb does
   const reqs = queryRequirements({ sliceId: 'S01' });
-  assert.ok(reqs.length === 1, 'got 1 requirement for S01');
+  assertTrue(reqs.length === 1, 'got 1 requirement for S01');
   const rFormatted = formatRequirementsForPrompt(reqs);
   const rWrapped = `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${rFormatted}`;
-  assert.match(rWrapped, /^### Requirements\nSource: `.gsd\/REQUIREMENTS\.md`\n\n### R001/, 'requirements wrapper format correct');
+  assertMatch(rWrapped, /^### Requirements\nSource: `.gsd\/REQUIREMENTS\.md`\n\n### R001/, 'requirements wrapper format correct');
 
   // Simulate what inlineProjectFromDb does
   const project = queryProject();
-  assert.ok(project !== null, 'project content exists');
+  assertTrue(project !== null, 'project content exists');
   const pWrapped = `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${project}`;
-  assert.match(pWrapped, /^### Project\nSource: `.gsd\/PROJECT\.md`\n\n# Project Name/, 'project wrapper format correct');
+  assertMatch(pWrapped, /^### Project\nSource: `.gsd\/PROJECT\.md`\n\n# Project Name/, 'project wrapper format correct');
 
   closeDatabase();
 }
@@ -321,9 +322,8 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { migrateFromMarkdown } from '../md-importer.ts';
 
-
-describe('prompt-db', () => {
-test('prompt-db: re-import updates DB when source markdown changes', () => {
+console.log('\n=== prompt-db: re-import updates DB when source markdown changes ===');
+{
   // Create a temp dir simulating a project with .gsd/DECISIONS.md
   const tmpDir = mkdtempSync(join(tmpdir(), 'prompt-db-reimport-'));
   const gsdDir = join(tmpDir, '.gsd');
@@ -345,9 +345,9 @@ test('prompt-db: re-import updates DB when source markdown changes', () => {
 
   // Verify initial state: 2 decisions
   const initial = queryDecisions();
-  assert.deepStrictEqual(initial.length, 2, 're-import: initial import has 2 decisions');
+  assertEq(initial.length, 2, 're-import: initial import has 2 decisions');
   const initialIds = initial.map(d => d.id).sort();
-  assert.deepStrictEqual(initialIds, ['D001', 'D002'], 're-import: initial decisions are D001, D002');
+  assertEq(initialIds, ['D001', 'D002'], 're-import: initial decisions are D001, D002');
 
   // Now "the LLM modifies DECISIONS.md" — add a third decision
   const updatedDecisions = `# Decisions Register
@@ -365,23 +365,23 @@ test('prompt-db: re-import updates DB when source markdown changes', () => {
 
   // Verify DB now has 3 decisions
   const afterReimport = queryDecisions();
-  assert.deepStrictEqual(afterReimport.length, 3, 're-import: after re-import has 3 decisions');
+  assertEq(afterReimport.length, 3, 're-import: after re-import has 3 decisions');
   const afterIds = afterReimport.map(d => d.id).sort();
-  assert.deepStrictEqual(afterIds, ['D001', 'D002', 'D003'], 're-import: decisions are D001, D002, D003');
+  assertEq(afterIds, ['D001', 'D002', 'D003'], 're-import: decisions are D001, D002, D003');
 
   // Verify the new decision has correct data
   const d003 = afterReimport.find(d => d.id === 'D003');
-  assert.ok(d003 !== undefined, 're-import: D003 exists');
-  assert.deepStrictEqual(d003!.when_context, 'M001/S02', 're-import: D003 when_context is M001/S02');
-  assert.deepStrictEqual(d003!.scope, 'runtime', 're-import: D003 scope is runtime');
-  assert.deepStrictEqual(d003!.choice, 'D014 pattern', 're-import: D003 choice is D014 pattern');
+  assertTrue(d003 !== undefined, 're-import: D003 exists');
+  assertEq(d003!.when_context, 'M001/S02', 're-import: D003 when_context is M001/S02');
+  assertEq(d003!.scope, 'runtime', 're-import: D003 scope is runtime');
+  assertEq(d003!.choice, 'D014 pattern', 're-import: D003 choice is D014 pattern');
 
   // Verify scoped query picks up the new decision
   const m001Scoped = queryDecisions({ milestoneId: 'M001' });
-  assert.ok(m001Scoped.length === 3, 're-import: all 3 decisions are for M001');
+  assertTrue(m001Scoped.length === 3, 're-import: all 3 decisions are for M001');
 
   closeDatabase();
-});
+}
 
 // ─── Final Report ──────────────────────────────────────────────────────────
-});
+report();

package/src/resources/extensions/gsd/tests/queue-draft-detection.test.ts

@@ -1,5 +1,3 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -7,94 +5,122 @@ import { tmpdir } from "node:os";
 import { deriveState } from "../state.js";
 import { buildExistingMilestonesContext } from "../guided-flow.js";
 
-describe('queue-draft-detection', () => {
-  test('draft and context milestone detection', async () => {
-    const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-draft-test-"));
-    const gsd = join(tmpBase, ".gsd");
-
-    try {
-      // M001: has only CONTEXT-DRAFT.md (draft milestone)
-      mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
-      writeFileSync(
-        join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
-        "# M001: Draft Milestone\n\nSeed material from prior discussion.\n",
-      );
-
-      // M002: has full CONTEXT.md (ready milestone)
-      mkdirSync(join(gsd, "milestones", "M002"), { recursive: true });
-      writeFileSync(
-        join(gsd, "milestones", "M002", "M002-CONTEXT.md"),
-        "# M002: Ready Milestone\n\nFull context from deep discussion.\n",
-      );
-
-      // M003: has both CONTEXT.md and CONTEXT-DRAFT.md (CONTEXT wins)
-      mkdirSync(join(gsd, "milestones", "M003"), { recursive: true });
-      writeFileSync(
-        join(gsd, "milestones", "M003", "M003-CONTEXT.md"),
-        "# M003: Full Context\n\nThis is the real context.\n",
-      );
-      writeFileSync(
-        join(gsd, "milestones", "M003", "M003-CONTEXT-DRAFT.md"),
-        "# M003: Draft\n\nThis should be ignored.\n",
-      );
-
-      // M004: has neither (empty milestone dir)
-      mkdirSync(join(gsd, "milestones", "M004"), { recursive: true });
-
-      // Build context
-      const state = await deriveState(tmpBase);
-      const milestoneIds = ["M001", "M002", "M003", "M004"];
-      const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, state);
-
-      // draft-only milestone includes "Draft context available"
-      assert.ok(
-        context.includes("Draft context available"),
-        "M001 (draft-only) should include 'Draft context available' label",
-      );
-      assert.ok(
-        context.includes("Seed material from prior discussion"),
-        "M001 draft content should be included in context output",
-      );
-
-      // full-context milestone uses "Context:" label
-      assert.ok(
-        context.includes("**Context:**"),
-        "M002 (full context) should use 'Context:' label",
-      );
-      assert.ok(
-        context.includes("Full context from deep discussion"),
-        "M002 context content should be included",
-      );
-
-      // both files: CONTEXT.md wins, no draft label
-      const m003Idx = context.indexOf("M003:");
-      const m003Section = context.slice(m003Idx, m003Idx + 500);
-      assert.ok(
-        m003Section.includes("**Context:**"),
-        "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
-      );
-      assert.ok(
-        !m003Section.includes("Draft context available"),
-        "M003 (both files) should NOT show draft label — CONTEXT.md takes precedence",
-      );
-      assert.ok(
-        m003Section.includes("This is the real context"),
-        "M003 should show CONTEXT.md content, not draft content",
-      );
-
-      // neither file: no context section
-      const m004Idx = context.indexOf("M004:");
-      const m004Section = context.slice(m004Idx, m004Idx + 500);
-      assert.ok(
-        !m004Section.includes("**Context:**"),
-        "M004 (neither file) should not have Context: label",
-      );
-      assert.ok(
-        !m004Section.includes("Draft context available"),
-        "M004 (neither file) should not have Draft label",
-      );
-    } finally {
-      rmSync(tmpBase, { recursive: true, force: true });
-    }
-  });
-});
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+// ─── Fixture setup ──────────────────────────────────────────────────────
+
+const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-draft-test-"));
+const gsd = join(tmpBase, ".gsd");
+
+// M001: has only CONTEXT-DRAFT.md (draft milestone)
+mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
+writeFileSync(
+  join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
+  "# M001: Draft Milestone\n\nSeed material from prior discussion.\n",
+);
+
+// M002: has full CONTEXT.md (ready milestone)
+mkdirSync(join(gsd, "milestones", "M002"), { recursive: true });
+writeFileSync(
+  join(gsd, "milestones", "M002", "M002-CONTEXT.md"),
+  "# M002: Ready Milestone\n\nFull context from deep discussion.\n",
+);
+
+// M003: has both CONTEXT.md and CONTEXT-DRAFT.md (CONTEXT wins)
+mkdirSync(join(gsd, "milestones", "M003"), { recursive: true });
+writeFileSync(
+  join(gsd, "milestones", "M003", "M003-CONTEXT.md"),
+  "# M003: Full Context\n\nThis is the real context.\n",
+);
+writeFileSync(
+  join(gsd, "milestones", "M003", "M003-CONTEXT-DRAFT.md"),
+  "# M003: Draft\n\nThis should be ignored.\n",
+);
+
+// M004: has neither (empty milestone dir)
+mkdirSync(join(gsd, "milestones", "M004"), { recursive: true });
+
+// ─── Build context ──────────────────────────────────────────────────────
+
+const state = await deriveState(tmpBase);
+const milestoneIds = ["M001", "M002", "M003", "M004"];
+const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, state);
+
+// ─── Test: draft-only milestone includes "Draft context available" ──────
+
+assert(
+  context.includes("Draft context available"),
+  "M001 (draft-only) should include 'Draft context available' label",
+);
+
+assert(
+  context.includes("Seed material from prior discussion"),
+  "M001 draft content should be included in context output",
+);
+
+// ─── Test: full-context milestone uses "Context:" label ────────────────
+
+assert(
+  context.includes("**Context:**"),
+  "M002 (full context) should use 'Context:' label",
+);
+
+assert(
+  context.includes("Full context from deep discussion"),
+  "M002 context content should be included",
+);
+
+// ─── Test: both files → CONTEXT.md wins, no draft label ────────────────
+
+// Find M003's section and check it has Context: but not Draft
+const m003Idx = context.indexOf("M003:");
+const m003Section = context.slice(m003Idx, m003Idx + 500);
+
+assert(
+  m003Section.includes("**Context:**"),
+  "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
+);
+
+assert(
+  !m003Section.includes("Draft context available"),
+  "M003 (both files) should NOT show draft label — CONTEXT.md takes precedence",
+);
+
+assert(
+  m003Section.includes("This is the real context"),
+  "M003 should show CONTEXT.md content, not draft content",
+);
+
+// ─── Test: neither file → no context section ───────────────────────────
+
+const m004Idx = context.indexOf("M004:");
+const m004Section = context.slice(m004Idx, m004Idx + 500);
+
+assert(
+  !m004Section.includes("**Context:**"),
+  "M004 (neither file) should not have Context: label",
+);
+
+assert(
+  !m004Section.includes("Draft context available"),
+  "M004 (neither file) should not have Draft label",
+);
+
+// ─── Cleanup ──────────────────────────────────────────────────────────
+
+rmSync(tmpBase, { recursive: true, force: true });
+
+// ─── Results ──────────────────────────────────────────────────────────
+
+console.log(`\nqueue-draft-detection: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);