gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

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

@@ -1,56 +1,58 @@
 /**
- * /gsd show-config command — structural tests.
- *
- * Verifies the config overlay class and command handler exist
- * with correct structure.
+ * /gsd show-config command behavior tests.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const overlaySrc = readFileSync(join(__dirname, "..", "config-overlay.ts"), "utf-8");
-const coreSrc = readFileSync(join(__dirname, "..", "commands", "handlers", "core.ts"), "utf-8");
-
-// ─── Config overlay ───────────────────────────────────────────────────────
-
-test("GSDConfigOverlay class is exported", () => {
-  assert.ok(
-    overlaySrc.includes("export class GSDConfigOverlay"),
-    "GSDConfigOverlay should be exported",
+import { GSDConfigOverlay, formatConfigText } from "../config-overlay.ts";
+import { handleCoreCommand } from "../commands/handlers/core.ts";
+
+const theme = {
+  bold: (s: string) => s,
+  fg: (_name: string, s: string) => s,
+};
+
+test("GSDConfigOverlay renders and responds to input", () => {
+  let renderRequests = 0;
+  let closed = false;
+  const overlay = new GSDConfigOverlay(
+    { requestRender: () => { renderRequests++; } },
+    theme as any,
+    () => { closed = true; },
   );
-});
 
-test("GSDConfigOverlay implements Component interface methods", () => {
-  assert.ok(overlaySrc.includes("render("), "should have render method");
-  assert.ok(overlaySrc.includes("handleInput("), "should have handleInput method");
-  assert.ok(overlaySrc.includes("invalidate("), "should have invalidate method");
-  assert.ok(overlaySrc.includes("dispose("), "should have dispose method");
-});
+  const lines = overlay.render(60);
+  assert.ok(lines.some((line) => line.includes("GSD Configuration")));
 
-test("formatConfigText function is exported", () => {
-  assert.ok(
-    overlaySrc.includes("export function formatConfigText"),
-    "formatConfigText should be exported for non-overlay fallback",
-  );
-});
+  overlay.handleInput("j");
+  assert.equal(renderRequests, 1);
 
-// ─── Command handler ──────────────────────────────────────────────────────
+  overlay.handleInput("q");
+  assert.equal(closed, true);
+});
 
-test("core handler routes show-config command", () => {
-  assert.ok(
-    coreSrc.includes('"show-config"'),
-    "core handler should match show-config command",
-  );
+test("formatConfigText provides a text fallback", () => {
+  const text = formatConfigText();
+  assert.match(text, /GSD Configuration/);
+  assert.match(text, /SOURCES/);
 });
 
-test("show-config has text fallback via formatConfigText", () => {
-  assert.ok(
-    coreSrc.includes("formatConfigText"),
-    "show-config should use formatConfigText as fallback",
-  );
+test("core handler routes show-config to overlay with text fallback", async () => {
+  const notifications: Array<{ message: string; level: string }> = [];
+  const ctx = {
+    ui: {
+      custom: async () => undefined,
+      notify: (message: string, level: string) => {
+        notifications.push({ message, level });
+      },
+    },
+  };
+
+  const handled = await handleCoreCommand("show-config", ctx as any);
+
+  assert.equal(handled, true);
+  assert.equal(notifications.length, 1);
+  assert.equal(notifications[0]?.level, "info");
+  assert.match(notifications[0]?.message ?? "", /GSD Configuration/);
 });

package/src/resources/extensions/gsd/tests/signal-handlers.test.ts

@@ -101,3 +101,30 @@ test("registerSigtermHandler deregisters previous handler from all signals", ()
   // Clean up
   deregisterSigtermHandler(handler2);
 });
+
+test("registered signal handler runs best-effort cleanup before exiting", () => {
+  let cleanupCalled = false;
+  let exitCode: number | string | null | undefined;
+  const originalExit = process.exit;
+  const handler = registerSigtermHandler(
+    "/tmp/test-signal-cleanup",
+    null,
+    () => {
+      cleanupCalled = true;
+    },
+  );
+
+  (process as any).exit = ((code?: number | string | null) => {
+    exitCode = code;
+    throw new Error("process.exit intercepted");
+  }) as never;
+
+  try {
+    assert.throws(() => handler(), /process\.exit intercepted/);
+    assert.equal(cleanupCalled, true);
+    assert.equal(exitCode, 0);
+  } finally {
+    (process as any).exit = originalExit;
+    deregisterSigtermHandler(handler);
+  }
+});

package/src/resources/extensions/gsd/tests/skip-slice-state-rebuild.test.ts

@@ -1,31 +1,63 @@
 /**
- * Regression test for #3477: gsd_skip_slice tool must rebuild STATE.md
- * after updating the DB so auto-mode reads the correct state.
+ * Regression test for #3477: gsd_skip_slice updates DB state and rebuilds
+ * the projected STATE.md artifact.
  */
