gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/workflow-logger.test.ts

@@ -0,0 +1,275 @@
+// GSD Extension — Workflow Logger Tests
+// Tests for the centralized warning/error accumulator.
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  logWarning,
+  logError,
+  drainLogs,
+  drainAndSummarize,
+  peekLogs,
+  hasErrors,
+  hasWarnings,
+  hasAnyIssues,
+  summarizeLogs,
+  formatForNotification,
+  _resetLogs,
+} from "../workflow-logger.ts";
+
+const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+describe("workflow-logger", () => {
+  beforeEach(() => {
+    _resetLogs();
+  });
+
+  describe("accumulation", () => {
+    test("logWarning adds an entry with severity warn", () => {
+      logWarning("engine", "test warning");
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "warn");
+      assert.equal(entries[0].component, "engine");
+      assert.equal(entries[0].message, "test warning");
+      assert.match(entries[0].ts, ISO_RE);
+    });
+
+    test("logError adds an entry with severity error", () => {
+      logError("intercept", "blocked write", { path: "/foo/STATE.md" });
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "error");
+      assert.equal(entries[0].component, "intercept");
+      assert.deepEqual(entries[0].context, { path: "/foo/STATE.md" });
+    });
+
+    test("accumulates multiple entries in order", () => {
+      logWarning("projection", "render failed");
+      logError("intercept", "blocked write");
+      logWarning("manifest", "write failed");
+      assert.equal(peekLogs().length, 3);
+      assert.equal(peekLogs()[0].component, "projection");
+      assert.equal(peekLogs()[1].component, "intercept");
+      assert.equal(peekLogs()[2].component, "manifest");
+    });
+
+    test("omits context field when not provided", () => {
+      logWarning("engine", "no context");
+      assert.equal("context" in peekLogs()[0], false);
+    });
+
+    test("omits context field when undefined is passed", () => {
+      logWarning("engine", "no context", undefined);
+      assert.equal("context" in peekLogs()[0], false);
+    });
+
+    test("context with special characters is stored as-is", () => {
+      logError("tool", "failed", { path: '/foo/"quoted".md', msg: "line1\nline2" });
+      assert.deepEqual(peekLogs()[0].context, {
+        path: '/foo/"quoted".md',
+        msg: "line1\nline2",
+      });
+    });
+
+    test("ts field is a valid ISO 8601 timestamp", () => {
+      logWarning("engine", "ts check");
+      assert.match(peekLogs()[0].ts, ISO_RE);
+    });
+  });
+
+  describe("drain", () => {
+    test("returns all entries and clears buffer", () => {
+      logWarning("engine", "w1");
+      logError("engine", "e1");
+      const drained = drainLogs();
+      assert.equal(drained.length, 2);
+      assert.equal(peekLogs().length, 0);
+    });
+
+    test("returns empty array when no entries", () => {
+      assert.deepEqual(drainLogs(), []);
+    });
+
+    test("second drain returns empty array", () => {
+      logWarning("engine", "w1");
+      drainLogs();
+      assert.deepEqual(drainLogs(), []);
+    });
+  });
+
+  describe("drainAndSummarize", () => {
+    test("returns summary and clears buffer atomically", () => {
+      logError("intercept", "blocked");
+      logWarning("projection", "render failed");
+      const { logs, summary } = drainAndSummarize();
+      assert.equal(logs.length, 2);
+      assert.equal(peekLogs().length, 0);
+      assert.ok(summary?.includes("1 error(s)"));
+      assert.ok(summary?.includes("1 warning(s)"));
+    });
+
+    test("returns null summary when buffer is empty", () => {
+      const { logs, summary } = drainAndSummarize();
+      assert.deepEqual(logs, []);
+      assert.equal(summary, null);
+    });
+  });
+
+  describe("hasErrors / hasWarnings / hasAnyIssues", () => {
+    test("hasErrors returns false when only warnings", () => {
+      logWarning("engine", "just a warning");
+      assert.equal(hasErrors(), false);
+      assert.equal(hasWarnings(), true);
+    });
+
+    test("hasErrors returns true when errors present", () => {
+      logWarning("engine", "warning");
+      logError("intercept", "error");
+      assert.equal(hasErrors(), true);
+    });
+
+    test("hasWarnings returns false when buffer empty", () => {
+      assert.equal(hasWarnings(), false);
+    });
+
+    test("hasWarnings returns false when buffer contains only errors", () => {
+      logError("intercept", "only an error");
+      assert.equal(hasWarnings(), false);
+      assert.equal(hasErrors(), true);
+    });
+
+    test("hasAnyIssues returns true for warnings only", () => {
+      logWarning("engine", "warn");
+      assert.equal(hasAnyIssues(), true);
+    });
+
+    test("hasAnyIssues returns true for errors only", () => {
+      logError("engine", "err");
+      assert.equal(hasAnyIssues(), true);
+    });
+
+    test("hasAnyIssues returns false when buffer empty", () => {
+      assert.equal(hasAnyIssues(), false);
+    });
+  });
+
+  describe("summarizeLogs", () => {
+    test("returns null when empty", () => {
+      assert.equal(summarizeLogs(), null);
+    });
+
+    test("summarizes errors and warnings separately", () => {
+      logError("intercept", "blocked STATE.md");
+      logWarning("projection", "render failed");
+      logWarning("manifest", "write failed");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("1 error(s)"));
+      assert.ok(summary.includes("blocked STATE.md"));
+      assert.ok(summary.includes("2 warning(s)"));
+    });
+
+    test("only shows errors section when no warnings", () => {
+      logError("intercept", "blocked");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("1 error(s)"));
+      assert.ok(!summary.includes("warning"));
+    });
+
+    test("only shows warnings section when no errors", () => {
+      logWarning("projection", "render degraded");
+      logWarning("manifest", "write slow");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("2 warning(s)"));
+      assert.ok(!summary.includes("error"));
+    });
+
+    test("does not clear buffer", () => {
+      logError("intercept", "blocked");
+      summarizeLogs();
+      assert.equal(peekLogs().length, 1);
+    });
+  });
+
+  describe("formatForNotification", () => {
+    test("returns empty string for empty array", () => {
+      assert.equal(formatForNotification([]), "");
+    });
+
+    test("formats single entry without line breaks", () => {
+      logError("intercept", "blocked write");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.equal(formatted, "[intercept] blocked write");
+    });
+
+    test("formats multiple entries with line breaks", () => {
+      logWarning("projection", "render failed");
+      logError("intercept", "blocked write");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.ok(formatted.includes("[projection] render failed"));
+      assert.ok(formatted.includes("[intercept] blocked write"));
+      assert.ok(formatted.includes("\n"));
+    });
+
+    test("does not include context in formatted output", () => {
+      logError("tool", "failed", { cmd: "complete_task" });
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.equal(formatted, "[tool] failed");
+      assert.ok(!formatted.includes("complete_task"));
+    });
+  });
+
+  describe("buffer limit", () => {
+    test("caps at MAX_BUFFER entries, dropping oldest", () => {
+      const OVER = 110;
+      const MAX = 100;
+      for (let i = 0; i < OVER; i++) {
+        logWarning("engine", `msg-${i}`);
+      }
+      const entries = peekLogs();
+      assert.equal(entries.length, MAX);
+      // First MAX entries dropped; oldest surviving = msg-(OVER-MAX)
+      assert.equal(entries[0].message, `msg-${OVER - MAX}`);
+      assert.equal(entries[MAX - 1].message, `msg-${OVER - 1}`);
+    });
+  });
+
+  describe("stderr output", () => {
+    test("writes WARN prefix to stderr for warnings", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logWarning("engine", "test warn");
+      assert.equal(written.length, 1);
+      assert.ok(written[0].includes("[gsd:engine] WARN: test warn"));
+    });
+
+    test("writes ERROR prefix to stderr for errors", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logError("intercept", "blocked");
+      assert.ok(written[0].includes("[gsd:intercept] ERROR: blocked"));
+    });
+
+    test("includes serialized context in stderr output", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logError("tool", "failed", { cmd: "complete_task" });
+      assert.ok(written[0].includes('"cmd":"complete_task"'));
+    });
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-manifest.test.ts

