gsd-pi 2.82.0 → 3.0.0-dev.2e8b124f7

package/src/resources/extensions/gsd/tests/autocomplete-regressions-1675.test.ts

@@ -120,3 +120,24 @@ test("bare /gsd skip shows usage and does not fall through to unknown-command wa
   );
 });
 
+test("direct loop verbs do not fall through to unknown-command warning", async () => {
+  const loopVerbs = [
+    "research-milestone",
+    "research-slice",
+    "plan-milestone",
+    "plan-slice",
+    "execute-task",
+    "complete-slice",
+    "validate-milestone",
+    "complete-milestone",
+  ];
+
+  for (const verb of loopVerbs) {
+    const ctx = createMockCtx();
+    await handleGSDCommand(verb, ctx as any, {} as any);
+    assert.ok(
+      !ctx.notifications.some((n) => n.message.startsWith(`Unknown: /gsd ${verb}`)),
+      `${verb} should be recognized as a valid /gsd command alias`,
+    );
+  }
+});

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

@@ -0,0 +1,89 @@
+// GSD-2 + /gsd brief command behavior tests
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { GSD_COMMAND_DESCRIPTION, getGsdArgumentCompletions } from "../commands/catalog.ts";
+import { handleCoreCommand, showHelp } from "../commands/handlers/core.ts";
+import { VISUAL_BRIEF_USAGE } from "../../visual-brief/prompts.ts";
+
+function createMockCtx() {
+  const notifications: { message: string; level: string }[] = [];
+  return {
+    notifications,
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+      custom: async () => undefined,
+    },
+  };
+}
+
+function createMockPi() {
+  const sentMessages: string[] = [];
+  return {
+    sentMessages,
+    sendUserMessage(content: string) {
+      sentMessages.push(content);
+    },
+  };
+}
+
+test("/gsd brief appears in the command description and top-level completions", () => {
+  assert.match(GSD_COMMAND_DESCRIPTION, /brief/);
+
+  const completions = getGsdArgumentCompletions("br");
+  const entry = completions.find((completion) => completion.value === "brief");
+
+  assert.ok(entry, "brief should appear in top-level completions");
+  assert.match(entry.description, /visual HTML brief/i);
+});
+
+test("/gsd brief exposes Visual Brief mode completions", () => {
+  const completions = getGsdArgumentCompletions("brief d");
+
+  assert.ok(
+    completions.some((completion) => completion.value === "brief diagram"),
+    "diagram should be suggested as a /gsd brief mode",
+  );
+  assert.ok(
+    getGsdArgumentCompletions("brief ").some((completion) => completion.value === "brief diff"),
+    "diff should be suggested after /gsd brief",
+  );
+});
+
+test("/gsd brief sends a Visual Brief prompt for valid args", async () => {
+  const ctx = createMockCtx();
+  const pi = createMockPi();
+
+  const handled = await handleCoreCommand("brief diagram extension loading lifecycle", ctx as any, pi as any);
+
+  assert.equal(handled, true);
+  assert.equal(ctx.notifications.length, 0);
+  assert.equal(pi.sentMessages.length, 1);
+  assert.match(pi.sentMessages[0], /Mode: diagram/);
+  assert.match(pi.sentMessages[0], /Subject: extension loading lifecycle/);
+  assert.match(pi.sentMessages[0], /Output directory:/);
+});
+
+test("/gsd brief reports usage for empty args instead of sending a prompt", async () => {
+  const ctx = createMockCtx();
+  const pi = createMockPi();
+
+  const handled = await handleCoreCommand("brief", ctx as any, pi as any);
+
+  assert.equal(handled, true);
+  assert.equal(pi.sentMessages.length, 0);
+  assert.deepEqual(ctx.notifications, [{ message: VISUAL_BRIEF_USAGE, level: "info" }]);
+});
+
+test("/gsd help full lists brief separately from visualize", () => {
+  const ctx = createMockCtx();
+
+  showHelp(ctx as any, "full");
+
+  const help = ctx.notifications.at(0)?.message ?? "";
+  assert.match(help, /\/gsd visualize\s+Interactive 10-tab TUI/);
+  assert.match(help, /\/gsd brief <mode>\s+Generate a visual HTML brief/);
+});

package/src/resources/extensions/gsd/tests/browser-tools-compatibility-declarations.test.ts

