gsd-pi 2.19.0 → 2.20.0

package/dist/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -6,6 +6,9 @@ import {
   renderDepsView,
   renderMetricsView,
   renderTimelineView,
+  renderAgentView,
+  renderChangelogView,
+  renderExportView,
 } from "../visualizer-views.js";
 import type { VisualizerData } from "../visualizer-data.js";
 import { createTestContext } from "./test-helpers.ts";
@@ -30,6 +33,15 @@ function makeVisualizerData(overrides: Partial<VisualizerData> = {}): Visualizer
     bySlice: [],
     byModel: [],
     units: [],
+    criticalPath: {
+      milestonePath: [],
+      slicePath: [],
+      milestoneSlack: new Map(),
+      sliceSlack: new Map(),
+    },
+    remainingSliceCount: 0,
+    agentActivity: null,
+    changelog: { entries: [] },
     ...overrides,
   };
 }
@@ -104,6 +116,73 @@ console.log("\n=== renderProgressView ===");
   assertEq(lines.length, 0, "empty milestones produce no lines");
 }
 
+// ─── Risk Heatmap ───────────────────────────────────────────────────────────
+
+console.log("\n=== Risk Heatmap ===");
+
+{
+  const data = makeVisualizerData({
+    milestones: [
+      {
+        id: "M001",
+        title: "First",
+        status: "active",
+        dependsOn: [],
+        slices: [
+          { id: "S01", title: "A", done: true, active: false, risk: "low", depends: [], tasks: [] },
+          { id: "S02", title: "B", done: false, active: true, risk: "high", depends: [], tasks: [] },
+          { id: "S03", title: "C", done: false, active: false, risk: "medium", depends: [], tasks: [] },
+          { id: "S04", title: "D", done: false, active: false, risk: "high", depends: [], tasks: [] },
+        ],
+      },
+    ],
+  });
+
+  const lines = renderProgressView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("Risk Heatmap")), "heatmap header present");
+  assertTrue(lines.some(l => l.includes("██")), "heatmap has colored blocks");
+  assertTrue(lines.some(l => l.includes("low") && l.includes("med") && l.includes("high")), "heatmap legend present");
+  assertTrue(lines.some(l => l.includes("1 low, 1 med, 2 high")), "risk summary counts");
+  assertTrue(lines.some(l => l.includes("1 high-risk not started")), "high-risk not started warning");
+}
+
+// ─── Search/Filter ──────────────────────────────────────────────────────────
+
+console.log("\n=== Search/Filter ===");
+
+{
+  const data = makeVisualizerData({
+    milestones: [
+      {
+        id: "M001",
+        title: "Auth",
+        status: "active",
+        dependsOn: [],
+        slices: [
+          { id: "S01", title: "JWT", done: false, active: false, risk: "low", depends: [], tasks: [] },
+          { id: "S02", title: "OAuth", done: false, active: false, risk: "high", depends: [], tasks: [] },
+        ],
+      },
+      {
+        id: "M002",
+        title: "Dashboard",
+        status: "pending",
+        dependsOn: ["M001"],
+        slices: [],
+      },
+    ],
+  });
+
+  // Filter by keyword "auth"
+  const filtered = renderProgressView(data, mockTheme, 80, { text: "auth", field: "all" });
+  assertTrue(filtered.some(l => l.includes("M001")), "filter shows matching milestone");
+  assertTrue(filtered.some(l => l.includes("Filter (all): auth")), "filter indicator present");
+
+  // Filter by risk "high"
+  const riskFiltered = renderProgressView(data, mockTheme, 80, { text: "high", field: "risk" });
+  assertTrue(riskFiltered.some(l => l.includes("M001")), "risk filter shows milestone with high-risk slice");
+}
+
 // ─── renderDepsView ─────────────────────────────────────────────────────────
 
 console.log("\n=== renderDepsView ===");
@@ -129,12 +208,20 @@ console.log("\n=== renderDepsView ===");
         slices: [],
       },
     ],
+    criticalPath: {
+      milestonePath: ["M001", "M002"],
+      slicePath: ["S01", "S02"],
+      milestoneSlack: new Map([["M001", 0], ["M002", 0]]),
+      sliceSlack: new Map([["S01", 0], ["S02", 0]]),
+    },
   });
 
   const lines = renderDepsView(data, mockTheme, 80);
   assertTrue(lines.length > 0, "deps view produces output");
   assertTrue(lines.some(l => l.includes("M001") && l.includes("M002")), "shows milestone dep edge");
   assertTrue(lines.some(l => l.includes("S01") && l.includes("S02")), "shows slice dep edge");
