gsd-pi 2.78.1-dev.9d08d820b → 2.78.1-dev.a7b6e59b7

package/src/resources/extensions/gsd/commands-worktree.ts

@@ -0,0 +1,383 @@
+// GSD-2 — In-TUI handler for /gsd worktree commands (list, merge, clean, remove).
+//
+// Mirrors the CLI subcommands in src/worktree-cli.ts but emits results via
+// ctx.ui.notify() instead of writing colored output to stderr. Reuses the
+// same extension modules (worktree-manager, native-git-bridge, etc.) so the
+// behavior is identical to the CLI surface.
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { existsSync } from "node:fs";
+
+import { projectRoot } from "./commands/context.js";
+import {
+  listWorktrees,
+  removeWorktree,
+  mergeWorktreeToMain,
+  diffWorktreeAll,
+  diffWorktreeNumstat,
+  worktreeBranchName,
+} from "./worktree-manager.js";
+import {
+  nativeHasChanges,
+  nativeDetectMainBranch,
+  nativeCommitCountBetween,
+} from "./native-git-bridge.js";
+import { inferCommitType } from "./git-service.js";
+import { autoCommitCurrentBranch } from "./worktree.js";
+import { GSDError, GSD_GIT_ERROR } from "./errors.js";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface WorktreeStatus {
+  name: string;
+  path: string;
+  branch: string;
+  exists: boolean;
+  filesChanged: number;
+  linesAdded: number;
+  linesRemoved: number;
+  uncommitted: boolean;
+  commits: number;
+}
+
+// ─── Status helper ─────────────────────────────────────────────────────────
+
+function getStatus(basePath: string, name: string, wtPath: string): WorktreeStatus {
+  const diff = diffWorktreeAll(basePath, name);
+  const numstat = diffWorktreeNumstat(basePath, name);
+  const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const s of numstat) {
+    linesAdded += s.added;
+    linesRemoved += s.removed;
+  }
+
+  let uncommitted = false;
+  try {
+    uncommitted = existsSync(wtPath) && nativeHasChanges(wtPath);
+  } catch {
+    // native check failure → treat as clean for display purposes
+  }
+
+  let commits = 0;
+  try {
+    const main = nativeDetectMainBranch(basePath);
+    commits = nativeCommitCountBetween(basePath, main, worktreeBranchName(name));
+  } catch {
+    // commit count unavailable → leave at 0
+  }
+
+  return {
+    name,
+    path: wtPath,
+    branch: worktreeBranchName(name),
+    exists: existsSync(wtPath),
+    filesChanged,
+    linesAdded,
+    linesRemoved,
+    uncommitted,
+    commits,
+  };
+}
+
+// ─── Formatters (exported for tests) ────────────────────────────────────────
+
+export function formatWorktreeList(statuses: WorktreeStatus[]): string {
+  if (statuses.length === 0) {
+    return "No worktrees.\n\nCreate one from the CLI: gsd -w <name>";
+  }
+
+  const lines: string[] = [`Worktrees — ${statuses.length}`, ""];
+  for (const s of statuses) {
+    const badge = s.uncommitted
+      ? "(uncommitted)"
+      : s.filesChanged > 0
+        ? "(unmerged)"
+        : "(clean)";
+    lines.push(`  ${s.name} ${badge}`);
+    lines.push(`    branch  ${s.branch}`);
+    lines.push(`    path    ${s.path}`);
+    if (s.filesChanged > 0) {
+      lines.push(
+        `    diff    ${s.filesChanged} file${s.filesChanged === 1 ? "" : "s"}, +${s.linesAdded} -${s.linesRemoved}, ${s.commits} commit${s.commits === 1 ? "" : "s"}`,
+      );
+    }
+    lines.push("");
+  }
+  lines.push("Commands:");
+  lines.push("  /gsd worktree merge <name>   Merge into main and clean up");
+  lines.push("  /gsd worktree remove <name>  Remove a worktree (--force to skip safety checks)");
+  lines.push("  /gsd worktree clean          Remove all merged/empty worktrees");
+  return lines.join("\n");
+}
+
+export function formatCleanKeepReason(status: WorktreeStatus): string {
+  if (!status.exists) {
+    return "directory missing — run 'git worktree prune' to unregister";
+  }
+
+  if (status.filesChanged > 0) {
+    return `${status.filesChanged} changed file${status.filesChanged === 1 ? "" : "s"}${status.uncommitted ? ", uncommitted" : ""}`;
+  }
+
+  return "uncommitted changes";
+}
+
+// ─── Subcommand: list ───────────────────────────────────────────────────────
+
+async function handleList(ctx: ExtensionCommandContext): Promise<void> {
+  const basePath = projectRoot();
+  const worktrees = listWorktrees(basePath);
+  const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path));
+  ctx.ui.notify(formatWorktreeList(statuses), "info");
+}
+
+// ─── Subcommand: merge ──────────────────────────────────────────────────────
+
+async function handleMerge(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const basePath = projectRoot();
+  const worktrees = listWorktrees(basePath);
+  const trimmed = args.trim();
+
+  let target = trimmed;
+  if (!target) {
+    if (worktrees.length === 1) {
+      target = worktrees[0].name;
+    } else if (worktrees.length === 0) {
+      ctx.ui.notify("No worktrees to merge.", "info");
+      return;
+    } else {
+      const names = worktrees.map((w) => w.name).join(", ");
+      ctx.ui.notify(`Usage: /gsd worktree merge <name>\n\nWorktrees: ${names}`, "warning");
+      return;
+    }
+  }
+
+  const wt = worktrees.find((w) => w.name === target);
+  if (!wt) {
+    const available = worktrees.map((w) => w.name).join(", ") || "(none)";
+    ctx.ui.notify(`Worktree "${target}" not found.\n\nAvailable: ${available}`, "error");
+    return;
+  }
+
+  const status = getStatus(basePath, target, wt.path);
+  if (status.filesChanged === 0 && !status.uncommitted) {
+    try {
+      removeWorktree(basePath, target, { deleteBranch: true });
+      ctx.ui.notify(`Removed empty worktree ${target}.`, "info");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.ui.notify(
+        `Worktree partially removed: ${msg}\n\nRun 'git worktree prune' to clean up any dangling registrations.`,
+        "error",
+      );
+    }
+    return;
+  }
+
+  if (status.uncommitted) {
+    try {
+      autoCommitCurrentBranch(wt.path, "worktree-merge", target);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.ui.notify(
+        [
+          `Auto-commit before merge failed: ${msg}`,
+          "",
+          `Commit or stash changes in ${wt.path}, then re-run /gsd worktree merge ${target}.`,
+        ].join("\n"),
+        "error",
+      );
+      return;
+    }
+  }
+
+  const commitType = inferCommitType(target);
+  const mainBranch = nativeDetectMainBranch(basePath);
+  const commitMessage = `${commitType}: merge worktree ${target}\n\nGSD-Worktree: ${target}`;
+
+  try {
+    mergeWorktreeToMain(basePath, target, commitMessage);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (err instanceof GSDError && err.code === GSD_GIT_ERROR) {
+      ctx.ui.notify(
+        `Merge requires the main branch to be checked out: ${msg}\n\nSwitch to ${mainBranch} (e.g. 'git checkout ${mainBranch}'), then re-run /gsd worktree merge ${target}.`,
+        "error",
+      );
+    } else {
+      ctx.ui.notify(
+        `Merge failed: ${msg}\n\nResolve conflicts manually, then run /gsd worktree merge ${target} again.`,
+        "error",
+      );
+    }
+    return;
+  }
+
+  const successLines = [
+    `Merged ${target} → ${mainBranch}`,
+    `  ${status.filesChanged} file${status.filesChanged === 1 ? "" : "s"}, +${status.linesAdded} -${status.linesRemoved}`,
+    `  commit: ${commitMessage.split("\n")[0]}`,
+  ];
+
+  try {
+    removeWorktree(basePath, target, { deleteBranch: true });
+    ctx.ui.notify(successLines.join("\n"), "info");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const cleanupLines = [
+      ...successLines,
+      "",
+      `Cleanup failed after the merge succeeded: ${msg}`,
+      err instanceof GSDError && err.code === GSD_GIT_ERROR
+        ? `Switch to ${mainBranch} (e.g. 'git checkout ${mainBranch}'), then remove the worktree manually with /gsd worktree remove ${target} --force.`
+        : `Remove the worktree manually with /gsd worktree remove ${target} --force, or run 'git worktree prune' to clean up dangling registrations.`,
+    ];
+    ctx.ui.notify(cleanupLines.join("\n"), "warning");
+  }
+}
+
+// ─── Subcommand: clean ──────────────────────────────────────────────────────
+
+async function handleClean(ctx: ExtensionCommandContext): Promise<void> {
+  const basePath = projectRoot();
+  const worktrees = listWorktrees(basePath);
+  if (worktrees.length === 0) {
+    ctx.ui.notify("No worktrees to clean.", "info");
+    return;
+  }
+
+  const removed: string[] = [];
+  const kept: string[] = [];
+  for (const wt of worktrees) {
+    const status = getStatus(basePath, wt.name, wt.path);
+    if (status.filesChanged === 0 && !status.uncommitted) {
+      try {
+        removeWorktree(basePath, wt.name, { deleteBranch: true });
+        removed.push(wt.name);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        kept.push(`${wt.name} (failed: ${msg})`);
+      }
+    } else {
+      const reason = formatCleanKeepReason(status);
+      kept.push(`${wt.name} (${reason})`);
+    }
+  }
+
+  const lines: string[] = [`Cleaned ${removed.length} worktree${removed.length === 1 ? "" : "s"}.`];
+  if (removed.length > 0) {
+    lines.push("", "Removed:");
+    for (const n of removed) lines.push(`  ✓ ${n}`);
+  }
+  if (kept.length > 0) {
+    lines.push("", "Kept:");
+    for (const n of kept) lines.push(`  ─ ${n}`);
+  }
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+// ─── Subcommand: remove ─────────────────────────────────────────────────────
+
+async function handleRemove(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const basePath = projectRoot();
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  const force = tokens.includes("--force");
+  const name = tokens.find((t) => t !== "--force");
+  if (!name) {
+    ctx.ui.notify("Usage: /gsd worktree remove <name> [--force]", "warning");
+    return;
+  }
+
+  const worktrees = listWorktrees(basePath);
+  const wt = worktrees.find((w) => w.name === name);
+  if (!wt) {
+    const available = worktrees.map((w) => w.name).join(", ") || "(none)";
+    ctx.ui.notify(`Worktree "${name}" not found.\n\nAvailable: ${available}`, "error");
+    return;
+  }
+
+  const status = getStatus(basePath, name, wt.path);
+  if ((status.filesChanged > 0 || status.uncommitted) && !force) {
+    ctx.ui.notify(
+      [
+        `Worktree "${name}" has pending changes (${formatCleanKeepReason(status)}).`,
+        "",
+        `  Merge first:     /gsd worktree merge ${name}`,
+        `  Or force-remove: /gsd worktree remove ${name} --force`,
+      ].join("\n"),
+      "warning",
+    );
+    return;
+  }
+
+  try {
+    removeWorktree(basePath, name, { deleteBranch: true });
+    ctx.ui.notify(`Removed worktree ${name}.`, "info");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.ui.notify(
+      `Worktree partially removed: ${msg}\n\nRun 'git worktree prune' to clean up any dangling registrations.`,
+      "error",
+    );
+  }
+}
+
+// ─── Help text ──────────────────────────────────────────────────────────────
+
+const HELP_TEXT = [
+  "Usage: /gsd worktree <command> [args]",
+  "",
+  "Commands:",
+  "  list                       Show all worktrees with status",
+  "  merge [name]               Merge a worktree into main, then remove it",
+  "  remove <name> [--force]    Remove a worktree (refuses unmerged changes without --force)",
+  "  clean                      Remove all merged/empty worktrees",
+  "",
+  "The -w flag (CLI only) creates/resumes worktrees on session start:",
+  "  gsd -w               Auto-name a new worktree, or resume the only active one",
+  "  gsd -w my-feature    Create or resume a named worktree",
+].join("\n");
+
+// ─── Dispatcher ─────────────────────────────────────────────────────────────
+
+export async function handleWorktree(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const trimmed = args.trim();
+  const lowered = trimmed.toLowerCase();
+
+  if (!lowered || lowered === "help" || lowered === "--help" || lowered === "-h") {
+    ctx.ui.notify(HELP_TEXT, "info");
+    return;
+  }
+
+  try {
+    if (lowered === "list" || lowered === "ls") {
+      await handleList(ctx);
+      return;
+    }
+    if (lowered === "merge" || lowered.startsWith("merge ")) {
+      await handleMerge(trimmed.replace(/^merge\s*/i, ""), ctx);
+      return;
+    }
+    if (lowered === "clean") {
+      await handleClean(ctx);
+      return;
+    }
+    if (
+      lowered === "remove" ||
+      lowered.startsWith("remove ") ||
+      lowered === "rm" ||
+      lowered.startsWith("rm ")
+    ) {
+      const stripped = trimmed.replace(/^(remove|rm)\s*/i, "");
+      await handleRemove(stripped, ctx);
+      return;
+    }
+
+    ctx.ui.notify(`Unknown worktree command: ${trimmed}\n\n${HELP_TEXT}`, "warning");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.ui.notify(`Worktree command failed: ${msg}`, "error");
+  }
+}

package/src/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -1,3 +1,5 @@
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 Discuss milestone {{milestoneId}} ("{{milestoneTitle}}"). Identify gray areas, ask the user about them, and write `{{milestoneId}}-CONTEXT.md` in the milestone directory with the decisions. Use the **Context** output template below. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow; do not override required artifact rules.
 
 **Structured questions available: {{structuredQuestionsAvailable}}**

package/src/resources/extensions/gsd/prompts/parallel-research-slices.md

@@ -1,5 +1,7 @@
 # Parallel Slice Research
 
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 You are dispatching parallel research agents for **{{sliceCount}} slices** in milestone **{{mid}} — {{midTitle}}**.
 
 ## Slices to Research

package/src/resources/extensions/gsd/prompts/rewrite-docs.md

@@ -1,5 +1,7 @@
 You are executing GSD auto-mode.
 
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 ## UNIT: Rewrite Documents — Apply Override(s) for Milestone {{milestoneId}} ("{{milestoneTitle}}")
 
 An override was issued by the user that changes a fundamental decision or approach. Your job is to propagate this change across all active planning documents so they are internally consistent and future tasks execute correctly.

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

@@ -63,6 +63,7 @@ function makeMockSession(opts?: {
   const session = {
     active: true,
     verbose: false,
+    basePath: process.cwd(),
     cmdCtx: {
       newSession: (options?: { abortSignal?: AbortSignal }) => {
         opts?.onNewSessionStart?.(session);

package/src/resources/extensions/gsd/tests/bundled-skill-triggers.test.ts

@@ -2,12 +2,56 @@
 //
 // Guards the skill-trigger table in system-context.ts against accidental
 // regression. Every entry must have a non-empty trigger + skill, and the
-// skills added in PR #4505 must remain present.
+// skills added in PR #4505 and PR #5060 must remain present.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 import { BUNDLED_SKILL_TRIGGERS } from '../bootstrap/system-context.ts';
 
+const PR_4505_BUNDLED_SKILLS = [
+  'review',
+  'test',
+  'lint',
+  'make-interfaces-feel-better',
+  'accessibility',
+  'grill-me',
+  'design-an-interface',
+  'tdd',
+  'write-milestone-brief',
+  'decompose-into-slices',
+  'spike-wrap-up',
+  'verify-before-complete',
+  'create-mcp-server',
+  'write-docs',
+  'forensics',
+  'handoff',
+  'security-review',
+  'api-design',
+  'dependency-upgrade',
+  'observability',
+] as const;
+
+const PR_5060_BUNDLED_SKILLS = [
+  'react-best-practices',
+  'core-web-vitals',
+  'github-workflows',
+  'web-quality-audit',
+  'agent-browser',
+  'web-design-guidelines',
+  'userinterface-wiki',
+  'create-skill',
+  'create-gsd-extension',
+  'create-workflow',
+  'code-optimizer',
+] as const;
+
+function assertBundledSkillsRegistered(label: string, expectedSkills: readonly string[]): void {
+  const registered = new Set(BUNDLED_SKILL_TRIGGERS.map(e => e.skill));
+  for (const skill of expectedSkills) {
+    assert.ok(registered.has(skill), `${label}: expected bundled skill "${skill}" to be registered`);
+  }
+}
+
 test('BUNDLED_SKILL_TRIGGERS: every entry has a non-empty trigger and skill', () => {
   assert.ok(BUNDLED_SKILL_TRIGGERS.length > 0, 'table should not be empty');
   for (const { trigger, skill } of BUNDLED_SKILL_TRIGGERS) {
@@ -17,32 +61,11 @@ test('BUNDLED_SKILL_TRIGGERS: every entry has a non-empty trigger and skill', ()
 });
 
 test('BUNDLED_SKILL_TRIGGERS: PR #4505 bundled skills are present', () => {
-  const expected = [
-    'review',
-    'test',
-    'lint',
-    'make-interfaces-feel-better',
-    'accessibility',
-    'grill-me',
-    'design-an-interface',
-    'tdd',
-    'write-milestone-brief',
-    'decompose-into-slices',
-    'spike-wrap-up',
-    'verify-before-complete',
-    'create-mcp-server',
-    'write-docs',
-    'forensics',
-    'handoff',
-    'security-review',
-    'api-design',
-    'dependency-upgrade',
-    'observability',
-  ];
-  const registered = new Set(BUNDLED_SKILL_TRIGGERS.map(e => e.skill));
-  for (const skill of expected) {
-    assert.ok(registered.has(skill), `expected bundled skill "${skill}" to be registered`);
-  }
+  assertBundledSkillsRegistered('PR #4505', PR_4505_BUNDLED_SKILLS);
+});
+
+test('BUNDLED_SKILL_TRIGGERS: PR #5060 previously-unexposed skills are present', () => {
+  assertBundledSkillsRegistered('PR #5060', PR_5060_BUNDLED_SKILLS);
 });
 
 test('BUNDLED_SKILL_TRIGGERS: skill ids are unique', () => {

package/src/resources/extensions/gsd/tests/commands-worktree-clean.test.ts

@@ -0,0 +1,48 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatCleanKeepReason,
+  type WorktreeStatus,
+} from "../commands-worktree.ts";
+
+function mkStatus(over: Partial<WorktreeStatus>): WorktreeStatus {
+  const name = over.name ?? "feat-x";
+  return {
+    name,
+    path: `/repo/.gsd/worktrees/${name}`,
+    branch: `gsd/${name}`,
+    exists: true,
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    uncommitted: false,
+    commits: 0,
+    ...over,
+  };
+}
+
+test("clean keep reason shows uncommitted-only worktrees clearly", () => {
+  const reason = formatCleanKeepReason(mkStatus({ uncommitted: true }));
+  assert.equal(reason, "uncommitted changes");
+});
+
+test("clean keep reason includes uncommitted context with changed files", () => {
+  const reason = formatCleanKeepReason(mkStatus({ filesChanged: 2, uncommitted: true }));
+  assert.equal(reason, "2 changed files, uncommitted");
+});
+
+test("clean keep reason flags missing directory with prune hint", () => {
+  const reason = formatCleanKeepReason(mkStatus({ exists: false }));
+  assert.equal(reason, "directory missing — run 'git worktree prune' to unregister");
+});
+
+test("clean keep reason reports changed files without uncommitted suffix", () => {
+  const reason = formatCleanKeepReason(mkStatus({ filesChanged: 2, uncommitted: false }));
+  assert.equal(reason, "2 changed files");
+});
+
+test("clean keep reason uses singular form for a single changed file", () => {
+  const reason = formatCleanKeepReason(mkStatus({ filesChanged: 1, uncommitted: false }));
+  assert.equal(reason, "1 changed file");
+});