@@ -0,0 +1,62 @@
+// GSD-2 — ADR-005 Phase 2: Verify browser tool compatibility declarations.
+//
+// Locks in the declarations that always-image-producing browser tools
+// (browser_screenshot, browser_zoom_region) carry `producesImages: true` so
+// the model-router filters them out on providers without imageToolResults
+// (OpenAI completions/responses, Azure, Mistral, Ollama). Conditional-image
+// browser tools (navigation, forms, refs, intent, interaction) must NOT
+// declare producesImages — they only attach error screenshots and filtering
+// them would lose the whole tool surface for OpenAI users.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+
+import { registerScreenshotTools } from "../../browser-tools/tools/screenshot.ts";
+import { registerZoomTools } from "../../browser-tools/tools/zoom.ts";
+
+interface CapturedToolDef {
+  name: string;
+  compatibility?: { producesImages?: boolean; schemaFeatures?: string[] };
+}
+
+function makeCapturingPi(): { pi: ExtensionAPI; tools: CapturedToolDef[] } {
+  const tools: CapturedToolDef[] = [];
+  const pi = {
+    registerTool(def: CapturedToolDef): void {
+      tools.push({ name: def.name, compatibility: def.compatibility });
+    },
+  } as unknown as ExtensionAPI;
+  return { pi, tools };
+}
+
+// Browser tool registration functions accept a `deps` object. None of the
+// declarations under test reach for these deps at registration time — they
+// only run inside execute(), which we never invoke. A bare object satisfies
+// the type signature.
+const stubDeps = {} as Parameters<typeof registerScreenshotTools>[1];
+
+test("browser_screenshot declares producesImages: true", () => {
+  const { pi, tools } = makeCapturingPi();
+  registerScreenshotTools(pi, stubDeps);
+  const screenshot = tools.find((t) => t.name === "browser_screenshot");
+  assert.ok(screenshot, "browser_screenshot should be registered");
+  assert.equal(
+    screenshot.compatibility?.producesImages,
+    true,
+    "browser_screenshot must declare producesImages so it is filtered on providers without imageToolResults",
+  );
+});
+
+test("browser_zoom_region declares producesImages: true", () => {
+  const { pi, tools } = makeCapturingPi();
+  registerZoomTools(pi, stubDeps);
+  const zoom = tools.find((t) => t.name === "browser_zoom_region");
+  assert.ok(zoom, "browser_zoom_region should be registered");
+  assert.equal(
+    zoom.compatibility?.producesImages,
+    true,
+    "browser_zoom_region must declare producesImages so it is filtered on providers without imageToolResults",
+  );
+});

package/src/resources/extensions/gsd/tests/checkout-branch-stash-guard.test.ts

