gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/quick-auto-guard.test.ts

@@ -6,101 +6,31 @@
  * delegating to handleQuick.
  */
 
-import { describe, it, mock, beforeEach, afterEach } from "node:test";
+import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ─── Structural test: verify the guard exists in source ──────────────────────
+import { _setAutoActiveForTest } from "../auto.ts";
+import { handleWorkflowCommand } from "../commands/handlers/workflow.ts";
 
 describe("/gsd quick auto-mode guard (#2417)", () => {
-  it("handleWorkflowCommand checks isAutoActive() before calling handleQuick", () => {
-    // Read the source file and verify the guard is structurally present
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // Find the quick command block
-    const quickBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"quick"\s*\|\|\s*trimmed\.startsWith\("quick "\)\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(quickBlockMatch, "quick command block exists in handleWorkflowCommand");
-
-    const quickBlock = quickBlockMatch[1];
-
-    // Verify the shared auto-mode guard comes BEFORE handleQuick call.
-    // Accepts either the inline isAutoActive() check (legacy) or the shared
-    // requireNotAutoActive() helper (#4712).
-    const guardIndex = Math.max(
-      quickBlock.indexOf("isAutoActive()"),
-      quickBlock.indexOf("requireNotAutoActive("),
-    );
-    const handleQuickIndex = quickBlock.indexOf("handleQuick(");
-
-    assert.ok(guardIndex !== -1, "auto-mode guard exists in quick command block");
-    assert.ok(handleQuickIndex !== -1, "handleQuick() call exists in quick command block");
-    assert.ok(
-      guardIndex < handleQuickIndex,
-      "auto-mode guard appears before handleQuick() call",
-    );
-  });
-
-  it("guard shows error message mentioning /gsd stop", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // The shared helper assembles the message dynamically from the command name,
-    // so assert on the message fragment and the /gsd stop instruction.
-    assert.ok(
-      src.includes("cannot run while auto-mode is active"),
-      "error message explains that the command cannot run during auto-mode",
-    );
-    assert.ok(
-      src.includes("/gsd stop"),
-      "error message mentions /gsd stop as the resolution",
-    );
-  });
-
-  it("guard returns true (handled) to prevent falling through", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // After the isAutoActive() check and notify, there should be a `return true`
-    // before the handleQuick call
-    const quickBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"quick"\s*\|\|\s*trimmed\.startsWith\("quick "\)\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(quickBlockMatch);
-    const quickBlock = quickBlockMatch[1];
-
-    // The guard block should have its own return true before handleQuick
-    const guardBlock = quickBlock.slice(0, quickBlock.indexOf("handleQuick("));
-    assert.ok(
-      guardBlock.includes("return true"),
-      "guard block returns true before handleQuick is reached",
-    );
+  it("returns handled and notifies when auto-mode is active", async () => {
+    const notifications: Array<{ message: string; level?: string }> = [];
+    _setAutoActiveForTest(true);
+    try {
+      const handled = await handleWorkflowCommand("quick fix the docs", {
+        ui: {
+          notify(message: string, level?: string) {
+            notifications.push({ message, level });
+          },
+        },
+      } as any, {} as any);
+
+      assert.equal(handled, true);
+      assert.deepEqual(notifications, [{
+        message: "/gsd quick cannot run while auto-mode is active.\nStop auto-mode first with /gsd stop, then run /gsd quick.",
+        level: "error",
+      }]);
+    } finally {
+      _setAutoActiveForTest(false);
+    }
   });
 });

package/src/resources/extensions/gsd/tests/quick-turn-end-cleanup.test.ts

@@ -1,90 +1,61 @@
 /**
- * Tests that cleanupQuickBranch is called on turn_end to squash-merge the
- * quick branch back to the original branch after the agent completes.
- *
- * Relates to #2668: /gsd quick does not squash-merge branch back after agent
- * completes task. cleanupQuickBranch() exists but is never invoked.
- *
- * The fix registers a turn_end hook in register-hooks.ts that calls
- * cleanupQuickBranch() after each turn, which is a no-op when no quick-task
- * state is pending.
+ * Tests that cleanupQuickBranch is wired to turn_end by exercising the
+ * registered hook against a real temporary git repository.
  */
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-// ─── Structural test: verify turn_end hook exists in register-hooks.ts ──────
+import { registerHooks } from "../bootstrap/register-hooks.ts";
 