@@ -0,0 +1,186 @@
+// GSD Extension — workflow-manifest unit tests
+// Tests writeManifest, readManifest, snapshotState, bootstrapFromManifest.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from '../gsd-db.ts';
+import {
+  writeManifest,
+  readManifest,
+  snapshotState,
+  bootstrapFromManifest,
+} from '../workflow-manifest.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-manifest-'));
+}
+
+function tempDbPath(base: string): string {
+  return path.join(base, 'test.db');
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+// ─── readManifest: no file ────────────────────────────────────────────────
+
+test('workflow-manifest: readManifest returns null when file does not exist', () => {
+  const base = tempDir();
+  try {
+    const result = readManifest(base);
+    assert.strictEqual(result, null);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── writeManifest + readManifest round-trip ─────────────────────────────
+
+test('workflow-manifest: writeManifest creates state-manifest.json with version 1', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    writeManifest(base);
+    const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist');
+    const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    assert.strictEqual(raw.version, 1);
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: readManifest parses manifest written by writeManifest', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    writeManifest(base);
+    const manifest = readManifest(base);
+    assert.ok(manifest !== null);
+    assert.strictEqual(manifest!.version, 1);
+    assert.ok(typeof manifest!.exported_at === 'string');
+    assert.ok(Array.isArray(manifest!.milestones));
+    assert.ok(Array.isArray(manifest!.slices));
+    assert.ok(Array.isArray(manifest!.tasks));
+    assert.ok(Array.isArray(manifest!.decisions));
+    assert.ok(Array.isArray(manifest!.verification_evidence));
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── snapshotState: captures DB rows ─────────────────────────────────────
+
+test('workflow-manifest: snapshotState includes inserted milestone', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'Auth Milestone' });
+    const snap = snapshotState();
+    assert.strictEqual(snap.version, 1);
+    const m = snap.milestones.find((r) => r.id === 'M001');
+    assert.ok(m !== undefined, 'M001 should appear in snapshot');
+    assert.strictEqual(m!.title, 'Auth Milestone');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: snapshotState captures tasks', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Do thing', status: 'complete' });
+    const snap = snapshotState();
+    const t = snap.tasks.find((r) => r.id === 'T01');
+    assert.ok(t !== undefined, 'T01 should appear in snapshot');
+    assert.strictEqual(t!.status, 'complete');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── bootstrapFromManifest ────────────────────────────────────────────────
+
+test('workflow-manifest: bootstrapFromManifest returns false when no manifest file', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    const result = bootstrapFromManifest(base);
+    assert.strictEqual(result, false);
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    // Insert data and write manifest
+    insertMilestone({ id: 'M001', title: 'Restored Milestone' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Restored Slice' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Restored Task', status: 'complete' });
+    writeManifest(base);
+    closeDatabase();
+
+    // Open a fresh DB and bootstrap from manifest
+    const newDbPath = path.join(base, 'new.db');
+    openDatabase(newDbPath);
+    const result = bootstrapFromManifest(base);
+    assert.strictEqual(result, true, 'bootstrapFromManifest should return true');
+
+    // Verify restored state
+    const snap = snapshotState();
+    const m = snap.milestones.find((r) => r.id === 'M001');
+    assert.ok(m !== undefined, 'M001 should be restored');
+    assert.strictEqual(m!.title, 'Restored Milestone');
+
+    const s = snap.slices.find((r) => r.id === 'S01');
+    assert.ok(s !== undefined, 'S01 should be restored');
+
+    const t = snap.tasks.find((r) => r.id === 'T01');
+    assert.ok(t !== undefined, 'T01 should be restored');
+    assert.strictEqual(t!.status, 'complete');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── readManifest: version check ─────────────────────────────────────────
+
+test('workflow-manifest: readManifest throws on unsupported version', () => {
+  const base = tempDir();
+  try {
+    fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+    fs.writeFileSync(
+      path.join(base, '.gsd', 'state-manifest.json'),
+      JSON.stringify({ version: 99, exported_at: '', milestones: [], slices: [], tasks: [], decisions: [], verification_evidence: [] }),
+    );
+    assert.throws(
+      () => readManifest(base),
+      /Unsupported manifest version/,
+      'should throw on version mismatch',
+    );
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/workflow-projections.test.ts

@@ -0,0 +1,171 @@
+// GSD Extension — workflow-projections unit tests
+// Tests the pure rendering functions (no DB required).
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { renderPlanContent } from '../workflow-projections.ts';
+import type { SliceRow, TaskRow } from '../gsd-db.ts';
+
+// ─── Test fixtures ────────────────────────────────────────────────────────
+
+function makeSlice(overrides: Partial<SliceRow> = {}): SliceRow {
+  return {
+    id: 'S01',
+    milestone_id: 'M001',
+    title: 'Auth Layer',
+    status: 'active',
+    risk: 'high',
+    depends: [],
+    demo: 'Login flow works end-to-end',
+    goal: 'Implement JWT authentication',
+    full_summary_md: '',
+    full_uat_md: '',
+    success_criteria: '',
+    proof_level: '',
+    integration_closure: '',
+    observability_impact: '',
+    created_at: '2026-01-01T00:00:00Z',
+    completed_at: null,
+    sequence: 1,
+    replan_triggered_at: null,
+    ...overrides,
+  };
+}
+
+function makeTask(overrides: Partial<TaskRow> = {}): TaskRow {
+  return {
+    id: 'T01',
+    slice_id: 'S01',
+    milestone_id: 'M001',
+    title: 'Create JWT middleware',
+    status: 'pending',
+    description: 'Implement JWT validation middleware',
+    estimate: '2h',
+    files: ['src/middleware/auth.ts'],
+    verify: 'npm test src/middleware/auth.test.ts',
+    one_liner: '',
+    narrative: '',
+    verification_result: '',
+    duration: '',
+    completed_at: null,
+    blocker_discovered: false,
+    deviations: '',
+    known_issues: '',
+    key_files: [],
+    key_decisions: [],
+    full_summary_md: '',
+    full_plan_md: '',
+    inputs: [],
+    expected_output: [],
+    observability_impact: '',
+    sequence: 1,
+    ...overrides,
+  };
+}
+
+// ─── renderPlanContent: structure ────────────────────────────────────────
+
+test('workflow-projections: renderPlanContent starts with H1 containing slice id and title', () => {
+  const content = renderPlanContent(makeSlice(), []);
+  assert.ok(content.startsWith('# S01: Auth Layer'), `expected H1, got: ${content.slice(0, 60)}`);
+});
+
+test('workflow-projections: renderPlanContent includes Goal line', () => {
+  const content = renderPlanContent(makeSlice(), []);
+  assert.ok(content.includes('**Goal:** Implement JWT authentication'));
+});
+
+test('workflow-projections: renderPlanContent includes Demo line', () => {
+  const content = renderPlanContent(makeSlice(), []);
+  assert.ok(content.includes('**Demo:** After this: Login flow works end-to-end'));
+});
+
+test('workflow-projections: renderPlanContent falls back to TBD when goal and full_summary_md are empty', () => {
+  const slice = makeSlice({ goal: '', full_summary_md: '' });
+  const content = renderPlanContent(slice, []);
+  assert.ok(content.includes('**Goal:** TBD'));
+});
+
+test('workflow-projections: renderPlanContent falls back to full_summary_md when goal is empty', () => {
+  const slice = makeSlice({ goal: '', full_summary_md: 'Fallback goal text' });
+  const content = renderPlanContent(slice, []);
+  assert.ok(content.includes('**Goal:** Fallback goal text'));
+});
+
+test('workflow-projections: renderPlanContent includes ## Tasks section', () => {
+  const content = renderPlanContent(makeSlice(), []);
+  assert.ok(content.includes('## Tasks'));
+});
+
+// ─── renderPlanContent: task checkboxes ──────────────────────────────────
+
+test('workflow-projections: pending task renders with [ ] checkbox', () => {
+  const task = makeTask({ status: 'pending' });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(content.includes('- [ ] **T01:'), `expected unchecked, got: ${content}`);
+});
+
+test('workflow-projections: done task renders with [x] checkbox', () => {
+  const task = makeTask({ status: 'done' });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(content.includes('- [x] **T01:'), `expected checked, got: ${content}`);
+});
+
+test('workflow-projections: complete status renders with [x] checkbox', () => {
+  const task = makeTask({ status: 'complete' }); // 'complete' and 'done' both → checked
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(content.includes('- [x] **T01:'));
+});
+
+// ─── renderPlanContent: task sublines ────────────────────────────────────
+
+test('workflow-projections: task with estimate renders Estimate subline', () => {
+  const task = makeTask({ estimate: '2h' });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(content.includes('  - Estimate: 2h'));
+});
+
+test('workflow-projections: task with empty estimate omits Estimate subline', () => {
+  const task = makeTask({ estimate: '' });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(!content.includes('  - Estimate:'));
+});
+
+test('workflow-projections: task with files renders Files subline', () => {
+  const task = makeTask({ files: ['src/auth.ts', 'src/auth.test.ts'] });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(content.includes('  - Files: src/auth.ts, src/auth.test.ts'));
+});
+
+test('workflow-projections: task with empty files array omits Files subline', () => {
+  const task = makeTask({ files: [] });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(!content.includes('  - Files:'));
+});
+
+test('workflow-projections: task with verify renders Verify subline', () => {
+  const task = makeTask({ verify: 'npm test' });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(content.includes('  - Verify: npm test'));
+});
+
+test('workflow-projections: task with no verify omits Verify subline', () => {
+  const task = makeTask({ verify: '' });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(!content.includes('  - Verify:'));
+});
+
+test('workflow-projections: task with duration renders Duration subline', () => {
+  const task = makeTask({ duration: '45m' });
+  const content = renderPlanContent(makeSlice(), [task]);
+  assert.ok(content.includes('  - Duration: 45m'));
+});
+
+test('workflow-projections: multiple tasks rendered in order', () => {
+  const t1 = makeTask({ id: 'T01', title: 'First task', sequence: 1 });
+  const t2 = makeTask({ id: 'T02', title: 'Second task', sequence: 2 });
+  const content = renderPlanContent(makeSlice(), [t1, t2]);
+  const idxT1 = content.indexOf('**T01:');
+  const idxT2 = content.indexOf('**T02:');
+  assert.ok(idxT1 < idxT2, 'T01 should appear before T02');
+});