@@ -0,0 +1,87 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { checkoutBranchWithStashGuard } from "../auto-worktree.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  });
+}
+
+function createRepo(t: { after: (fn: () => void) => void }): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "checkout-stash-guard-")));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  git(["init"], dir);
+  git(["config", "user.email", "test@example.com"], dir);
+  git(["config", "user.name", "Test User"], dir);
+  writeFileSync(join(dir, "note.txt"), "base\n");
+  git(["add", "note.txt"], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  return dir;
+}
+
+describe("checkoutBranchWithStashGuard", () => {
+  test("restores dirty working tree after successful checkout", (t) => {
+    const repo = createRepo(t);
+    git(["checkout", "-b", "milestone/M001"], repo);
+    git(["checkout", "main"], repo);
+
+    writeFileSync(join(repo, "note.txt"), "dirty\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M001", "test-success");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M001");
+    const content = git(["show", "HEAD:note.txt"], repo).trim();
+    assert.equal(content, "base");
+    const wtContent = readFileSync(join(repo, "note.txt"), "utf8");
+    assert.equal(wtContent, "dirty\n");
+    const status = git(["status", "--porcelain"], repo);
+    assert.match(status, /note\.txt/);
+  });
+
+  test("restores dirty working tree when checkout throws", (t) => {
+    const repo = createRepo(t);
+    writeFileSync(join(repo, "note.txt"), "dirty\n");
+
+    assert.throws(
+      () => checkoutBranchWithStashGuard(repo, "milestone/DOES-NOT-EXIST", "test-failure"),
+    );
+
+    const status = git(["status", "--porcelain"], repo);
+    assert.match(status, /note\.txt/);
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
+
+  test("surfaces distinct error when checkout succeeds but stash pop conflicts", (t) => {
+    const repo = createRepo(t);
+    // Branch B has a divergent version of note.txt so popping a stash made
+    // against main will conflict after the checkout to B.
+    git(["checkout", "-b", "milestone/B"], repo);
+    writeFileSync(join(repo, "note.txt"), "B-version\n");
+    git(["add", "note.txt"], repo);
+    git(["commit", "-m", "B"], repo);
+    git(["checkout", "main"], repo);
+
+    writeFileSync(join(repo, "note.txt"), "local\n");
+
+    assert.throws(
+      () => checkoutBranchWithStashGuard(repo, "milestone/B", "test-pop-failure"),
+      /checkout to 'milestone\/B' succeeded but stash restore failed/,
+    );
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/B");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.match(stashList, /gsd: checkout stash/);
+  });
+});

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -8,7 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -208,8 +208,8 @@ test("postflightPopStash conflict warning names the exact stash ref", () => {
     assert.match(postflight.message, /failed after merge of milestone M005C/);
 
     const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
-    assert.match(warning, /git stash pop stash@\{\d+\}/);
     assert.match(warning, /git stash apply stash@\{\d+\}/);
+    assert.match(warning, /git stash drop stash@\{\d+\}/);
   } finally {
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
@@ -279,3 +279,108 @@ test("postflightPopStash falls back to milestone marker prefix when exact marker
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
 });
+
+test("postflightPopStash preserves stash when untracked collision differs from merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local preflight test\n");
+    const preflight = preflightCleanRoot(repo, "M009", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    const postflight = postflightPopStash(repo, "M009", preflight.stashMarker, (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    assert.equal(postflight.needsManualRecovery, false, "different already-present untracked files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-preserved");
+    assert.deepEqual(postflight.collidedPaths, ["tests.txt"]);
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "merged milestone test\n");
+    assert.equal(run("git status --porcelain", repo), "", "merged file must stay clean");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash backup must be preserved");
+    assert.ok(
+      notifications.some((n) => n.level === "warning" && n.msg.includes("preserving")),
+      "user must be warned that the stash was preserved as backup",
+    );
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash drops stash when untracked collision is identical to merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    const preflight = preflightCleanRoot(repo, "M010", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add same test"', repo);
+
+    const postflight = postflightPopStash(repo, "M010", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, false, "identical already-present files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-dropped");
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "same test content\n");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(!stashList.includes(preflight.stashMarker ?? ""), "identical stash must be dropped");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery for mixed tracked changes and untracked collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# local tracked work\n");
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M011", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash mixed changes");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M011", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "tracked stash payload must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "mixed stash must be preserved");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery when an untracked stash path is missing after collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    writeFileSync(join(repo, "other-tests.txt"), "other local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M012", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked files");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add one merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M012", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "partial untracked restores must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    assert.equal(existsSync(join(repo, "other-tests.txt")), true, "git may partially restore the non-colliding path");
+    assert.match(run("git status --porcelain", repo), /\?\? other-tests\.txt/, "partial restore must leave manual recovery visible");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash must remain for manual recovery");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -7,9 +7,10 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
 
 import {
   _getPendingAutoStart,
@@ -17,6 +18,17 @@ import {
   setPendingAutoStart,
 } from "../guided-flow.ts";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  };
+}
+
 afterEach(() => {
   clearPendingAutoStart();
 });
@@ -28,7 +40,7 @@ describe("clear stale pending auto-start (#3667)", () => {
     mkdirSync(join(base, ".gsd"), { recursive: true });
     const before = Date.now();
 
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry);
@@ -41,8 +53,24 @@ describe("clear stale pending auto-start (#3667)", () => {
     t.after(() => rmSync(base, { recursive: true, force: true }));
     mkdirSync(join(base, ".gsd"), { recursive: true });
 
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001", createdAt: 123 });
+    setPendingAutoStart(base, { ...pendingInput(base, "M001"), createdAt: 123 });
 
     assert.equal(_getPendingAutoStart(base)?.createdAt, 123);
   });
+
+  test("guided-flow clears stale pending entry when discuss already completed", () => {
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes('const milestoneHasRoadmap = !!resolveMilestoneFile(basePath, entry.milestoneId, "ROADMAP");'),
+      "pending auto-start gate must check ROADMAP presence for completed discuss sessions",
+    );
+    assert.ok(
+      source.includes('milestoneRow.status !== "queued"'),
+      "pending auto-start gate must require non-queued DB milestone status before clearing",
+    );
+    assert.ok(
+      source.includes("if (discussPlanComplete)"),
+      "pending auto-start gate must clear stale map entries for completed discussions",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/closeout-git-deferral.test.ts

@@ -0,0 +1,16 @@
+// Project/App: GSD-2
+// File Purpose: Tests closeout git action deferral policy for auto-mode units.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { shouldDeferCloseoutGitAction } from "../auto-post-unit.ts";
+
+test("execute-task defers closeout git action until verification passes", () => {
+  assert.equal(shouldDeferCloseoutGitAction("execute-task"), true);
+});
+
+test("non execute-task units keep pre-verification closeout git action", () => {
+  assert.equal(shouldDeferCloseoutGitAction("plan-slice"), false);
+  assert.equal(shouldDeferCloseoutGitAction("complete-slice"), false);
+});