gsd-pi 2.18.0 → 2.20.0

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

@@ -0,0 +1,353 @@
+import { createTestContext } from './test-helpers.ts';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  openDatabase,
+  closeDatabase,
+  isDbAvailable,
+  getDbProvider,
+  insertDecision,
+  getDecisionById,
+  insertRequirement,
+  getRequirementById,
+  getActiveDecisions,
+  getActiveRequirements,
+  transaction,
+  _getAdapter,
+  _resetProvider,
+} from '../gsd-db.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helper: create a temp file path for file-backed DB tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-db-test-'));
+  return path.join(dir, 'test.db');
+}
+
+function cleanup(dbPath: string): void {
+  closeDatabase();
+  try {
+    const dir = path.dirname(dbPath);
+    // Remove DB file and WAL/SHM files
+    for (const f of fs.readdirSync(dir)) {
+      fs.unlinkSync(path.join(dir, f));
+    }
+    fs.rmdirSync(dir);
+  } catch {
+    // best effort
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// gsd-db tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== gsd-db: provider detection ===');
+{
+  const provider = getDbProvider();
+  assertTrue(provider !== null, 'provider should be non-null');
+  assertTrue(
+    provider === 'node:sqlite' || provider === 'better-sqlite3',
+    `provider should be a known name, got: ${provider}`,
+  );
+}
+
+console.log('\n=== gsd-db: fresh DB schema init (memory) ===');
+{
+  const ok = openDatabase(':memory:');
+  assertTrue(ok, 'openDatabase should return true');
+  assertTrue(isDbAvailable(), 'isDbAvailable should be true after open');
+
+  // Check schema_version table
+  const adapter = _getAdapter()!;
+  const version = adapter.prepare('SELECT version FROM schema_version').get();
+  assertEq(version?.['version'], 2, 'schema version should be 2');
+
+  // Check tables exist by querying them
+  const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();
+  assertEq(dRows?.['cnt'], 0, 'decisions table should exist and be empty');
+
+  const rRows = adapter.prepare('SELECT count(*) as cnt FROM requirements').get();
+  assertEq(rRows?.['cnt'], 0, 'requirements table should exist and be empty');
+
+  closeDatabase();
+  assertTrue(!isDbAvailable(), 'isDbAvailable should be false after close');
+}
+
+console.log('\n=== gsd-db: double-init idempotency ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  // Insert a decision so we can verify it survives re-init
+  insertDecision({
+    id: 'D001',
+    when_context: 'test',
+    scope: 'global',
+    decision: 'test decision',
+    choice: 'option A',
+    rationale: 'because',
+    revisable: 'yes',
+    superseded_by: null,
+  });
+
+  closeDatabase();
+
+  // Re-open same DB — schema init should be idempotent
+  openDatabase(dbPath);
+  const d = getDecisionById('D001');
+  assertTrue(d !== null, 'decision should survive re-init');
+  assertEq(d?.id, 'D001', 'decision ID preserved after re-init');
+
+  // Schema version should still be 1 (not duplicated)
+  const adapter = _getAdapter()!;
+  const versions = adapter.prepare('SELECT count(*) as cnt FROM schema_version').get();
+  assertEq(versions?.['cnt'], 1, 'schema_version should have exactly 1 row after double-init');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== gsd-db: insert + get decision ===');
+{
+  openDatabase(':memory:');
+  insertDecision({
+    id: 'D042',
+    when_context: 'during sprint 3',
+    scope: 'M001/S02',
+    decision: 'use SQLite for storage',
+    choice: 'node:sqlite',
+    rationale: 'built-in, zero deps',
+    revisable: 'yes, if perf insufficient',
+    superseded_by: null,
+  });
+
+  const d = getDecisionById('D042');
+  assertTrue(d !== null, 'should find inserted decision');
+  assertEq(d?.id, 'D042', 'decision id');
+  assertEq(d?.scope, 'M001/S02', 'decision scope');
+  assertEq(d?.choice, 'node:sqlite', 'decision choice');
+  assertTrue(typeof d?.seq === 'number' && d.seq > 0, 'seq should be auto-assigned positive number');
+  assertEq(d?.superseded_by, null, 'superseded_by should be null');
+
+  // Non-existent
+  const missing = getDecisionById('D999');
+  assertEq(missing, null, 'non-existent decision returns null');
+
+  closeDatabase();
+}
+
+console.log('\n=== gsd-db: insert + get requirement ===');
+{
+  openDatabase(':memory:');
+  insertRequirement({
+    id: 'R007',
+    class: 'functional',
+    status: 'active',
+    description: 'System must persist decisions',
+    why: 'decisions inform future agents',
+    source: 'M001-CONTEXT',
+    primary_owner: 'S01',
+    supporting_slices: 'S02, S03',
+    validation: 'insert and query roundtrip',
+    notes: 'high priority',
+    full_content: 'Full text of requirement...',
+    superseded_by: null,
+  });
+
+  const r = getRequirementById('R007');
+  assertTrue(r !== null, 'should find inserted requirement');
+  assertEq(r?.id, 'R007', 'requirement id');
+  assertEq(r?.class, 'functional', 'requirement class');
+  assertEq(r?.status, 'active', 'requirement status');
+  assertEq(r?.primary_owner, 'S01', 'requirement primary_owner');
+  assertEq(r?.superseded_by, null, 'superseded_by should be null');
+
+  // Non-existent
+  const missing = getRequirementById('R999');
+  assertEq(missing, null, 'non-existent requirement returns null');
+
+  closeDatabase();
+}
+
+console.log('\n=== gsd-db: active_decisions view excludes superseded ===');
+{
+  openDatabase(':memory:');
+
+  insertDecision({
+    id: 'D001',
+    when_context: 'early',
+    scope: 'global',
+    decision: 'use JSON files',
+    choice: 'JSON',
+    rationale: 'simple',
+    revisable: 'yes',
+    superseded_by: 'D002',  // superseded!
+  });
+
+  insertDecision({
+    id: 'D002',
+    when_context: 'later',
+    scope: 'global',
+    decision: 'use SQLite',
+    choice: 'SQLite',
+    rationale: 'better querying',
+    revisable: 'yes',
+    superseded_by: null,  // active
+  });
+
+  insertDecision({
+    id: 'D003',
+    when_context: 'same time',
+    scope: 'local',
+    decision: 'use WAL mode',
+    choice: 'WAL',
+    rationale: 'concurrent reads',
+    revisable: 'no',
+    superseded_by: null,  // active
+  });
+
+  const active = getActiveDecisions();
+  assertEq(active.length, 2, 'active_decisions should return 2 (not the superseded one)');
+  const ids = active.map(d => d.id).sort();
+  assertEq(ids, ['D002', 'D003'], 'active decisions should be D002 and D003');
+
+  // Verify D001 is still in the raw table
+  const d1 = getDecisionById('D001');
+  assertTrue(d1 !== null, 'superseded decision still exists in raw table');
+  assertEq(d1?.superseded_by, 'D002', 'superseded_by is set');
+
+  closeDatabase();
+}
+
+console.log('\n=== gsd-db: active_requirements view excludes superseded ===');
+{
+  openDatabase(':memory:');
+
+  insertRequirement({
+    id: 'R001',
+    class: 'functional',
+    status: 'active',
+    description: 'old requirement',
+    why: 'was needed',
+    source: 'M001',
+    primary_owner: 'S01',
+    supporting_slices: '',
+    validation: 'test',
+    notes: '',
+    full_content: '',
+    superseded_by: 'R002',  // superseded!
+  });
+
+  insertRequirement({
+    id: 'R002',
+    class: 'functional',
+    status: 'active',
+    description: 'new requirement',
+    why: 'replaces R001',
+    source: 'M001',
+    primary_owner: 'S01',
+    supporting_slices: '',
+    validation: 'test',
+    notes: '',
+    full_content: '',
+    superseded_by: null,  // active
+  });
+
+  const active = getActiveRequirements();
+  assertEq(active.length, 1, 'active_requirements should return 1');
+  assertEq(active[0]?.id, 'R002', 'only R002 should be active');
+
+  // R001 still in raw table
+  const r1 = getRequirementById('R001');
+  assertTrue(r1 !== null, 'superseded requirement still in raw table');
+
+  closeDatabase();
+}
+
+console.log('\n=== gsd-db: WAL mode on file-backed DB ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const adapter = _getAdapter()!;
+  const mode = adapter.prepare('PRAGMA journal_mode').get();
+  assertEq(mode?.['journal_mode'], 'wal', 'journal_mode should be wal for file-backed DB');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== gsd-db: transaction rollback on error ===');
+{
+  openDatabase(':memory:');
+
+  // Insert a decision normally
+  insertDecision({
+    id: 'D010',
+    when_context: 'test',
+    scope: 'test',
+    decision: 'test',
+    choice: 'test',
+    rationale: 'test',
+    revisable: 'test',
+    superseded_by: null,
+  });
+
+  // Try a transaction that fails — the insert inside should be rolled back
+  let threw = false;
+  try {
+    transaction(() => {
+      insertDecision({
+        id: 'D011',
+        when_context: 'should be rolled back',
+        scope: 'test',
+        decision: 'test',
+        choice: 'test',
+        rationale: 'test',
+        revisable: 'test',
+        superseded_by: null,
+      });
+      throw new Error('intentional failure');
+    });
+  } catch (err) {
+    if ((err as Error).message === 'intentional failure') {
+      threw = true;
+    }
+  }
+
+  assertTrue(threw, 'transaction should re-throw the error');
+  const d11 = getDecisionById('D011');
+  assertEq(d11, null, 'D011 should be rolled back (not found)');
+
+  // D010 should still be there
+  const d10 = getDecisionById('D010');
+  assertTrue(d10 !== null, 'D010 should survive the failed transaction');
+
+  closeDatabase();
+}
+
+console.log('\n=== gsd-db: query wrappers return null/empty when DB unavailable ===');
+{
+  // Ensure DB is closed
+  closeDatabase();
+  assertTrue(!isDbAvailable(), 'DB should not be available');
+
+  const d = getDecisionById('D001');
+  assertEq(d, null, 'getDecisionById returns null when DB closed');
+
+  const r = getRequirementById('R001');
+  assertEq(r, null, 'getRequirementById returns null when DB closed');
+
+  const ad = getActiveDecisions();
+  assertEq(ad, [], 'getActiveDecisions returns [] when DB closed');
+
+  const ar = getActiveRequirements();
+  assertEq(ar, [], 'getActiveRequirements returns [] when DB closed');
+}
+
+// ─── Final Report ──────────────────────────────────────────────────────────
+report();

package/src/resources/extensions/gsd/tests/gsd-inspect.test.ts

@@ -0,0 +1,125 @@
+// gsd-inspect — Tests for /gsd inspect output formatting
+//
+// Tests the pure formatInspectOutput function with known data.
+
+import { createTestContext } from './test-helpers.ts';
+import { formatInspectOutput, type InspectData } from '../commands.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ── formats output with schema version, counts, and recent entries ──
+console.log("# === gsd-inspect: full output formatting ===");
+{
+  const data: InspectData = {
+    schemaVersion: 2,
+    counts: { decisions: 12, requirements: 8, artifacts: 3 },
+    recentDecisions: [
+      { id: "D012", decision: "Use SQLite for persistence", choice: "node:sqlite with fallback" },
+      { id: "D011", decision: "Markdown dual-write", choice: "DB-first then regenerate" },
+    ],
+    recentRequirements: [
+      { id: "R015", status: "active", description: "Commands register via pi.registerCommand" },
+      { id: "R014", status: "active", description: "DB writes use upsert pattern" },
+    ],
+  };
+
+  const output = formatInspectOutput(data);
+
+  assertMatch(output, /=== GSD Database Inspect ===/, "contains header");
+  assertMatch(output, /Schema version: 2/, "contains schema version");
+  assertMatch(output, /Decisions:\s+12/, "contains decisions count");
+  assertMatch(output, /Requirements:\s+8/, "contains requirements count");
+  assertMatch(output, /Artifacts:\s+3/, "contains artifacts count");
+  assertMatch(output, /Recent decisions:/, "contains recent decisions header");
+  assertMatch(output, /D012: Use SQLite for persistence → node:sqlite with fallback/, "contains D012 entry");
+  assertMatch(output, /D011: Markdown dual-write → DB-first then regenerate/, "contains D011 entry");
+  assertMatch(output, /Recent requirements:/, "contains recent requirements header");
+  assertMatch(output, /R015 \[active\]: Commands register via pi\.registerCommand/, "contains R015 entry");
+  assertMatch(output, /R014 \[active\]: DB writes use upsert pattern/, "contains R014 entry");
+}
+
+// ── handles zero counts and no recent entries ──
+console.log("# === gsd-inspect: empty data ===");
+{
+  const data: InspectData = {
+    schemaVersion: 1,
+    counts: { decisions: 0, requirements: 0, artifacts: 0 },
+    recentDecisions: [],
+    recentRequirements: [],
+  };
+
+  const output = formatInspectOutput(data);
+
+  assertMatch(output, /Schema version: 1/, "contains schema version 1");
+  assertMatch(output, /Decisions:\s+0/, "zero decisions");
+  assertMatch(output, /Requirements:\s+0/, "zero requirements");
+  assertMatch(output, /Artifacts:\s+0/, "zero artifacts");
+  assertTrue(!output.includes("Recent decisions:"), "no recent decisions section when empty");
+  assertTrue(!output.includes("Recent requirements:"), "no recent requirements section when empty");
+}
+
+// ── handles null schema version ──
+console.log("# === gsd-inspect: null schema version ===");
+{
+  const data: InspectData = {
+    schemaVersion: null,
+    counts: { decisions: 0, requirements: 0, artifacts: 0 },
+    recentDecisions: [],
+    recentRequirements: [],
+  };
+
+  const output = formatInspectOutput(data);
+  assertMatch(output, /Schema version: unknown/, "null version shows as unknown");
+}
+
+// ── formats up to 5 recent entries ──
+console.log("# === gsd-inspect: five recent entries ===");
+{
+  const data: InspectData = {
+    schemaVersion: 2,
+    counts: { decisions: 5, requirements: 5, artifacts: 0 },
+    recentDecisions: [
+      { id: "D005", decision: "Dec 5", choice: "C5" },
+      { id: "D004", decision: "Dec 4", choice: "C4" },
+      { id: "D003", decision: "Dec 3", choice: "C3" },
+      { id: "D002", decision: "Dec 2", choice: "C2" },
+      { id: "D001", decision: "Dec 1", choice: "C1" },
+    ],
+    recentRequirements: [
+      { id: "R005", status: "active", description: "Req 5" },
+      { id: "R004", status: "done", description: "Req 4" },
+      { id: "R003", status: "active", description: "Req 3" },
+      { id: "R002", status: "active", description: "Req 2" },
+      { id: "R001", status: "done", description: "Req 1" },
+    ],
+  };
+
+  const output = formatInspectOutput(data);
+
+  for (let i = 1; i <= 5; i++) {
+    assertMatch(output, new RegExp(`D00${i}: Dec ${i} → C${i}`), `contains D00${i}`);
+  }
+  for (let i = 1; i <= 5; i++) {
+    assertMatch(output, new RegExp(`R00${i}`), `contains R00${i}`);
+  }
+  assertMatch(output, /\[active\]/, "contains active status");
+  assertMatch(output, /\[done\]/, "contains done status");
+}
+
+// ── output is multiline text (not JSON) ──
+console.log("# === gsd-inspect: output format ===");
+{
+  const data: InspectData = {
+    schemaVersion: 2,
+    counts: { decisions: 1, requirements: 1, artifacts: 0 },
+    recentDecisions: [{ id: "D001", decision: "Test", choice: "Yes" }],
+    recentRequirements: [{ id: "R001", status: "active", description: "Test req" }],
+  };
+
+  const output = formatInspectOutput(data);
+  const lines = output.split("\n");
+  assertTrue(lines.length > 5, "output has multiple lines");
+  assertTrue(!output.startsWith("{"), "output is not JSON");
+}
+
+report();