-import { test } from "node:test";
+
+import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-test("gsd_skip_slice tool calls rebuildState after DB update (#3477)", () => {
-  const src = readFileSync(
-    join(import.meta.dirname, "..", "bootstrap", "db-tools.ts"),
-    "utf-8",
-  );
-  // The fix adds a rebuildState call after updateSliceStatus in skip_slice
-  assert.ok(
-    src.includes("rebuildState"),
-    "gsd_skip_slice must call rebuildState after updating slice status",
-  );
-});
+import { registerDbTools } from "../bootstrap/db-tools.ts";
+import {
+  closeDatabase,
+  getSlice,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
+
+test("gsd_skip_slice marks a slice skipped and refreshes STATE.md", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-skip-slice-"));
+  const tools = new Map<string, any>();
+  const pi = { registerTool: (tool: any) => tools.set(tool.name, tool) };
+
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Skip Test", status: "active", depends_on: [] });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Skipped slice",
+      status: "pending",
+      risk: "low",
+      depends: [],
+      demo: "",
+      sequence: 1,
+    });
+
+    registerDbTools(pi as any);
+    const skipSlice = tools.get("gsd_skip_slice");
+    assert.ok(skipSlice, "gsd_skip_slice is registered");
+
+    const result = await skipSlice.execute(
+      "tool-call",
+      { milestoneId: "M001", sliceId: "S01", reason: "descoped" },
+      undefined,
+      undefined,
+      { cwd: base },
+    );
+
+    assert.equal(result.details.operation, "skip_slice");
+    assert.equal(getSlice("M001", "S01")?.status, "skipped");
 
