gsd-pi 2.37.0 → 2.37.1-dev.3bbb0a9

package/src/resources/extensions/gsd/tests/reactive-graph.test.ts

@@ -0,0 +1,299 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  deriveTaskGraph,
+  getReadyTasks,
+  chooseNonConflictingSubset,
+  isGraphAmbiguous,
+  detectDeadlock,
+  graphMetrics,
+} from "../reactive-graph.ts";
+import { parseTaskPlanIO } from "../files.ts";
+import type { TaskIO, DerivedTaskNode } from "../types.ts";
+
+// ─── parseTaskPlanIO ──────────────────────────────────────────────────────
+
+test("parseTaskPlanIO extracts backtick-wrapped file paths from Inputs and Expected Output", () => {
+  const content = `---
+estimated_steps: 3
+estimated_files: 2
+---
+
+# T01: Setup Models
+
+**Slice:** S01 — Core Setup
+**Milestone:** M001
+
+## Description
+
+Create the core data models.
+
+## Steps
+
+1. Create types file
+2. Create models file
+
+## Must-Haves
+
+- [ ] Type definitions complete
+
+## Verification
+
+- Run type checker
+
+## Inputs
+
+- \`src/types.ts\` — Existing type definitions from prior work
+- \`src/config.json\` — Configuration schema
+
+## Expected Output
+
+- \`src/models.ts\` — New data model definitions
+- \`src/models.test.ts\` — Unit tests for models
+`;
+
+  const io = parseTaskPlanIO(content);
+  assert.deepEqual(io.inputFiles, ["src/types.ts", "src/config.json"]);
+  assert.deepEqual(io.outputFiles, ["src/models.ts", "src/models.test.ts"]);
+});
+
+test("parseTaskPlanIO returns empty arrays for missing sections", () => {
+  const content = `# T01: Something\n\n## Description\n\nNo IO sections here.\n`;
+  const io = parseTaskPlanIO(content);
+  assert.deepEqual(io.inputFiles, []);
+  assert.deepEqual(io.outputFiles, []);
+});
+
+test("parseTaskPlanIO ignores non-file-path backtick tokens", () => {
+  const content = `# T01: Test
+
+## Inputs
+
+- \`true\` — a boolean flag
+- \`src/index.ts\` — main entry
+- \`npm run test\` — a command, not a file
+
+## Expected Output
+
+- \`dist/bundle.js\` — compiled output
+- \`false\` — not a file
+`;
+
+  const io = parseTaskPlanIO(content);
+  assert.deepEqual(io.inputFiles, ["src/index.ts"]);
+  assert.deepEqual(io.outputFiles, ["dist/bundle.js"]);
+});
+
+test("parseTaskPlanIO handles multiple backtick tokens on one line", () => {
+  const content = `# T01: Multi
+
+## Inputs
+
+- \`src/a.ts\` and \`src/b.ts\` — both needed
+
+## Expected Output
+
+- \`src/c.ts\` — output
+`;
+  const io = parseTaskPlanIO(content);
+  assert.deepEqual(io.inputFiles, ["src/a.ts", "src/b.ts"]);
+  assert.deepEqual(io.outputFiles, ["src/c.ts"]);
+});
+
+// ─── deriveTaskGraph ──────────────────────────────────────────────────────
+
+test("deriveTaskGraph: linear chain T01→T02→T03", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "First", inputFiles: [], outputFiles: ["src/a.ts"], done: false },
+    { id: "T02", title: "Second", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false },
+    { id: "T03", title: "Third", inputFiles: ["src/b.ts"], outputFiles: ["src/c.ts"], done: false },
+  ];
+
+  const graph = deriveTaskGraph(tasks);
+  assert.deepEqual(graph[0].dependsOn, []);
+  assert.deepEqual(graph[1].dependsOn, ["T01"]);
+  assert.deepEqual(graph[2].dependsOn, ["T02"]);
+});
+
+test("deriveTaskGraph: diamond dependency", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "Base", inputFiles: [], outputFiles: ["src/base.ts"], done: false },
+    { id: "T02", title: "Left", inputFiles: ["src/base.ts"], outputFiles: ["src/left.ts"], done: false },
+    { id: "T03", title: "Right", inputFiles: ["src/base.ts"], outputFiles: ["src/right.ts"], done: false },
+    { id: "T04", title: "Merge", inputFiles: ["src/left.ts", "src/right.ts"], outputFiles: ["src/final.ts"], done: false },
+  ];
+
+  const graph = deriveTaskGraph(tasks);
+  assert.deepEqual(graph[0].dependsOn, []);
+  assert.deepEqual(graph[1].dependsOn, ["T01"]);
+  assert.deepEqual(graph[2].dependsOn, ["T01"]);
+  assert.deepEqual(graph[3].dependsOn, ["T02", "T03"]);
+});
+
+test("deriveTaskGraph: fully independent tasks", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: false },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: ["src/b.ts"], done: false },
+    { id: "T03", title: "C", inputFiles: [], outputFiles: ["src/c.ts"], done: false },
+  ];
+
+  const graph = deriveTaskGraph(tasks);
+  assert.deepEqual(graph[0].dependsOn, []);
+  assert.deepEqual(graph[1].dependsOn, []);
+  assert.deepEqual(graph[2].dependsOn, []);
+});
+
+test("deriveTaskGraph: self-referencing output→input is excluded", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "Self", inputFiles: ["src/a.ts"], outputFiles: ["src/a.ts"], done: false },
+  ];
+
+  const graph = deriveTaskGraph(tasks);
+  assert.deepEqual(graph[0].dependsOn, []);
+});
+
+// ─── getReadyTasks ────────────────────────────────────────────────────────
+
+test("getReadyTasks: partially completed graph", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "Base", inputFiles: [], outputFiles: ["src/a.ts"], done: true },
+    { id: "T02", title: "Dep", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false },
+    { id: "T03", title: "Blocked", inputFiles: ["src/b.ts"], outputFiles: ["src/c.ts"], done: false },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const ready = getReadyTasks(graph, new Set(["T01"]), new Set());
+  assert.deepEqual(ready, ["T02"]);
+});
+
+test("getReadyTasks: nothing complete → only root tasks ready", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "Root", inputFiles: [], outputFiles: ["src/a.ts"], done: false },
+    { id: "T02", title: "Dep", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const ready = getReadyTasks(graph, new Set(), new Set());
+  assert.deepEqual(ready, ["T01"]);
+});
+
+test("getReadyTasks: all complete → empty", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "Done", inputFiles: [], outputFiles: ["src/a.ts"], done: true },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const ready = getReadyTasks(graph, new Set(["T01"]), new Set());
+  assert.deepEqual(ready, []);
+});
+
+test("getReadyTasks: in-flight tasks excluded", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: false },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: ["src/b.ts"], done: false },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const ready = getReadyTasks(graph, new Set(), new Set(["T01"]));
+  assert.deepEqual(ready, ["T02"]);
+});
+
+// ─── chooseNonConflictingSubset ───────────────────────────────────────────
+
+test("chooseNonConflictingSubset: output conflicts", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/shared.ts"], done: false },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: ["src/shared.ts"], done: false },
+    { id: "T03", title: "C", inputFiles: [], outputFiles: ["src/other.ts"], done: false },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const selected = chooseNonConflictingSubset(["T01", "T02", "T03"], graph, 3, new Set());
+  // T01 claims shared.ts, T02 conflicts, T03 is fine
+  assert.deepEqual(selected, ["T01", "T03"]);
+});
+
+test("chooseNonConflictingSubset: respects maxParallel", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: false },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: ["src/b.ts"], done: false },
+    { id: "T03", title: "C", inputFiles: [], outputFiles: ["src/c.ts"], done: false },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const selected = chooseNonConflictingSubset(["T01", "T02", "T03"], graph, 2, new Set());
+  assert.deepEqual(selected, ["T01", "T02"]);
+});
+
+test("chooseNonConflictingSubset: respects inFlightOutputs", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: false },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: ["src/b.ts"], done: false },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const selected = chooseNonConflictingSubset(["T01", "T02"], graph, 4, new Set(["src/a.ts"]));
+  assert.deepEqual(selected, ["T02"]);
+});
+
+// ─── isGraphAmbiguous ─────────────────────────────────────────────────────
+
+test("isGraphAmbiguous: task with no IO → ambiguous", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: [], done: false, dependsOn: [] },
+    { id: "T02", title: "B", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false, dependsOn: [] },
+  ];
+  assert.equal(isGraphAmbiguous(graph), true);
+});
+
+test("isGraphAmbiguous: all tasks have IO → not ambiguous", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: false, dependsOn: [] },
+    { id: "T02", title: "B", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false, dependsOn: ["T01"] },
+  ];
+  assert.equal(isGraphAmbiguous(graph), false);
+});
+
+test("isGraphAmbiguous: done tasks with no IO are ignored", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: [], done: true, dependsOn: [] },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: ["src/b.ts"], done: false, dependsOn: [] },
+  ];
+  assert.equal(isGraphAmbiguous(graph), false);
+});
+
+// ─── detectDeadlock ───────────────────────────────────────────────────────
+
+test("detectDeadlock: circular dependency detected", () => {
+  // T01 depends on T02, T02 depends on T01 — deadlock
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: ["src/b.ts"], outputFiles: ["src/a.ts"], done: false, dependsOn: ["T02"] },
+    { id: "T02", title: "B", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false, dependsOn: ["T01"] },
+  ];
+  assert.equal(detectDeadlock(graph, new Set(), new Set()), true);
+});
+
+test("detectDeadlock: normal blocked-waiting-for-in-flight → not deadlock", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: false, dependsOn: [] },
+    { id: "T02", title: "B", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false, dependsOn: ["T01"] },
+  ];
+  // T01 is in-flight, T02 is waiting → not deadlock
+  assert.equal(detectDeadlock(graph, new Set(), new Set(["T01"])), false);
+});
+
+test("detectDeadlock: all complete → not deadlock", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: true, dependsOn: [] },
+  ];
+  assert.equal(detectDeadlock(graph, new Set(["T01"]), new Set()), false);
+});
+
+// ─── graphMetrics ─────────────────────────────────────────────────────────
+
+test("graphMetrics computes correct values", () => {
+  const tasks: TaskIO[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: ["src/a.ts"], done: true },
+    { id: "T02", title: "B", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false },
+    { id: "T03", title: "C", inputFiles: [], outputFiles: ["src/c.ts"], done: false },
+  ];
+  const graph = deriveTaskGraph(tasks);
+  const metrics = graphMetrics(graph);
+  assert.equal(metrics.taskCount, 3);
+  assert.equal(metrics.edgeCount, 1); // T02 depends on T01
+  assert.equal(metrics.readySetSize, 2); // T02 (T01 done) and T03 (no deps)
+  assert.equal(metrics.ambiguous, false);
+});