-describe("quick task turn_end cleanup (#2668)", () => {
-  const hooksSource = readFileSync(
-    join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
-    "utf-8",
-  );
-
-  it("register-hooks.ts loads cleanupQuickBranch from quick.ts", () => {
-    assert.ok(
-      hooksSource.includes("cleanupQuickBranch"),
-      "register-hooks.ts must reference cleanupQuickBranch",
-    );
-
-    // Verify it is loaded from quick.ts (static or lazy), not just mentioned in a comment.
-    const importMatch =
-      hooksSource.match(/import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/) ||
-      hooksSource.match(/const\s+\{\s*cleanupQuickBranch\s*\}\s*=\s*await\s+import\(["'][^"']*quick\.js["']\)/);
-    assert.ok(
-      importMatch,
-      "cleanupQuickBranch must be loaded from quick module",
-    );
-  });
-
-  it("registers a turn_end handler that calls cleanupQuickBranch", () => {
-    // Find the turn_end registration
-    const turnEndMatch = hooksSource.match(
-      /pi\.on\(\s*["']turn_end["']/,
-    );
-    assert.ok(
-      turnEndMatch,
-      "register-hooks.ts must register a turn_end handler",
-    );
-
-    // Extract the turn_end handler body — find everything from the pi.on("turn_end"
-    // to the matching closing });
-    const turnEndIdx = hooksSource.indexOf(turnEndMatch[0]);
-    assert.ok(turnEndIdx !== -1);
-
-    // Get the rest of the source from that point
-    const rest = hooksSource.slice(turnEndIdx);
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, { cwd, encoding: "utf-8" }).trim();
+}
 
-    // The handler must call cleanupQuickBranch
-    // Look for cleanupQuickBranch within the first handler body (up to first `});`)
-    const handlerEnd = rest.indexOf("});");
-    assert.ok(handlerEnd !== -1, "turn_end handler has a closing });");
-
-    const handlerBody = rest.slice(0, handlerEnd);
-    assert.ok(
-      handlerBody.includes("cleanupQuickBranch"),
-      "turn_end handler must call cleanupQuickBranch",
-    );
-  });
-
-  it("turn_end handler calls cleanupQuickBranch without arguments (uses cwd default)", () => {
-    // cleanupQuickBranch(basePath = process.cwd()) — calling without args is correct
-    // because the handler runs in the same process where handleQuick set up cwd
-    const turnEndIdx = hooksSource.indexOf('pi.on("turn_end"') !== -1
-      ? hooksSource.indexOf('pi.on("turn_end"')
-      : hooksSource.indexOf("pi.on('turn_end'");
-    assert.ok(turnEndIdx !== -1);
-
-    const rest = hooksSource.slice(turnEndIdx);
-    const handlerEnd = rest.indexOf("});");
-    const handlerBody = rest.slice(0, handlerEnd);
-
-    // Should call cleanupQuickBranch() — either bare or with no-arg form
-    assert.ok(
-      handlerBody.includes("cleanupQuickBranch("),
-      "turn_end handler invokes cleanupQuickBranch()",
-    );
+describe("quick task turn_end cleanup (#2668)", () => {
+  it("turn_end handler runs cleanupQuickBranch and removes quick-return state", async () => {
+    const repo = mkdtempSync(join(tmpdir(), "gsd-quick-cleanup-"));
+    const oldCwd = process.cwd();
+    try {
+      git(repo, ["init", "-b", "main"]);
+      git(repo, ["config", "user.email", "test@example.com"]);
+      git(repo, ["config", "user.name", "Test User"]);
+      writeFileSync(join(repo, "README.md"), "base\n");
+      git(repo, ["add", "README.md"]);
+      git(repo, ["commit", "-m", "chore: initial"]);
+      git(repo, ["checkout", "-b", "quick/Q1-test"]);
+      writeFileSync(join(repo, "quick.txt"), "quick work\n");
+      git(repo, ["add", "quick.txt"]);
+      git(repo, ["commit", "-m", "test: quick work"]);
+
+      mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
+      writeFileSync(join(repo, ".gsd", "runtime", "quick-return.json"), JSON.stringify({
+        basePath: repo,
+        originalBranch: "main",
+        quickBranch: "quick/Q1-test",
+        taskNum: 1,
+        slug: "test",
+        description: "test",
+      }) + "\n");
+
+      const handlers = new Map<string, Function>();
+      registerHooks({ on(event: string, handler: Function) { handlers.set(event, handler); } } as any, []);
+      const turnEnd = handlers.get("turn_end");
+      assert.ok(turnEnd, "turn_end hook should be registered");
+
+      process.chdir(repo);
+      await turnEnd();
+
+      assert.equal(git(repo, ["branch", "--show-current"]), "main");
+      assert.throws(() => git(repo, ["rev-parse", "--verify", "quick/Q1-test"]));
+      assert.equal(existsSync(join(repo, ".gsd", "runtime", "quick-return.json")), false);
+    } finally {
+      process.chdir(oldCwd);
+      rmSync(repo, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/reassess-default-optin.test.ts

@@ -5,7 +5,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -16,6 +16,8 @@ import {
   type DispatchAction,
   type DispatchContext,
 } from "../auto-dispatch.ts";
+import { buildPlanSlicePrompt } from "../auto-prompts.ts";
+import { registerDbTools } from "../bootstrap/db-tools.ts";
 import { resolveProfileDefaults } from "../preferences-models.ts";
 import type { GSDState } from "../types.ts";
 import type { GSDPreferences } from "../preferences.ts";
@@ -117,16 +119,28 @@ test("ADR-003 §4: burn-max profile opts into dedicated reassess-roadmap dispatc
 });
 
 test("ADR-003 §4: plan-slice prompt and MCP tool agree on reassess sliceChanges shape", () => {
-  const planSlicePrompt = readFileSync(new URL("../prompts/plan-slice.md", import.meta.url), "utf8");
-  assert.match(planSlicePrompt, /gsd_reassess_roadmap/);
-  assert.match(planSlicePrompt, /sliceChanges\.modified/);
-  assert.match(planSlicePrompt, /sliceChanges\.added/);
-  assert.match(planSlicePrompt, /sliceChanges\.removed/);
-
-  const dbToolsSource = readFileSync(new URL("../bootstrap/db-tools.ts", import.meta.url), "utf8");
-  assert.match(dbToolsSource, /name:\s*"gsd_reassess_roadmap"/);
-  assert.match(dbToolsSource, /sliceChanges:\s*Type\.Object/);
-  assert.match(dbToolsSource, /modified:\s*Type\.Array/);
-  assert.match(dbToolsSource, /added:\s*Type\.Array/);
-  assert.match(dbToolsSource, /removed:\s*Type\.Array/);
+  const tools: Record<string, any> = {};
+  registerDbTools({ registerTool(tool: any) { tools[tool.name] = tool; } } as any);
+
+  const reassessTool = tools.gsd_reassess_roadmap;
+  assert.ok(reassessTool, "gsd_reassess_roadmap should be registered");
+  const sliceChanges = reassessTool.parameters.properties.sliceChanges.properties;
+  assert.ok(sliceChanges.modified, "tool schema exposes sliceChanges.modified");
+  assert.ok(sliceChanges.added, "tool schema exposes sliceChanges.added");
+  assert.ok(sliceChanges.removed, "tool schema exposes sliceChanges.removed");
+});
+
+test("ADR-003 §4: rendered plan-slice prompt documents reassess sliceChanges shape", async () => {
+  const base = makeIsolatedBase();
+  try {
+    const msDir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(join(msDir, "M001-ROADMAP.md"), "# Roadmap\n\n## Slices\n\n- [ ] **S01: First** `risk:low` `depends:[]`\n");
+    const prompt = await buildPlanSlicePrompt("M001", "Test", "S01", "First", base, "minimal");
+    assert.match(prompt, /gsd_reassess_roadmap/);
+    assert.match(prompt, /sliceChanges\.modified/);
+    assert.match(prompt, /sliceChanges\.added/);
+    assert.match(prompt, /sliceChanges\.removed/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });