gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.5a170d0

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

@@ -0,0 +1,386 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdirSync,
+  readFileSync,
+  existsSync,
+  rmSync,
+  chmodSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  emitJournalEvent,
+  queryJournal,
+  type JournalEntry,
+} from "../journal.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* */
+  }
+}
+
+function makeEntry(overrides: Partial<JournalEntry> = {}): JournalEntry {
+  return {
+    ts: "2025-03-21T10:00:00.000Z",
+    flowId: "flow-aaa",
+    seq: 0,
+    eventType: "iteration-start",
+    ...overrides,
+  };
+}
+
+// ─── emitJournalEvent ─────────────────────────────────────────────────────────
+
+test("emitJournalEvent creates journal directory and JSONL file", () => {
+  const base = makeTmpBase();
+  try {
+    const entry = makeEntry();
+    emitJournalEvent(base, entry);
+
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    assert.ok(existsSync(filePath), "JSONL file should exist");
+
+    const raw = readFileSync(filePath, "utf-8").trim();
+    const parsed = JSON.parse(raw);
+    assert.equal(parsed.ts, entry.ts);
+    assert.equal(parsed.flowId, entry.flowId);
+    assert.equal(parsed.seq, entry.seq);
+    assert.equal(parsed.eventType, entry.eventType);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("emitJournalEvent appends multiple lines to the same file", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(base, makeEntry({ seq: 0 }));
+    emitJournalEvent(base, makeEntry({ seq: 1, eventType: "dispatch-match" }));
+    emitJournalEvent(base, makeEntry({ seq: 2, eventType: "unit-start" }));
+
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    const lines = readFileSync(filePath, "utf-8").trim().split("\n");
+    assert.equal(lines.length, 3, "Should have 3 lines");
+
+    const parsed = lines.map(l => JSON.parse(l));
+    assert.equal(parsed[0].seq, 0);
+    assert.equal(parsed[1].seq, 1);
+    assert.equal(parsed[2].seq, 2);
+    assert.equal(parsed[1].eventType, "dispatch-match");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("emitJournalEvent auto-creates nonexistent parent directory", () => {
+  const base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
+  // Don't create .gsd/ — emitJournalEvent should handle it via mkdirSync recursive
+  try {
+    emitJournalEvent(base, makeEntry());
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    assert.ok(existsSync(filePath), "File should exist even when parent dirs did not");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("emitJournalEvent preserves optional fields (rule, causedBy, data)", () => {
+  const base = makeTmpBase();
+  try {
+    const entry = makeEntry({
+      rule: "my-dispatch-rule",
+      causedBy: { flowId: "flow-prior", seq: 3 },
+      data: { unitId: "M001/S01/T01", status: "ok" },
+    });
+    emitJournalEvent(base, entry);
+
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    const parsed = JSON.parse(readFileSync(filePath, "utf-8").trim());
+    assert.equal(parsed.rule, "my-dispatch-rule");
+    assert.deepEqual(parsed.causedBy, { flowId: "flow-prior", seq: 3 });
+    assert.equal(parsed.data.unitId, "M001/S01/T01");
+    assert.equal(parsed.data.status, "ok");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("emitJournalEvent silently catches write errors (no throw)", () => {
+  // Use a path that can't be created — null bytes in path
+  assert.doesNotThrow(() => {
+    emitJournalEvent("/dev/null/impossible\0path", makeEntry());
+  });
+});
+
+test("emitJournalEvent silently catches read-only directory errors", () => {
+  const base = makeTmpBase();
+  const journalDir = join(base, ".gsd", "journal");
+  mkdirSync(journalDir, { recursive: true });
+
+  try {
+    // Make the journal directory read-only
+    chmodSync(journalDir, 0o444);
+
+    // Should not throw
+    assert.doesNotThrow(() => {
+      emitJournalEvent(base, makeEntry());
+    });
+  } finally {
+    // Restore permissions for cleanup
+    try {
+      chmodSync(journalDir, 0o755);
+    } catch {
+      /* */
+    }
+    cleanup(base);
+  }
+});
+
+// ─── Daily Rotation ───────────────────────────────────────────────────────────
+
+test("daily rotation: events with different dates go to different files", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-20T23:59:59.000Z" }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T00:00:01.000Z" }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-22T12:00:00.000Z" }));
+
+    const journalDir = join(base, ".gsd", "journal");
+    assert.ok(existsSync(join(journalDir, "2025-03-20.jsonl")));
+    assert.ok(existsSync(join(journalDir, "2025-03-21.jsonl")));
+    assert.ok(existsSync(join(journalDir, "2025-03-22.jsonl")));
+
+    // Verify each file has exactly one line
+    for (const date of ["2025-03-20", "2025-03-21", "2025-03-22"]) {
+      const lines = readFileSync(join(journalDir, `${date}.jsonl`), "utf-8")
+        .trim()
+        .split("\n");
+      assert.equal(lines.length, 1, `${date}.jsonl should have 1 line`);
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── queryJournal ─────────────────────────────────────────────────────────────
+
+test("queryJournal returns all entries when no filters provided", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(base, makeEntry({ seq: 0 }));
+    emitJournalEvent(base, makeEntry({ seq: 1, eventType: "dispatch-match" }));
+
+    const results = queryJournal(base);
+    assert.equal(results.length, 2);
+    assert.equal(results[0].seq, 0);
+    assert.equal(results[1].seq, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal filters by flowId", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(base, makeEntry({ flowId: "flow-aaa", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ flowId: "flow-bbb", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ flowId: "flow-aaa", seq: 2 }));
+
+    const results = queryJournal(base, { flowId: "flow-aaa" });
+    assert.equal(results.length, 2);
+    assert.ok(results.every(e => e.flowId === "flow-aaa"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal filters by eventType", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(base, makeEntry({ eventType: "iteration-start", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ eventType: "dispatch-match", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ eventType: "unit-start", seq: 2 }));
+    emitJournalEvent(base, makeEntry({ eventType: "dispatch-match", seq: 3 }));
+
+    const results = queryJournal(base, { eventType: "dispatch-match" });
+    assert.equal(results.length, 2);
+    assert.ok(results.every(e => e.eventType === "dispatch-match"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal filters by unitId (from data.unitId)", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 0, data: { unitId: "M001/S01/T01" } }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 1, data: { unitId: "M001/S01/T02" } }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 2, data: { unitId: "M001/S01/T01" } }),
+    );
+    emitJournalEvent(base, makeEntry({ seq: 3 })); // no data
+
+    const results = queryJournal(base, { unitId: "M001/S01/T01" });
+    assert.equal(results.length, 2);
+    assert.ok(
+      results.every(
+        e => (e.data as Record<string, unknown>)?.unitId === "M001/S01/T01",
+      ),
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal filters by time range (after/before)", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-20T08:00:00.000Z", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T10:00:00.000Z", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T15:00:00.000Z", seq: 2 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-22T20:00:00.000Z", seq: 3 }));
+
+    // After only
+    const afterResults = queryJournal(base, { after: "2025-03-21T00:00:00.000Z" });
+    assert.equal(afterResults.length, 3, "3 entries on or after 2025-03-21");
+
+    // Before only
+    const beforeResults = queryJournal(base, { before: "2025-03-21T12:00:00.000Z" });
+    assert.equal(beforeResults.length, 2, "2 entries on or before noon on 03-21");
+
+    // Both after and before
+    const rangeResults = queryJournal(base, {
+      after: "2025-03-21T00:00:00.000Z",
+      before: "2025-03-21T23:59:59.000Z",
+    });
+    assert.equal(rangeResults.length, 2, "2 entries within 2025-03-21");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal combines multiple filters", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(
+      base,
+      makeEntry({ flowId: "flow-aaa", eventType: "unit-start", seq: 0 }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ flowId: "flow-aaa", eventType: "dispatch-match", seq: 1 }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ flowId: "flow-bbb", eventType: "unit-start", seq: 2 }),
+    );
+
+    const results = queryJournal(base, {
+      flowId: "flow-aaa",
+      eventType: "unit-start",
+    });
+    assert.equal(results.length, 1);
+    assert.equal(results[0].flowId, "flow-aaa");
+    assert.equal(results[0].eventType, "unit-start");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal on nonexistent directory returns empty array", () => {
+  const base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
+  // Don't create anything
+  try {
+    const results = queryJournal(base);
+    assert.deepEqual(results, []);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal skips malformed JSON lines gracefully", () => {
+  const base = makeTmpBase();
+  try {
+    const journalDir = join(base, ".gsd", "journal");
+    mkdirSync(journalDir, { recursive: true });
+
+    // Write a file with a mix of valid and invalid lines
+    const validEntry = JSON.stringify(makeEntry({ seq: 0 }));
+    const content = `${validEntry}\n{not valid json\n${JSON.stringify(makeEntry({ seq: 1 }))}\n`;
+    writeFileSync(join(journalDir, "2025-03-21.jsonl"), content);
+
+    const results = queryJournal(base);
+    assert.equal(results.length, 2, "Should skip the malformed line");
+    assert.equal(results[0].seq, 0);
+    assert.equal(results[1].seq, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal reads across multiple daily files", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-20T12:00:00.000Z", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T12:00:00.000Z", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-22T12:00:00.000Z", seq: 2 }));
+
+    const results = queryJournal(base);
+    assert.equal(results.length, 3, "Should read from all 3 files");
+    // Files are sorted, so order should be chronological
+    assert.equal(results[0].ts, "2025-03-20T12:00:00.000Z");
+    assert.equal(results[1].ts, "2025-03-21T12:00:00.000Z");
+    assert.equal(results[2].ts, "2025-03-22T12:00:00.000Z");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryJournal filters by rule", () => {
+  const base = makeTmpBase();
+  try {
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 0, eventType: "dispatch-match", rule: "dispatch-task" }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 1, eventType: "post-unit-hook", rule: "post-unit-hook" }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 2, eventType: "dispatch-match", rule: "dispatch-task" }),
+    );
+
+    const results = queryJournal(base, { rule: "dispatch-task" });
+    assert.equal(results.length, 2, "Should return only dispatch-task entries");
+    assert.ok(
+      results.every(e => e.rule === "dispatch-task"),
+      "All results should have rule === 'dispatch-task'",
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -187,6 +187,36 @@ console.log('=== md-importer: malformed/empty rows skipped ===');
   assertEq(decisions[1].id, 'D003', 'second valid row (skipping malformed)');
 }
 
+console.log('=== md-importer: made_by backward compatibility (old 7-column format) ===');
+
+{
+  const decisions = parseDecisionsTable(DECISIONS_MD);
+  // Old format has no Made By column — should default to 'agent'
+  for (const d of decisions) {
+    assertEq(d.made_by, 'agent', `${d.id} made_by defaults to agent for legacy format`);
+  }
+}
+
+console.log('=== md-importer: made_by column parsing (new 8-column format) ===');
+
+{
+  const newFormatMd = `# Decisions Register
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |
+|---|------|-------|----------|--------|-----------|------------|---------|
+| D001 | M001 | library | SQLite library | better-sqlite3 | Sync API | No | human |
+| D002 | M001 | arch | DB location | .gsd/gsd.db | Derived state | No | agent |
+| D003 | M002 | impl | Config format | JSON | Simple | Yes | collaborative |
+| D004 | M002 | impl | Cache strategy | LRU | Predictable | No | bogus |
+`;
+  const decisions = parseDecisionsTable(newFormatMd);
+  assertEq(decisions.length, 4, 'should parse 4 decisions with new format');
+  assertEq(decisions[0].made_by, 'human', 'D001 made_by = human');
+  assertEq(decisions[1].made_by, 'agent', 'D002 made_by = agent');
+  assertEq(decisions[2].made_by, 'collaborative', 'D003 made_by = collaborative');
+  assertEq(decisions[3].made_by, 'agent', 'D004 invalid made_by defaults to agent');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // md-importer: parseRequirementsSections
 // ═══════════════════════════════════════════════════════════════════════════
@@ -354,7 +384,7 @@ console.log('=== md-importer: schema v1→v2 migration ===');
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(version?.v, 3, 'new DB should be at schema version 3');
+  assertEq(version?.v, 4, 'new DB should be at schema version 4');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -335,9 +335,9 @@ console.log('\n=== memory-store: schema includes memories table ===');
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assertEq(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 3
+  // Verify schema version is 4
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(version?.['v'], 3, 'schema version should be 3');
+  assertEq(version?.['v'], 4, 'schema version should be 4');
 
   closeDatabase();
 }

package/src/resources/extensions/gsd/tests/milestone-id-reservation.test.ts

@@ -1,5 +1,5 @@
 // milestone-id-reservation — Verifies that preview IDs from guided-flow
-// match the IDs claimed by gsd_generate_milestone_id via the shared
+// match the IDs claimed by gsd_milestone_generate_id via the shared
 // reservation mechanism in milestone-ids.ts.
 //
 // Regression test for #1569.

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

@@ -652,6 +652,116 @@ console.log('\n=== parsePlan: new-format task entries with Files and Verify subl
   assertTrue(p.tasks[0].description.includes('Why: because we need typed plan entries'), 'Why line accumulates into description');
 }
 
+console.log('\n=== parsePlan: heading-style task entries (### T01 -- Title) ===');
+{
+  const content = `# S11: Heading Style
+
+**Goal:** Test heading-style task parsing.
+**Demo:** Parser handles heading-style task entries.
+
+## Tasks
+
+### T01 -- Implement feature
+
+- Why: the feature is needed
+- Files: \`src/feature.ts\`
+- Verify: npm test
+
+### T02 -- Write tests \`est:1h\`
+
+Some description for the second task.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 2, 'heading-style task count');
+  assertEq(p.tasks[0].id, 'T01', 'heading T01 id');
+  assertEq(p.tasks[0].title, 'Implement feature', 'heading T01 title');
+  assertEq(p.tasks[0].done, false, 'heading T01 not done (headings have no checkbox)');
+  assertEq(p.tasks[0].files![0], 'src/feature.ts', 'heading T01 files extracted');
+  assertEq(p.tasks[0].verify, 'npm test', 'heading T01 verify extracted');
+  assertEq(p.tasks[1].id, 'T02', 'heading T02 id');
+  assertEq(p.tasks[1].title, 'Write tests', 'heading T02 title');
+  assertEq(p.tasks[1].estimate, '1h', 'heading T02 estimate');
+  assertTrue(p.tasks[1].description.includes('Some description'), 'heading T02 description');
+}
+
+console.log('\n=== parsePlan: heading-style with colon separator (### T01: Title) ===');
+{
+  const content = `# S12: Heading Colon Style
+
+**Goal:** Test colon-separated heading tasks.
+**Demo:** Parser handles colon separator.
+
+## Tasks
+
+### T01: Setup project
+  Basic project setup steps.
+
+### T02: Add CI pipeline \`est:30m\`
+  Configure CI.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 2, 'colon heading task count');
+  assertEq(p.tasks[0].id, 'T01', 'colon heading T01 id');
+  assertEq(p.tasks[0].title, 'Setup project', 'colon heading T01 title');
+  assertEq(p.tasks[1].id, 'T02', 'colon heading T02 id');
+  assertEq(p.tasks[1].title, 'Add CI pipeline', 'colon heading T02 title');
+  assertEq(p.tasks[1].estimate, '30m', 'colon heading T02 estimate');
+}
+
+console.log('\n=== parsePlan: heading-style with em-dash separator (### T01 — Title) ===');
+{
+  const content = `# S13: Em-Dash Style
+
+**Goal:** Test em-dash separated heading tasks.
+**Demo:** Parser handles em-dash separator.
+
+## Tasks
+
+### T01 — Build the widget
+
+Widget description.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 1, 'em-dash heading task count');
+  assertEq(p.tasks[0].id, 'T01', 'em-dash heading T01 id');
+  assertEq(p.tasks[0].title, 'Build the widget', 'em-dash heading T01 title');
+}
+
+console.log('\n=== parsePlan: mixed checkbox and heading-style tasks ===');
+{
+  const content = `# S14: Mixed Format
+
+**Goal:** Test mixed formats.
+**Demo:** Parser handles both styles in one plan.
+
+## Tasks
+
+- [ ] **T01: Checkbox task** \`est:20m\`
+  A checkbox-style task.
+
+### T02 -- Heading task \`est:15m\`
+
+A heading-style task.
+
+- [x] **T03: Done checkbox task** \`est:10m\`
+  Already completed.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 3, 'mixed format task count');
+  assertEq(p.tasks[0].id, 'T01', 'mixed T01 id');
+  assertEq(p.tasks[0].done, false, 'mixed T01 not done');
+  assertEq(p.tasks[1].id, 'T02', 'mixed T02 id');
+  assertEq(p.tasks[1].title, 'Heading task', 'mixed T02 title');
+  assertEq(p.tasks[1].estimate, '15m', 'mixed T02 estimate');
+  assertEq(p.tasks[1].done, false, 'mixed T02 not done (heading style)');
+  assertEq(p.tasks[2].id, 'T03', 'mixed T03 id');
+  assertEq(p.tasks[2].done, true, 'mixed T03 done');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // parseSummary tests
 // ═══════════════════════════════════════════════════════════════════════════