+  assertTrue(lines.some(l => l.includes("Critical Path")), "shows critical path section");
+  assertTrue(lines.some(l => l.includes("[CRITICAL]")), "shows CRITICAL badge");
 }
 
 {
@@ -162,6 +249,8 @@ console.log("\n=== renderMetricsView ===");
       toolCalls: 15,
       assistantMessages: 10,
       userMessages: 5,
+      totalTruncationSections: 0,
+      continueHereFiredCount: 0,
     },
     byPhase: [
       {
@@ -187,6 +276,11 @@ console.log("\n=== renderMetricsView ===");
         cost: 2.50,
       },
     ],
+    bySlice: [
+      { sliceId: "M001/S01", units: 3, tokens: { input: 600, output: 300, cacheRead: 100, cacheWrite: 50, total: 1050 }, cost: 1.50, duration: 40000 },
+      { sliceId: "M001/S02", units: 2, tokens: { input: 400, output: 200, cacheRead: 100, cacheWrite: 50, total: 750 }, cost: 1.00, duration: 20000 },
+    ],
+    remainingSliceCount: 3,
   });
 
   const lines = renderMetricsView(data, mockTheme, 80);
@@ -194,6 +288,11 @@ console.log("\n=== renderMetricsView ===");
   assertTrue(lines.some(l => l.includes("$2.50")), "shows total cost");
   assertTrue(lines.some(l => l.includes("execution")), "shows phase name");
   assertTrue(lines.some(l => l.includes("claude-opus-4-6")), "shows model name");
+  assertTrue(lines.some(l => l.includes("Projections")), "shows projections section");
+  assertTrue(lines.some(l => l.includes("Avg cost/slice")), "shows avg cost per slice");
+  assertTrue(lines.some(l => l.includes("Projected remaining")), "shows projected remaining");
+  assertTrue(lines.some(l => l.includes("Burn rate")), "shows burn rate");
+  assertTrue(lines.some(l => l.includes("Cost trend")), "shows sparkline");
 }
 
 {
@@ -237,11 +336,16 @@ console.log("\n=== renderTimelineView ===");
     ],
   });
 
-  const lines = renderTimelineView(data, mockTheme, 80);
-  assertTrue(lines.length >= 2, "timeline view produces lines for each unit");
-  assertTrue(lines.some(l => l.includes("execute-task")), "shows unit type");
-  assertTrue(lines.some(l => l.includes("M001/S01/T01")), "shows unit id");
-  assertTrue(lines.some(l => l.includes("$0.42")), "shows unit cost");
+  // Wide terminal — Gantt view
+  const ganttLines = renderTimelineView(data, mockTheme, 120);
+  assertTrue(ganttLines.length >= 2, "gantt view produces lines for each unit");
+
+  // Narrow terminal — list view
+  const listLines = renderTimelineView(data, mockTheme, 80);
+  assertTrue(listLines.length >= 2, "list view produces lines for each unit");
+  assertTrue(listLines.some(l => l.includes("execute-task")), "shows unit type");
+  assertTrue(listLines.some(l => l.includes("M001/S01/T01")), "shows unit id");
+  assertTrue(listLines.some(l => l.includes("$0.42")), "shows unit cost");
 }
 
 {
@@ -250,6 +354,125 @@ console.log("\n=== renderTimelineView ===");
   assertTrue(lines.some(l => l.includes("No execution history")), "shows empty message");
 }
 
+// ─── renderAgentView ────────────────────────────────────────────────────────
+
+console.log("\n=== renderAgentView ===");
+
+{
+  const now = Date.now();
+  const data = makeVisualizerData({
+    agentActivity: {
+      currentUnit: { type: "execute-task", id: "M001/S02/T03", startedAt: now - 60000 },
+      elapsed: 60000,
+      completedUnits: 8,
+      totalSlices: 15,
+      completionRate: 2.4,
+      active: true,
+      sessionCost: 1.23,
+      sessionTokens: 45200,
+    },
+    units: [
+      {
+        type: "execute-task", id: "M001/S01/T01", model: "claude-opus-4-6",
+        startedAt: now - 300000, finishedAt: now - 240000,
+        tokens: { input: 500, output: 200, cacheRead: 100, cacheWrite: 50, total: 850 },
+        cost: 0.12, toolCalls: 5, assistantMessages: 3, userMessages: 1,
+      },
+    ],
+  });
+
+  const lines = renderAgentView(data, mockTheme, 80);
+  assertTrue(lines.length > 0, "agent view produces output");
+  assertTrue(lines.some(l => l.includes("ACTIVE")), "shows active status");
+  assertTrue(lines.some(l => l.includes("M001/S02/T03")), "shows current unit");
+  assertTrue(lines.some(l => l.includes("8/15")), "shows progress fraction");
+  assertTrue(lines.some(l => l.includes("2.4 units/hr")), "shows completion rate");
+  assertTrue(lines.some(l => l.includes("$1.23")), "shows session cost");
+}
+
+{
+  const data = makeVisualizerData({ agentActivity: null });
+  const lines = renderAgentView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("No agent activity")), "shows no-activity message");
+}
+
+{
+  const data = makeVisualizerData({
+    agentActivity: {
+      currentUnit: null,
+      elapsed: 0,
+      completedUnits: 5,
+      totalSlices: 10,
+      completionRate: 1.5,
+      active: false,
+      sessionCost: 0.50,
+      sessionTokens: 20000,
+    },
+  });
+
+  const lines = renderAgentView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("IDLE")), "shows idle status");
+  assertTrue(lines.some(l => l.includes("Not in auto mode")), "shows not-in-auto message");
+}
+
+// ─── renderChangelogView ────────────────────────────────────────────────────
+
+console.log("\n=== renderChangelogView ===");
+
+{
+  const data = makeVisualizerData({
+    changelog: {
+      entries: [
+        {
+          milestoneId: "M001",
+          sliceId: "S01",
+          title: "Core Authentication Setup",
+          oneLiner: "Added JWT-based auth with refresh token rotation",
+          filesModified: [
+            { path: "src/auth/jwt.ts", description: "JWT token generation and validation" },
+            { path: "src/auth/middleware.ts", description: "Express middleware for auth checks" },
+          ],
+          completedAt: "2026-03-15T14:30:00Z",
+        },
+      ],
+    },
+  });
+
+  const lines = renderChangelogView(data, mockTheme, 80);
+  assertTrue(lines.length > 0, "changelog view produces output");
+  assertTrue(lines.some(l => l.includes("M001/S01")), "shows slice reference");
+  assertTrue(lines.some(l => l.includes("Core Authentication Setup")), "shows entry title");
+  assertTrue(lines.some(l => l.includes("JWT-based auth")), "shows one-liner");
+  assertTrue(lines.some(l => l.includes("src/auth/jwt.ts")), "shows modified file");
+  assertTrue(lines.some(l => l.includes("2026-03-15")), "shows completed date");
+}
+
+{
+  const data = makeVisualizerData({ changelog: { entries: [] } });
+  const lines = renderChangelogView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("No completed slices")), "shows empty state");
+}
+
+// ─── renderExportView ───────────────────────────────────────────────────────
+
+console.log("\n=== renderExportView ===");
+
+{
+  const data = makeVisualizerData();
+  const lines = renderExportView(data, mockTheme, 80);
+  assertTrue(lines.some(l => l.includes("Export Options")), "shows export header");
+  assertTrue(lines.some(l => l.includes("[m]")), "shows markdown option");
+  assertTrue(lines.some(l => l.includes("[j]")), "shows json option");
+  assertTrue(lines.some(l => l.includes("[s]")), "shows snapshot option");
+}
+
+{
+  const data = makeVisualizerData();
+  const lines = renderExportView(data, mockTheme, 80, "/tmp/export-2026.md");
+  assertTrue(lines.some(l => l.includes("Last export:")), "shows last export path");
+  assertTrue(lines.some(l => l.includes("/tmp/export-2026.md")), "shows specific export path");
+}
+
 // ─── Report ─────────────────────────────────────────────────────────────────
 
 report();

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