-test("rethink prompt warns against markdown-only edits for skip (#3477)", () => {
-  const prompt = readFileSync(
-    join(import.meta.dirname, "..", "prompts", "rethink.md"),
-    "utf-8",
-  );
-  assert.ok(
-    prompt.includes("MUST") && prompt.includes("gsd_skip_slice"),
-    "Rethink prompt must emphasize gsd_skip_slice tool requirement",
-  );
+    const statePath = join(base, ".gsd", "STATE.md");
+    assert.equal(existsSync(statePath), true, "STATE.md should be rebuilt");
+    assert.match(readFileSync(statePath, "utf-8"), /Active Slice:\*\* None/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
 });

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

@@ -1,17 +1,57 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { DISPATCH_RULES } from "../auto-dispatch.ts";
+import {
+  closeDatabase,
+  getLatestAssessmentByScope,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
 
-test("skipped validation DB persistence stays atomic", () => {
-  const source = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+test("skipped validation dispatch persists the validation file and DB assessment together", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-skip-validation-"));
+  const milestoneDir = join(basePath, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  const rule = DISPATCH_RULES.find((r) => r.name === "validating-milestone → validate-milestone");
+  assert.ok(rule, "validate-milestone rule is registered");
 
-  assert.match(
-    source,
-    /if \(isDbAvailable\(\)\) \{\s+transaction\(\(\) => \{\s+insertAssessment\([\s\S]*?insertMilestoneValidationGates\(/,
-    "skipped validation DB writes must remain inside a single transaction",
-  );
+  try {
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# S01 Summary\n", "utf-8");
+    openDatabase(join(basePath, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Validation", status: "active", depends_on: [] });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Done slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "",
+      sequence: 1,
+    });
+
+    const action = await rule.match({
+      state: { phase: "validating-milestone" },
+      mid: "M001",
+      midTitle: "Validation",
+      basePath,
+      prefs: { phases: { skip_milestone_validation: true } },
+    } as any);
+
+    assert.deepEqual(action, { action: "skip" });
+    assert.equal(existsSync(join(milestoneDir, "M001-VALIDATION.md")), true);
+    assert.equal(
+      getLatestAssessmentByScope("M001", "milestone-validation")?.status,
+      "pass",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/slice-cadence.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Slice-cadence merge and resquash tests.
 /**
  * Tests for slice-cadence collapse — #4765.
  *
@@ -20,6 +22,7 @@ import {
 } from "../slice-cadence.ts";
 import { MergeConflictError } from "../git-service.ts";
 import { summarizeWorktreeTelemetry } from "../worktree-telemetry.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 function git(args: string[], cwd: string): string {
   return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -81,6 +84,7 @@ describe("mergeSliceToMain", () => {
 
   afterEach(() => {
     try { process.chdir(originalCwd); } catch { /* */ }
+    closeDatabase();
     rmSync(dir, { recursive: true, force: true });
   });
 
@@ -109,6 +113,25 @@ describe("mergeSliceToMain", () => {
     assert.equal(summary.sliceMergeConflicts, 0);
   });
 
+  test("slice-cadence commit messages include milestone and slice names", () => {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "M001: Backend foundation", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "S01: Core API", status: "complete" });
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1 work\n", "feat: S01 work");
+
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    const subject = git(["log", "-1", "--format=%s", "main"], dir);
+    const body = git(["log", "-1", "--format=%B", "main"], dir);
+    assert.equal(subject, "feat: Core API - S01 of M001 (slice-cadence)");
+    assert.ok(body.includes("Slice: S01 - Core API"));
+    assert.ok(body.includes("Milestone: M001 - Backend foundation"));
+    assert.ok(body.includes("GSD-Slice: S01"));
+    assert.ok(body.includes("GSD-Milestone: M001"));
+  });
+
   test("merges slices to the recorded integration branch", () => {
     git(["checkout", "-b", "develop"], dir);
     mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });

package/src/resources/extensions/gsd/tests/slice-context-injection.test.ts

@@ -1,63 +1,79 @@
 /**
- * Regression test: S##-CONTEXT.md from slice discussion must be
- * injected into all 5 downstream prompt builders (#3452).
- *
- * Scans auto-prompts.ts for the 5 builder functions and verifies
- * each one resolves and inlines the slice-level CONTEXT file.
+ * Regression test: S##-CONTEXT.md from slice discussion is injected into
+ * downstream prompt builders (#3452).
  */
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
-const source = readFileSync(autoPromptsPath, "utf-8");
+import {
+  buildCompleteSlicePrompt,
+  buildPlanSlicePrompt,
+  buildReassessRoadmapPrompt,
+  buildReplanSlicePrompt,
+  buildResearchSlicePrompt,
+} from "../auto-prompts.ts";
 
-const BUILDERS = [
-  "buildResearchSlicePrompt",
-  "buildPlanSlicePrompt",
-  "buildCompleteSlicePrompt",
-  "buildReplanSlicePrompt",
-  "buildReassessRoadmapPrompt",
-];
+function makeSliceContextFixture(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-context-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceDir, "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Context Injection",
+      "",
+      "## Slices",
+      "- [ ] **S01: Context-heavy slice** `risk:low`",
+      "  Demo: context appears in prompts.",
+    ].join("\n"),
+    "utf-8",
+  );
+  writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# M001 Context\n", "utf-8");
+  writeFileSync(
+    join(sliceDir, "S01-CONTEXT.md"),
+    "# Slice Context\n\nUnique slice context marker: SLICE-CONTEXT-3452\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Context-heavy slice",
+      "",
+      "**Goal:** Test context injection.",
+      "**Demo:** Prompt contains the marker.",
+      "",
+      "## Tasks",
+      "- [ ] **T01: Task** `est:10m`",
+    ].join("\n"),
+    "utf-8",
+  );
+  return base;
+}
 
 describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
-  for (const builder of BUILDERS) {
-    test(`${builder} resolves slice CONTEXT file`, () => {
-      // Find the function body
-      const fnStart = source.indexOf(`export async function ${builder}`);
-      assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
+  const builders: Array<[string, (base: string) => Promise<string>]> = [
+    ["buildResearchSlicePrompt", (base) => buildResearchSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildPlanSlicePrompt", (base) => buildPlanSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildCompleteSlicePrompt", (base) => buildCompleteSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildReplanSlicePrompt", (base) => buildReplanSlicePrompt("M001", "Context Injection", "S01", "Context-heavy slice", base)],
+    ["buildReassessRoadmapPrompt", (base) => buildReassessRoadmapPrompt("M001", "Context Injection", "S01", base)],
+  ];
 
-      // Get a reasonable chunk after the function start
-      const chunk = extractSourceRegion(source, `export async function ${builder}`);
-
-      // ADR-011: buildPlanSlicePrompt / buildRefineSlicePrompt now delegate to
-      // a shared helper (renderSlicePrompt) that performs the slice CONTEXT
-      // resolve. When a builder delegates, scan the helper's body instead.
-      const delegatesToHelper = chunk.includes("renderSlicePrompt(");
-      const bodyToCheck = delegatesToHelper
-        ? (() => {
-            const helperStart = source.indexOf("async function renderSlicePrompt");
-            assert.ok(helperStart !== -1, "renderSlicePrompt helper must exist");
-            return extractSourceRegion(source, "async function renderSlicePrompt");
-          })()
-        : chunk;
-
-      // Must resolve the slice CONTEXT path
-      assert.ok(
-        bodyToCheck.includes('resolveSliceFile(base, mid,') && bodyToCheck.includes('"CONTEXT"'),
-        `${builder} should call resolveSliceFile with "CONTEXT" (directly or via renderSlicePrompt)`,
-      );
-
-      // Must inline it with inlineFileOptional
-      assert.ok(
-        bodyToCheck.includes("Slice Context"),
-        `${builder} should inline slice CONTEXT with a "Slice Context" label`,
-      );
+  for (const [name, build] of builders) {
+    test(`${name} includes slice discussion context`, async () => {
+      const base = makeSliceContextFixture();
+      try {
+        const prompt = await build(base);
+        assert.match(prompt, /Slice Context/);
+        assert.match(prompt, /SLICE-CONTEXT-3452/);
+      } finally {
+        rmSync(base, { recursive: true, force: true });
+      }
     });
   }
 });