package/src/resources/extensions/gsd/tests/session-lock-regression.test.ts

@@ -17,6 +17,7 @@ import { tmpdir } from 'node:os';
 
 import {
   acquireSessionLock,
+  getSessionLockStatus,
   validateSessionLock,
   releaseSessionLock,
   readSessionLockData,
@@ -201,6 +202,50 @@ async function main(): Promise<void> {
     }
   }
 
+  // ─── 7b. getSessionLockStatus with missing metadata → reason surfaced ──
+  console.log('\n=== 7b. missing lock metadata → structured reason ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const status = getSessionLockStatus(base);
+      assertEq(status.valid, false, 'missing lock metadata is invalid');
+      assertEq(status.failureReason, 'missing-metadata', 'missing metadata reason is surfaced');
+      assertEq(status.expectedPid, process.pid, 'expected PID is included');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 7c. getSessionLockStatus with foreign PID → reason surfaced ───────
+  console.log('\n=== 7c. foreign PID in lock file → structured reason ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const foreignPid = process.pid + 1000;
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      writeFileSync(lockFile, JSON.stringify({
+        pid: foreignPid,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date().toISOString(),
+        completedUnits: 0,
+      }, null, 2));
+
+      const status = getSessionLockStatus(base);
+      assertEq(status.valid, false, 'foreign PID lock is invalid');
+      assertEq(status.failureReason, 'pid-mismatch', 'PID mismatch reason is surfaced');
+      assertEq(status.existingPid, foreignPid, 'existing PID is included');
+      assertEq(status.expectedPid, process.pid, 'expected PID is included');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
   // ─── 8. Acquire after release is possible ─────────────────────────────
   console.log('\n=== 8. acquire after release → re-acquirable ===');
   {

package/src/resources/extensions/gsd/types.ts

@@ -436,3 +436,46 @@ export interface ParallelConfig {
   merge_strategy: MergeStrategy;
   auto_merge: AutoMergeMode;
 }
+
+// ─── Reactive Task Execution Types ───────────────────────────────────────
+
+/** IO signature extracted from a single task plan's Inputs/Expected Output sections. */
+export interface TaskIO {
+  id: string;        // e.g. "T01"
+  title: string;
+  inputFiles: string[];
+  outputFiles: string[];
+  done: boolean;
+}
+
+/** A task node with derived dependency edges from input/output intersection. */
+export interface DerivedTaskNode extends TaskIO {
+  /** IDs of tasks whose outputFiles overlap with this task's inputFiles. */
+  dependsOn: string[];
+}
+
+/** Configuration for reactive (graph-derived parallel) task execution within a slice. */
+export interface ReactiveExecutionConfig {
+  enabled: boolean;
+  /** Maximum number of tasks to dispatch in parallel. Clamped to 1–8. */
+  max_parallel: number;
+  /** Isolation mode for parallel tasks within a slice. Currently only "same-tree" is supported. */
+  isolation_mode: "same-tree";
+}
+
+/** Per-slice reactive execution runtime state, persisted to disk. */
+export interface ReactiveExecutionState {
+  sliceId: string;
+  /** Task IDs that have been verified as completed. */
+  completed: string[];
+  /** Task IDs dispatched in the current/most recent reactive batch. */
+  dispatched: string[];
+  /** Snapshot of the graph at last dispatch. */
+  graphSnapshot: {
+    taskCount: number;
+    edgeCount: number;
+    readySetSize: number;
+    ambiguous: boolean;
+  };
+  updatedAt: string;
+}

package/src/resources/extensions/shared/format-utils.ts

@@ -1,12 +1,12 @@
 /**
- * Shared formatting and layout utilities for TUI dashboard components.
+ * Shared pure formatting utilities — no @gsd/pi-tui dependency.
  *
- * Consolidates helpers that were previously duplicated across
- * auto-dashboard.ts, dashboard-overlay.ts, and visualizer-views.ts.
+ * ANSI-aware layout helpers (padRight, joinColumns, centerLine, fitColumns)
+ * live in layout-utils.ts to avoid pulling @gsd/pi-tui into modules that
+ * run outside jiti's alias resolution (e.g. HTML report generation via
+ * dynamic import in auto-loop).
  */
 
-import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
-
 // ─── Duration Formatting ──────────────────────────────────────────────────────
 
 /** Format a millisecond duration as a compact human-readable string. */
@@ -31,45 +31,6 @@ export function formatTokenCount(count: number): string {
   return `${(count / 1_000_000).toFixed(2)}M`;
 }
 
-// ─── Layout Helpers ───────────────────────────────────────────────────────────
-
-/** Pad a string with trailing spaces to fill `width` (ANSI-aware). */
-export function padRight(content: string, width: number): string {
-  const vis = visibleWidth(content);
-  return content + " ".repeat(Math.max(0, width - vis));
-}
-
-/** Build a line with left-aligned and right-aligned content. */
-export function joinColumns(left: string, right: string, width: number): string {
-  const leftW = visibleWidth(left);
-  const rightW = visibleWidth(right);
-  if (leftW + rightW + 2 > width) {
-    return truncateToWidth(`${left}  ${right}`, width);
-  }
-  return left + " ".repeat(width - leftW - rightW) + right;
-}
-
-/** Center content within `width` (ANSI-aware). */
-export function centerLine(content: string, width: number): string {
-  const vis = visibleWidth(content);
-  if (vis >= width) return truncateToWidth(content, width);
-  const leftPad = Math.floor((width - vis) / 2);
-  return " ".repeat(leftPad) + content;
-}
-
-/** Join as many parts as fit within `width`, separated by `separator`. */
-export function fitColumns(parts: string[], width: number, separator = "  "): string {
-  const filtered = parts.filter(Boolean);
-  if (filtered.length === 0) return "";
-  let result = filtered[0];
-  for (let i = 1; i < filtered.length; i++) {
-    const candidate = `${result}${separator}${filtered[i]}`;
-    if (visibleWidth(candidate) > width) break;
-    result = candidate;
-  }
-  return truncateToWidth(result, width);
-}
-
 // ─── Text Truncation ─────────────────────────────────────────────────────────
 
 /** Truncate a string to `maxLength` characters, replacing the last character with an ellipsis if needed. */

package/src/resources/extensions/shared/layout-utils.ts

@@ -0,0 +1,49 @@
+/**
+ * ANSI-aware TUI layout utilities that depend on @gsd/pi-tui.
+ *
+ * Separated from format-utils.ts so that modules needing only pure
+ * formatting (e.g. HTML report generation) can import format-utils
+ * without pulling in the @gsd/pi-tui dependency — which fails when
+ * loaded outside jiti's alias resolution context.
+ */
+
+import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+
+// ─── Layout Helpers ───────────────────────────────────────────────────────────
+
+/** Pad a string with trailing spaces to fill `width` (ANSI-aware). */
+export function padRight(content: string, width: number): string {
+  const vis = visibleWidth(content);
+  return content + " ".repeat(Math.max(0, width - vis));
+}
+
+/** Build a line with left-aligned and right-aligned content. */
+export function joinColumns(left: string, right: string, width: number): string {
+  const leftW = visibleWidth(left);
+  const rightW = visibleWidth(right);
+  if (leftW + rightW + 2 > width) {
+    return truncateToWidth(`${left}  ${right}`, width);
+  }
+  return left + " ".repeat(width - leftW - rightW) + right;
+}
+
+/** Center content within `width` (ANSI-aware). */
+export function centerLine(content: string, width: number): string {
+  const vis = visibleWidth(content);
+  if (vis >= width) return truncateToWidth(content, width);
+  const leftPad = Math.floor((width - vis) / 2);
+  return " ".repeat(leftPad) + content;
+}
+
+/** Join as many parts as fit within `width`, separated by `separator`. */
+export function fitColumns(parts: string[], width: number, separator = "  "): string {
+  const filtered = parts.filter(Boolean);
+  if (filtered.length === 0) return "";
+  let result = filtered[0];
+  for (let i = 1; i < filtered.length; i++) {
+    const candidate = `${result}${separator}${filtered[i]}`;
+    if (visibleWidth(candidate) > width) break;
+    result = candidate;
+  }
+  return truncateToWidth(result, width);
+}

package/src/resources/extensions/shared/mod.ts

@@ -13,15 +13,18 @@ export {
 	stripAnsi,
 	formatTokenCount,
 	formatDuration,
-	padRight,
-	joinColumns,
-	centerLine,
-	fitColumns,
 	sparkline,
 	normalizeStringArray,
 	fileLink,
 } from "./format-utils.js";
 
+export {
+	padRight,
+	joinColumns,
+	centerLine,
+	fitColumns,
+} from "./layout-utils.js";
+
 export { shortcutDesc } from "./terminal.js";
 export { toPosixPath } from "./path-display.js";
 export { showInterviewRound } from "./interview-ui.js";

package/src/resources/extensions/shared/tests/format-utils.test.ts

@@ -2,13 +2,15 @@ import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import {
   formatDuration,
+  sparkline,
+  stripAnsi,
+} from "../format-utils.js";
+import {
   padRight,
   joinColumns,
   centerLine,
   fitColumns,
-  sparkline,
-  stripAnsi,
-} from "../format-utils.js";
+} from "../layout-utils.js";
 
 describe("formatDuration", () => {
   it("formats seconds", () => {