@@ -0,0 +1,205 @@
+/**
+ * worktree-db-integration.test.ts
+ *
+ * Integration tests for the worktree DB copy and reconcile hooks.
+ * Uses real temp git repos and real SQLite databases.
+ *
+ * Test cases:
+ *   1. Copy: createAutoWorktree seeds .gsd/gsd.db into the worktree when main has one
+ *   2. Copy-skip: createAutoWorktree silently skips when main has no gsd.db
+ *   3. Reconcile: reconcileWorktreeDb merges worktree rows into main DB
+ *   4. Reconcile-skip: reconcileWorktreeDb is non-fatal when both paths are nonexistent
+ *   5. Failure path: reconcileWorktreeDb emits to stderr on open failure (observable)
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { createAutoWorktree } from "../auto-worktree.ts";
+import { worktreePath } from "../worktree-manager.ts";
+import {
+  copyWorktreeDb,
+  reconcileWorktreeDb,
+  openDatabase,
+  closeDatabase,
+  upsertDecision,
+  getActiveDecisions,
+  isDbAvailable,
+} from "../gsd-db.ts";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-db-int-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const savedCwd = process.cwd();
+  const tempDirs: string[] = [];
+
+  function makeTempDir(): string {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-db-int-")));
+    tempDirs.push(dir);
+    return dir;
+  }
+
+  try {
+
+    // ─── Test 1: copy on worktree creation ───────────────────────────
+    console.log("\n=== Test 1: copy on worktree creation ===");
+    {
+      const tempDir = createTempRepo();
+      tempDirs.push(tempDir);
+
+      // Seed a gsd.db in the main repo
+      const gsdDir = join(tempDir, ".gsd");
+      mkdirSync(gsdDir, { recursive: true });
+      const mainDbPath = join(gsdDir, "gsd.db");
+      openDatabase(mainDbPath);
+      closeDatabase();
+
+      // Commit so createAutoWorktree can copy planning artifacts
+      run("git add .", tempDir);
+      run('git commit -m "add gsd dir"', tempDir);
+
+      // createAutoWorktree should copy the DB into the worktree
+      const wtPath = createAutoWorktree(tempDir, "M004");
+
+      const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
+      assertTrue(
+        existsSync(worktreeDbPath),
+        "gsd.db exists in worktree .gsd after createAutoWorktree",
+      );
+
+      // Restore cwd for next test
+      process.chdir(savedCwd);
+    }
+
+    // ─── Test 2: copy skip when no source DB ─────────────────────────
+    console.log("\n=== Test 2: copy skip when no source DB ===");
+    {
+      const tempDir = createTempRepo();
+      tempDirs.push(tempDir);
+
+      // No gsd.db — just a bare repo
+      let threw = false;
+      let wtPath: string | null = null;
+      try {
+        wtPath = createAutoWorktree(tempDir, "M004");
+      } catch (err) {
+        threw = true;
+        console.error("  Unexpected throw:", err);
+      }
+
+      assertTrue(!threw, "createAutoWorktree does not throw when no source DB");
+
+      const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
+      assertTrue(
+        !existsSync(worktreeDbPath),
+        "gsd.db is absent in worktree when source had none",
+      );
+
+      process.chdir(savedCwd);
+    }
+
+    // ─── Test 3: reconcile inserts worktree rows into main ───────────
+    console.log("\n=== Test 3: reconcile merges worktree rows into main ===");
+    {
+      const mainDbPath = join(makeTempDir(), "main.db");
+      const worktreeDbPath = join(makeTempDir(), "wt.db");
+
+      // Seed main DB (empty schema)
+      openDatabase(mainDbPath);
+      closeDatabase();
+
+      // Seed worktree DB with one decision
+      openDatabase(worktreeDbPath);
+      upsertDecision({
+        id: "D-WT-001",
+        when_context: "integration test",
+        scope: "test",
+        decision: "use reconcile",
+        choice: "reconcile on merge",
+        rationale: "test coverage",
+        revisable: "no",
+        superseded_by: null,
+      });
+      closeDatabase();
+
+      // Reconcile worktree → main
+      const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+      assertTrue(result.decisions >= 1, "reconcile reports at least 1 decision merged");
+
+      // Open main DB and verify the row is present
+      openDatabase(mainDbPath);
+      const decisions = getActiveDecisions();
+      closeDatabase();
+
+      const found = decisions.some((d) => d.id === "D-WT-001");
+      assertTrue(found, "worktree decision D-WT-001 present in main DB after reconcile");
+    }
+
+    // ─── Test 4: reconcile non-fatal when both paths nonexistent ─────
+    console.log("\n=== Test 4: reconcile non-fatal on nonexistent paths ===");
+    {
+      let threw = false;
+      try {
+        reconcileWorktreeDb("/nonexistent/path/gsd.db", "/also/nonexistent/gsd.db");
+      } catch {
+        threw = true;
+      }
+      assertTrue(!threw, "reconcileWorktreeDb does not throw when worktree DB is absent");
+    }
+
+    // ─── Test 5: failure path observable via stderr (diagnostic) ─────
+    // reconcileWorktreeDb emits to stderr on reconciliation failures.
+    // We can't easily intercept stderr in this test harness, but we verify
+    // that the function returns the zero-result shape (not undefined/throws)
+    // when the worktree DB is missing — confirming the failure path is non-fatal
+    // and returns a structured result.
+    console.log("\n=== Test 5: reconcile returns zero-shape when worktree DB absent ===");
+    {
+      const mainDbPath = join(makeTempDir(), "main2.db");
+      openDatabase(mainDbPath);
+      closeDatabase();
+
+      const result = reconcileWorktreeDb(mainDbPath, "/definitely/does/not/exist.db");
+      assertEq(result.decisions, 0, "decisions is 0 when worktree DB absent");
+      assertEq(result.requirements, 0, "requirements is 0 when worktree DB absent");
+      assertEq(result.artifacts, 0, "artifacts is 0 when worktree DB absent");
+      assertEq(result.conflicts.length, 0, "conflicts is empty when worktree DB absent");
+    }
+
+  } finally {
+    // Always restore cwd
+    process.chdir(savedCwd);
+    // Ensure DB is closed
+    if (isDbAvailable()) closeDatabase();
+    // Remove all temp dirs
+    for (const dir of tempDirs) {
+      if (existsSync(dir)) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+
+  report();
+}
+
+main();