gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.bf822e6

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

@@ -1,353 +0,0 @@
-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 MAX(version) as version FROM schema_version').get();
-  assertEq(version?.['version'], 3, 'schema version should be 3');
-
-  // 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/dist/resources/extensions/gsd/tests/gsd-inspect.test.ts

@@ -1,125 +0,0 @@
-// 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-inspect.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();