lsd-pi 1.0.0 → 1.1.0

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

@@ -1,164 +0,0 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-// ensureDbOpen — Tests that the lazy DB opener creates + migrates the database
-// when .gsd/ exists with Markdown content but no gsd.db file.
-//
-// This covers the bug where interactive (non-auto) sessions got
-// "GSD database is not available" because ensureDbOpen only opened
-// existing DB files but never created them.
-
-import * as path from 'node:path';
-import * as os from 'node:os';
-import * as fs from 'node:fs';
-import { closeDatabase, isDbAvailable, getDecisionById } from '../gsd-db.ts';
-
-function makeTmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-ensure-db-'));
-  return dir;
-}
-
-function cleanupDir(dir: string): void {
-  try {
-    fs.rmSync(dir, { recursive: true, force: true });
-  } catch { /* swallow */ }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen creates DB + migrates when .gsd/ has Markdown
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('ensure-db-open', () => {
-  test('ensureDbOpen: creates DB from Markdown', async () => {
-    const tmpDir = makeTmpDir();
-    const gsdDir = path.join(tmpDir, '.gsd');
-    fs.mkdirSync(gsdDir, { recursive: true });
-
-    // Write a minimal DECISIONS.md so migration has content
-    const decisionsContent = `# Decisions
-
-  | # | When | Scope | Decision | Choice | Rationale | Revisable |
-  |---|------|-------|----------|--------|-----------|-----------|
-  | D001 | M001 | architecture | Use SQLite | SQLite | Sync API | Yes |
-  `;
-    fs.writeFileSync(path.join(gsdDir, 'DECISIONS.md'), decisionsContent);
-
-    // Verify no DB file exists yet
-    const dbPath = path.join(gsdDir, 'gsd.db');
-    assert.ok(!fs.existsSync(dbPath), 'DB file should not exist before ensureDbOpen');
-
-    // Close any previously open DB
-    try { closeDatabase(); } catch { /* ok */ }
-
-    // Override process.cwd to point at tmpDir for ensureDbOpen
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
-
-    try {
-      // Dynamic import to get the freshest version
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-
-      const result = await ensureDbOpen();
-
-      assert.ok(result === true, 'ensureDbOpen should return true when .gsd/ has Markdown');
-      assert.ok(fs.existsSync(dbPath), 'DB file should be created after ensureDbOpen');
-      assert.ok(isDbAvailable(), 'DB should be available after ensureDbOpen');
-
-      // Verify that Markdown migration actually ran
-      const decision = getDecisionById('D001');
-      assert.ok(decision !== null, 'D001 should be migrated from DECISIONS.md');
-      if (decision) {
-        assert.deepStrictEqual(decision.scope, 'architecture', 'Migrated decision scope should match');
-        assert.deepStrictEqual(decision.choice, 'SQLite', 'Migrated decision choice should match');
-      }
-    } finally {
-      process.cwd = origCwd;
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // ensureDbOpen returns false when no .gsd/ exists
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  test('ensureDbOpen: no .gsd/ returns false', async () => {
-    const tmpDir = makeTmpDir();
-    // No .gsd/ directory at all
-
-    try { closeDatabase(); } catch { /* ok */ }
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
-
-    try {
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-      const result = await ensureDbOpen();
-      assert.ok(result === false, 'ensureDbOpen should return false when no .gsd/ exists');
-      assert.ok(!isDbAvailable(), 'DB should not be available');
-    } finally {
-      process.cwd = origCwd;
-      cleanupDir(tmpDir);
-    }
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // ensureDbOpen opens existing DB without re-migration
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  test('ensureDbOpen: opens existing DB', async () => {
-    const tmpDir = makeTmpDir();
-    const gsdDir = path.join(tmpDir, '.gsd');
-    fs.mkdirSync(gsdDir, { recursive: true });
-
-    // Create a DB file first
-    const dbPath = path.join(gsdDir, 'gsd.db');
-    const { openDatabase } = await import('../gsd-db.ts');
-    openDatabase(dbPath);
-    closeDatabase();
-
-    assert.ok(fs.existsSync(dbPath), 'DB file should exist from manual create');
-
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
-
-    try {
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-      const result = await ensureDbOpen();
-      assert.ok(result === true, 'ensureDbOpen should open existing DB');
-      assert.ok(isDbAvailable(), 'DB should be available');
-    } finally {
-      process.cwd = origCwd;
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // ensureDbOpen returns false for empty .gsd/ (no Markdown, no DB)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  test('ensureDbOpen: empty .gsd/ creates empty DB (#2510)', async () => {
-    const tmpDir = makeTmpDir();
-    const gsdDir = path.join(tmpDir, '.gsd');
-    fs.mkdirSync(gsdDir, { recursive: true });
-    // .gsd/ exists but no DECISIONS.md, REQUIREMENTS.md, or milestones/
-
-    try { closeDatabase(); } catch { /* ok */ }
-    const origCwd = process.cwd;
-    process.cwd = () => tmpDir;
-
-    try {
-      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
-      const result = await ensureDbOpen();
-      assert.ok(result === true, 'ensureDbOpen should create empty DB for fresh .gsd/');
-      assert.ok(fs.existsSync(path.join(gsdDir, 'gsd.db')), 'DB file should be created');
-      assert.ok(isDbAvailable(), 'DB should be available');
-    } finally {
-      process.cwd = origCwd;
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-
-});

package/src/resources/extensions/gsd/tests/est-annotation-timeout.test.ts

@@ -1,120 +0,0 @@
-/**
- * est-annotation-timeout.test.ts — Regression tests for #2243.
- *
- * Tasks with `est: 30m` or `est: 2h` annotations should get extended
- * supervision timeouts. The parseEstimateMinutes helper should parse
- * estimate strings, and startUnitSupervision should use them.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const timersSrcPath = join(import.meta.dirname, "..", "auto-timers.ts");
-const timersSrc = readFileSync(timersSrcPath, "utf-8");
-
-// ─── Source analysis: parseEstimateMinutes exists and is exported ────────────
-
-test("#2243: auto-timers.ts should export parseEstimateMinutes", () => {
-  assert.ok(
-    timersSrc.includes("export function parseEstimateMinutes"),
-    "parseEstimateMinutes should be exported from auto-timers.ts",
-  );
-});
-
-// ─── Inline unit test of parseEstimateMinutes logic ─────────────────────────
-// Since importing the module pulls in heavy deps, test the parsing logic inline.
-
-function parseEstimateMinutes(estimate: string): number | null {
-  if (!estimate || typeof estimate !== "string") return null;
-  const trimmed = estimate.trim();
-  if (!trimmed) return null;
-
-  let totalMinutes = 0;
-  let matched = false;
-
-  const hoursMatch = trimmed.match(/(\d+)\s*h/i);
-  if (hoursMatch) {
-    totalMinutes += Number(hoursMatch[1]) * 60;
-    matched = true;
-  }
-
-  const minutesMatch = trimmed.match(/(\d+)\s*m/i);
-  if (minutesMatch) {
-    totalMinutes += Number(minutesMatch[1]);
-    matched = true;
-  }
-
-  return matched ? totalMinutes : null;
-}
-
-test("#2243: parseEstimateMinutes parses '30m' correctly", () => {
-  assert.equal(parseEstimateMinutes("30m"), 30);
-});
-
-test("#2243: parseEstimateMinutes parses '2h' correctly", () => {
-  assert.equal(parseEstimateMinutes("2h"), 120);
-});
-
-test("#2243: parseEstimateMinutes parses '1h30m' correctly", () => {
-  assert.equal(parseEstimateMinutes("1h30m"), 90);
-});
-
-test("#2243: parseEstimateMinutes parses '15m' correctly", () => {
-  assert.equal(parseEstimateMinutes("15m"), 15);
-});
-
-test("#2243: parseEstimateMinutes returns null for empty string", () => {
-  assert.equal(parseEstimateMinutes(""), null);
-});
-
-test("#2243: parseEstimateMinutes returns null for invalid string", () => {
-  assert.equal(parseEstimateMinutes("not a time"), null);
-});
-
-// ─── Source analysis: startUnitSupervision uses task estimates ───────────────
-
-test("#2243: startUnitSupervision should reference task estimates for timeout scaling", () => {
-  const usesEstimate =
-    timersSrc.includes("parseEstimateMinutes") &&
-    timersSrc.includes("estimateMinutes") &&
-    timersSrc.includes("taskEstimate");
-
-  assert.ok(
-    usesEstimate,
-    "startUnitSupervision should use task estimate annotations for timeout scaling",
-  );
-});
-
-test("#2243: SupervisionContext should accept an optional taskEstimate field", () => {
-  const ctxIdx = timersSrc.indexOf("SupervisionContext");
-  assert.ok(ctxIdx !== -1, "SupervisionContext interface exists");
-
-  const ctxEnd = timersSrc.indexOf("}", ctxIdx);
-  const ctxBlock = timersSrc.slice(ctxIdx, ctxEnd);
-
-  assert.ok(
-    ctxBlock.includes("taskEstimate"),
-    "SupervisionContext should include a taskEstimate field",
-  );
-});
-
-test("#2243: timeouts should be scaled by estimate (timeoutScale in source)", () => {
-  assert.ok(
-    timersSrc.includes("timeoutScale"),
-    "auto-timers.ts should use a timeoutScale factor derived from est: annotations",
-  );
-});
-
-test("#2243: idle timeout should NOT be scaled (idle is idle regardless of estimate)", () => {
-  // Find the idleTimeoutMs line
-  const idleIdx = timersSrc.indexOf("const idleTimeoutMs");
-  assert.ok(idleIdx !== -1, "idleTimeoutMs variable exists");
-  
-  const idleLine = timersSrc.slice(idleIdx, timersSrc.indexOf("\n", idleIdx));
-  assert.ok(
-    !idleLine.includes("timeoutScale"),
-    "idleTimeoutMs should NOT be scaled — idle is idle",
-  );
-});

package/src/resources/extensions/gsd/tests/event-replay-idempotency.test.ts

@@ -1,140 +0,0 @@
-// GSD State Machine Regression Tests — Event Replay & Reconciliation (#3161)
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  insertSlice,
-  insertTask,
-  getTask,
-  updateTaskStatus,
-  insertVerificationEvidence,
-  upsertDecision,
-} from "../gsd-db.ts";
-import { extractEntityKey } from "../workflow-reconcile.ts";
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-const MID = "M001";
-const SID = "S01";
-const TID = "T01";
-const TS = new Date().toISOString();
-
-function setupDb(): void {
-  openDatabase(":memory:");
-  insertMilestone({ id: MID, title: "Test Milestone" });
-  insertSlice({ id: SID, milestoneId: MID, title: "Test Slice" });
-  insertTask({ id: TID, sliceId: SID, milestoneId: MID, title: "Test Task" });
-}
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe("event-replay-idempotency", () => {
-  beforeEach(() => {
-    setupDb();
-  });
-
-  afterEach(() => {
-    closeDatabase();
-  });
-
-  test("updateTaskStatus is idempotent for complete_task replay", () => {
-    // Simulates replaying a complete_task event twice (e.g. crash recovery)
-    updateTaskStatus(MID, SID, TID, "done", TS);
-    updateTaskStatus(MID, SID, TID, "done", TS);
-
-    const task = getTask(MID, SID, TID);
-    assert.ok(task !== null, "task should exist after status update");
-    assert.equal(task!.status, "done", "status should be 'done' after double replay");
-  });
-
-  test("updateTaskStatus is idempotent for start_task replay", () => {
-    // Simulates replaying a start_task event twice
-    updateTaskStatus(MID, SID, TID, "in-progress");
-    updateTaskStatus(MID, SID, TID, "in-progress");
-
-    const task = getTask(MID, SID, TID);
-    assert.ok(task !== null, "task should exist after status update");
-    assert.equal(task!.status, "in-progress", "status should be 'in-progress' after double replay");
-  });
-
-  test("updateTaskStatus for report_blocker does not set blocker_discovered flag (M4)", () => {
-    // M4 finding: report_blocker replay only calls updateTaskStatus("blocked").
-    // The blocker_discovered column is NOT set during replay — this is a known
-    // lossy replay: status is recovered but the blocker flag is not.
-    updateTaskStatus(MID, SID, TID, "blocked");
-
-    const task = getTask(MID, SID, TID);
-    assert.ok(task !== null, "task should exist after blocked status update");
-    assert.equal(task!.status, "blocked", "status should be 'blocked'");
-    assert.equal(
-      task!.blocker_discovered,
-      false,
-      "blocker_discovered should remain false — report_blocker replay is lossy (M4 finding)",
-    );
-  });
-
-  test("insertVerificationEvidence is NOT idempotent — duplicates accumulate (M5)", () => {
-    // M5 finding: insertVerificationEvidence uses a plain INSERT (no ON CONFLICT),
-    // so replaying the same record_verification event twice produces two rows.
-    // Both calls must succeed without throwing — the duplication is the risk.
-    const evidence = {
-      taskId: TID,
-      sliceId: SID,
-      milestoneId: MID,
-      command: "npm test",
-      exitCode: 0,
-      verdict: "pass",
-      durationMs: 1200,
-    };
-
-    assert.doesNotThrow(
-      () => insertVerificationEvidence(evidence),
-      "first insertVerificationEvidence call should not throw",
-    );
-    assert.doesNotThrow(
-      () => insertVerificationEvidence(evidence),
-      "second insertVerificationEvidence call should not throw — duplicates accumulate silently (M5 finding)",
-    );
-  });
-
-  test("upsertDecision is idempotent via INSERT OR REPLACE", () => {
-    // save_decision replay uses upsertDecision which is INSERT OR REPLACE,
-    // so replaying the same decision id twice overwrites without error.
-    const base = {
-      id: "arch:logging",
-      when_context: "during planning",
-      scope: "arch",
-      decision: "logging",
-      rationale: "structured logs",
-      revisable: "yes" as const,
-      made_by: "agent" as const,
-      superseded_by: null,
-    };
-
-    upsertDecision({ ...base, choice: "structured" });
-    upsertDecision({ ...base, choice: "unstructured" });
-
-    // No error means the second call replaced the first — idempotent at the id level.
-    // The final choice is "unstructured" per INSERT OR REPLACE semantics.
-  });
-
-  test("unknown event commands in replayEvents are silently skipped — extractEntityKey returns null for unknown commands", () => {
-    // replayEvents uses a switch/default that silently skips unrecognised commands.
-    // We verify this via extractEntityKey which follows the same command set.
-    // A future_command not in the switch must return null (not throw).
-    const event = {
-      cmd: "future_command",
-      params: { foo: "bar" },
-      ts: new Date().toISOString(),
-      hash: "0000000000000000",
-      actor: "agent" as const,
-      session_id: "test-session",
-    };
-
-    const key = extractEntityKey(event);
-    assert.equal(key, null, "extractEntityKey should return null for unknown commands");
-  });
-});

package/src/resources/extensions/gsd/tests/exit-command.test.ts

@@ -1,101 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { registerExitCommand } from "../exit-command.ts";
-
-test("/exit requests graceful shutdown instead of process.exit", async (t) => {
-  const commands = new Map<
-    string,
-    {
-      description?: string;
-      handler: (args: string, ctx: { shutdown: () => Promise<void> }) => Promise<void>;
-    }
-  >();
-
-  const pi = {
-    registerCommand(name: string, options: any) {
-      commands.set(name, options);
-    },
-  };
-
-  let stopAutoCalls = 0;
-  registerExitCommand(pi as any, {
-    async stopAuto() {
-      stopAutoCalls += 1;
-    },
-  });
-
-  const exit = commands.get("exit");
-  assert.ok(exit, "registerExitCommand should register /exit");
-  assert.equal(exit.description, "Exit GSD gracefully");
-
-  let shutdownCalls = 0;
-  const originalExit = process.exit;
-  process.exit = ((code?: number) => {
-    throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
-  }) as typeof process.exit;
-
-  t.after(() => { process.exit = originalExit; });
-
-  await exit.handler("", {
-    async shutdown() {
-      shutdownCalls += 1;
-    },
-  });
-
-  assert.equal(stopAutoCalls, 1, "handler should stop auto-mode exactly once before shutdown");
-  assert.equal(shutdownCalls, 1, "handler should request graceful shutdown exactly once");
-});
-
-// ─── #1839 regression: ESM cache mismatch must not crash exit ────────────────
-
-test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async (t) => {
-  const commands = new Map<string, { description?: string; handler: (args: string, ctx: any) => Promise<void> }>();
-
-  const pi = {
-    registerCommand(name: string, options: any) {
-      commands.set(name, options);
-    },
-  };
-
-  // Simulate the ESM cache mismatch: stopAuto throws because a static import
-  // in the dependency chain references an export absent from the cached module.
-  registerExitCommand(pi as any, {
-    async stopAuto() {
-      throw new Error(
-        "The requested module './native-git-bridge.js' does not provide an export named 'nativeAddAllWithExclusions'",
-      );
-    },
-  });
-
-  const exit = commands.get("exit")!;
-
-  let shutdownCalls = 0;
-  const notifications: Array<{ msg: string; level: string }> = [];
-
-  const originalExit = process.exit;
-  process.exit = ((code?: number) => {
-    throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
-  }) as typeof process.exit;
-
-  t.after(() => { process.exit = originalExit; });
-
-  await exit.handler("", {
-    async shutdown() {
-      shutdownCalls += 1;
-    },
-    ui: {
-      notify(msg: string, level: string) {
-        notifications.push({ msg, level });
-      },
-    },
-  });
-
-  assert.equal(shutdownCalls, 1, "shutdown must still be called even when stopAuto throws");
-  assert.equal(notifications.length, 1, "should emit exactly one warning notification");
-  assert.equal(notifications[0].level, "warning", "notification level should be warning");
-  assert.ok(
-    notifications[0].msg.includes("module version mismatch"),
-    "notification should mention module version mismatch",
-  );
-});

package/src/resources/extensions/gsd/tests/export-html-all.test.ts

@@ -1,105 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-// Test: --all flag generates snapshots for milestones not yet in the index
-
-test("handleExport --html --all generates reports for milestones missing from the index", async () => {
-  // We test the export logic indirectly by verifying the flag parsing
-  // and the deduplication logic via loadReportsIndex + milestone filtering
-  const { loadReportsIndex } = await import("../reports.js");
-
-  const tmp = join(tmpdir(), `gsd-export-all-test-${Date.now()}`);
-  const gsdDir = join(tmp, ".gsd");
-  const reportsDir = join(gsdDir, "reports");
-  mkdirSync(reportsDir, { recursive: true });
-
-  // No existing reports — loadReportsIndex returns null
-  const noIndex = loadReportsIndex(tmp);
-  assert.equal(noIndex, null, "empty reports dir should return null index");
-
-  // Write a reports.json with M001 already present
-  const index = {
-    version: 1,
-    projectName: "test-project",
-    projectPath: tmp,
-    gsdVersion: "2.27.0",
-    entries: [
-      {
-        filename: "M001-2026-01-01T00-00-00.html",
-        generatedAt: "2026-01-01T00:00:00.000Z",
-        milestoneId: "M001",
-        milestoneTitle: "First Milestone",
-        label: "M001: First Milestone",
-        kind: "milestone",
-        totalCost: 0.5,
-        totalTokens: 10000,
-        totalDuration: 60000,
-        doneSlices: 3,
-        totalSlices: 3,
-        doneMilestones: 1,
-        totalMilestones: 3,
-        phase: "complete",
-      },
-    ],
-  };
-  writeFileSync(join(reportsDir, "reports.json"), JSON.stringify(index), "utf-8");
-
-  // Now loadReportsIndex should find M001
-  const loaded = loadReportsIndex(tmp);
-  assert.ok(loaded, "should load existing reports index");
-  assert.equal(loaded.entries.length, 1);
-  assert.equal(loaded.entries[0].milestoneId, "M001");
-
-  // Simulate the deduplication logic from handleExport --all
-  const existingIds = new Set(loaded.entries.map(e => e.milestoneId));
-  const allMilestones = [
-    { id: "M001", title: "First Milestone", status: "complete" },
-    { id: "M002", title: "Second Milestone", status: "complete" },
-    { id: "M003", title: "Third Milestone", status: "active" },
-  ];
-
-  const targets = allMilestones.filter(m => !existingIds.has(m.id));
-  assert.equal(targets.length, 2, "should skip M001 and target M002 + M003");
-  assert.equal(targets[0].id, "M002");
-  assert.equal(targets[1].id, "M003");
-
-  // Cleanup
-  rmSync(tmp, { recursive: true, force: true });
-});
-
-test("handleExport --html --all sets milestone kind based on status", async () => {
-  const completeMilestone = { id: "M001", status: "complete" };
-  const activeMilestone = { id: "M002", status: "active" };
-
-  // Logic from the implementation
-  const completeKind = completeMilestone.status === "complete" ? "milestone" : "manual";
-  const activeKind = activeMilestone.status === "complete" ? "milestone" : "manual";
-
-  assert.equal(completeKind, "milestone", "completed milestones get kind 'milestone'");
-  assert.equal(activeKind, "manual", "active milestones get kind 'manual'");
-});
-
-test("export completions include --html and --html --all", async () => {
-  const { registerGSDCommand } = await import("../commands.js");
-
-  const commands = new Map<string, any>();
-  const pi = {
-    registerCommand(name: string, options: any) { commands.set(name, options); },
-    registerTool() {},
-    registerShortcut() {},
-    on() {},
-    sendMessage() {},
-  };
-
-  registerGSDCommand(pi as any);
-  const gsd = commands.get("gsd");
-  assert.ok(gsd, "should register /gsd command");
-
-  const completions = gsd.getArgumentCompletions("export --");
-  const labels = completions.map((c: any) => c.label);
-  assert.ok(labels.includes("--html"), "completions should include --html");
-  assert.ok(labels.includes("--html --all"), "completions should include --html --all");
-});