gsd-pi 2.34.0 → 2.35.0-dev.30eec3f

package/src/resources/extensions/gsd/tests/test-utils.ts

@@ -0,0 +1,165 @@
+/**
+ * Shared test utilities for GSD extension tests.
+ *
+ * Provides cross-platform helpers for creating temporary git repos,
+ * safe cleanup, file creation, and shell-free git operations.
+ *
+ * Usage:
+ *   import { git, makeTempRepo, cleanup, createFile } from "./test-utils.ts";
+ */
+
+import { execFileSync } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+
+/**
+ * Shell-free git helper — uses execFileSync to bypass shell entirely.
+ * No quoting issues, no Windows cmd.exe incompatibilities.
+ *
+ * @param cwd - Working directory for git command
+ * @param args - Git arguments (e.g., "add", "-A")
+ * @returns trimmed stdout
+ */
+export function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: "pipe",
+  }).trim();
+}
+
+/**
+ * Create a temporary git repository with an initial commit.
+ * Configures user.email, user.name, and core.autocrlf=false for
+ * consistent behavior across platforms.
+ *
+ * @param prefix - Optional prefix for the temp directory name
+ * @returns absolute path to the temp repo
+ */
+export function makeTempRepo(prefix: string = "gsd-test-"): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  git(dir, "init");
+  git(dir, "config", "user.email", "test@test.com");
+  git(dir, "config", "user.name", "Test");
+  git(dir, "config", "core.autocrlf", "false");
+  writeFileSync(join(dir, "README.md"), "# init\n");
+  git(dir, "add", "-A");
+  git(dir, "commit", "-m", "init");
+  git(dir, "branch", "-M", "main");
+  return dir;
+}
+
+/**
+ * Create a temporary directory (not a git repo).
+ *
+ * @param prefix - Optional prefix for the temp directory name
+ * @returns absolute path to the temp directory
+ */
+export function makeTempDir(prefix: string = "gsd-test-"): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+/**
+ * Safely clean up a temporary directory.
+ * Non-fatal — Windows may hold file descriptors briefly.
+ */
+export function cleanup(dir: string): void {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // ignore — Windows may hold file descriptors briefly after test
+  }
+}
+
+/**
+ * Create a file with intermediate directories.
+ *
+ * @param base - Base directory
+ * @param relativePath - Relative path within base (e.g., "src/index.ts")
+ * @param content - File content (defaults to empty string)
+ * @returns absolute path to the created file
+ */
+export function createFile(base: string, relativePath: string, content: string = ""): string {
+  const fullPath = join(base, relativePath);
+  mkdirSync(dirname(fullPath), { recursive: true });
+  writeFileSync(fullPath, content, "utf-8");
+  return fullPath;
+}
+
+/**
+ * Safely read a file, returning null if it doesn't exist or is a directory.
+ * Prevents EISDIR errors.
+ */
+export function safeReadFile(filePath: string): string | null {
+  try {
+    if (!existsSync(filePath)) return null;
+    if (!statSync(filePath).isFile()) return null;
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a minimal GSD milestone structure in a temp directory.
+ *
+ * @param base - Base directory (should have .gsd/ or be a temp repo)
+ * @param mid - Milestone ID (e.g., "M001")
+ * @param options - What to create
+ */
+export function writeMilestoneFixture(
+  base: string,
+  mid: string,
+  options: {
+    roadmap?: string;
+    context?: string;
+    summary?: string;
+    validation?: string;
+    slices?: Array<{
+      id: string;
+      plan?: string;
+      summary?: string;
+      uat?: string;
+    }>;
+  } = {},
+): void {
+  const milestoneDir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(milestoneDir, { recursive: true });
+
+  if (options.roadmap) {
+    writeFileSync(join(milestoneDir, `${mid}-ROADMAP.md`), options.roadmap);
+  }
+  if (options.context) {
+    writeFileSync(join(milestoneDir, `${mid}-CONTEXT.md`), options.context);
+  }
+  if (options.summary) {
+    writeFileSync(join(milestoneDir, `${mid}-SUMMARY.md`), options.summary);
+  }
+  if (options.validation) {
+    writeFileSync(join(milestoneDir, `${mid}-VALIDATION.md`), options.validation);
+  }
+  if (options.slices) {
+    for (const slice of options.slices) {
+      const sliceDir = join(milestoneDir, "slices", slice.id);
+      mkdirSync(sliceDir, { recursive: true });
+      if (slice.plan) {
+        writeFileSync(join(sliceDir, `${slice.id}-PLAN.md`), slice.plan);
+      }
+      if (slice.summary) {
+        writeFileSync(join(sliceDir, `${slice.id}-SUMMARY.md`), slice.summary);
+      }
+      if (slice.uat) {
+        writeFileSync(join(sliceDir, `${slice.id}-UAT.md`), slice.uat);
+      }
+    }
+  }
+}

package/src/resources/extensions/gsd/tests/validate-directory.test.ts

@@ -101,6 +101,21 @@ test("validateDirectory: subdirectory of home is NOT blocked", () => {
   }
 });
 
+// Regression test for #1317: GSD worktree inside $HOME must not be blocked even
+// when the resolved project root equals $HOME (e.g. home dir is a git repo).
+test("validateDirectory: GSD worktree path nested under home is NOT blocked (#1317)", () => {
+  const worktreePath = join(homedir(), ".gsd", "worktrees", "M001");
+  mkdirSync(worktreePath, { recursive: true });
+  try {
+    // The worktree CWD itself is a valid location — it must pass.
+    const result = validateDirectory(worktreePath);
+    assert.equal(result.safe, true, "GSD worktree path should be safe to run in");
+    assert.equal(result.severity, "ok");
+  } finally {
+    rmSync(join(homedir(), ".gsd", "worktrees", "M001"), { recursive: true, force: true });
+  }
+});
+
 // ─── Temp directory root ─────────────────────────────────────────────────────────
 
 test("validateDirectory: temp directory root is blocked", () => {

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -196,6 +196,7 @@ test("dispatch rule matches validating-milestone phase", async () => {
   try {
     // Set up minimal milestone structure for the prompt builder
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
     const ctx: DispatchContext = {
       basePath: base,
@@ -231,6 +232,7 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   const base = makeTmpBase();
   try {
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
     const ctx: DispatchContext = {
       basePath: base,

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -19,6 +19,7 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
 import { syncProjectRootToWorktree } from '../auto-worktree-sync.ts';
+import { syncGsdStateToWorktree } from '../auto-worktree.ts';
 import { createTestContext } from './test-helpers.ts';
 
 const { assertTrue, report } = createTestContext();
@@ -148,6 +149,37 @@ async function main(): Promise<void> {
     assertTrue(true, 'no crash on missing directories');
   }
 
+  // ─── 7. milestones/ directory created in worktree when missing ────────
+  console.log('\n=== 7. milestones/ directory created in worktree when missing ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-wt-'));
+
+    try {
+      // Worktree has .gsd/ but NO milestones/ subdirectory
+      mkdirSync(join(wtBase, '.gsd'), { recursive: true });
+
+      // Main repo has M001
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001 Context');
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# M001 Roadmap');
+
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones')), 'milestones/ missing before sync');
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones')), 'milestones/ created in worktree');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001')), 'M001 synced to worktree');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md')), 'M001 CONTEXT synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')), 'M001 ROADMAP synced');
+      assertTrue(result.synced.length > 0, 'sync reported files');
+    } finally {
+      cleanup(mainBase);
+      rmSync(wtBase, { recursive: true, force: true });
+    }
+  }
+
   report();
 }
 

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

@@ -13,6 +13,8 @@
  * `process.chdir()` internally — this class MUST NOT double-chdir.
  */
 
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
 import type { AutoSession } from "./auto/session.js";
 import { debugLog } from "./debug-logger.js";
 
@@ -372,6 +374,15 @@ export class WorktreeResolver {
       });
       ctx.notify(`Milestone merge failed: ${msg}`, "warning");
 
+      // Clean up stale merge state left by failed squash-merge (#1389)
+      try {
+        const gitDir = join(originalBase || this.s.basePath, ".git");
+        for (const f of ["SQUASH_MSG", "MERGE_HEAD", "MERGE_MSG"]) {
+          const p = join(gitDir, f);
+          if (existsSync(p)) unlinkSync(p);
+        }
+      } catch { /* best-effort */ }
+
       // Error recovery: always restore to project root
       if (originalBase) {
         try {

package/src/resources/extensions/mcp-client/index.ts

@@ -354,7 +354,8 @@ export default function (pi: ExtensionAPI) {
 				description: "Tool name on that server, e.g. 'railway_list_projects'",
 			}),
 			args: Type.Optional(
-				Type.Record(Type.String(), Type.Unknown(), {
+				Type.Object({}, {
+					additionalProperties: true,
 					description:
 						"Tool arguments as key-value pairs matching the tool's input schema",
 				}),

package/src/resources/extensions/remote-questions/remote-command.ts

@@ -4,12 +4,12 @@
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { AuthStorage } from "@gsd/pi-coding-agent";
-import { CURSOR_MARKER, Editor, type EditorTheme, Key, matchesKey, truncateToWidth } from "@gsd/pi-tui";
+import { Editor, type EditorTheme, Key, matchesKey, truncateToWidth } from "@gsd/pi-tui";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getGlobalGSDPreferencesPath, loadEffectiveGSDPreferences } from "../gsd/preferences.js";
 import { getRemoteConfigStatus, isValidChannelId, resolveRemoteConfig } from "./config.js";
-import { sanitizeError } from "../shared/sanitize.js";
+import { maskEditorLine, sanitizeError } from "../shared/mod.js";
 import { getLatestPromptSummary } from "./status.js";
 
 export async function handleRemote(
@@ -353,27 +353,6 @@ function removeRemoteQuestionsConfig(): void {
   writeFileSync(prefsPath, next, "utf-8");
 }
 
-function maskEditorLine(line: string): string {
-  let output = "";
-  let i = 0;
-  while (i < line.length) {
-    if (line.startsWith(CURSOR_MARKER, i)) {
-      output += CURSOR_MARKER;
-      i += CURSOR_MARKER.length;
-      continue;
-    }
-    const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
-    if (ansiMatch) {
-      output += ansiMatch[0];
-      i += ansiMatch[0].length;
-      continue;
-    }
-    output += line[i] === " " ? " " : "*";
-    i += 1;
-  }
-  return output;
-}
-
 async function promptMaskedInput(ctx: ExtensionCommandContext, label: string, hint: string): Promise<string | null> {
   if (!ctx.hasUI) return null;
   return ctx.ui.custom<string | null>((tui: any, theme: any, _kb: any, done: (r: string | null) => void) => {

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

@@ -28,6 +28,6 @@ export { showInterviewRound } from "./interview-ui.js";
 export type { Question, QuestionOption, RoundResult } from "./interview-ui.js";
 export { showNextAction } from "./next-action-ui.js";
 export { showConfirm } from "./confirm-ui.js";
-export { sanitizeError } from "./sanitize.js";
+export { sanitizeError, maskEditorLine } from "./sanitize.js";
 export { formatDateShort, truncateWithEllipsis } from "./format-utils.js";
 export { splitFrontmatter, parseFrontmatterMap } from "./frontmatter.js";

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

@@ -1,7 +1,10 @@
 /**
  * Sanitize error messages by redacting token-like strings before surfacing.
+ * Also provides maskEditorLine for masking sensitive TUI editor input.
  */
 
+import { CURSOR_MARKER } from "@gsd/pi-tui";
+
 const TOKEN_PATTERNS = [
   /xoxb-[A-Za-z0-9\-]+/g,    // Slack bot tokens
   /xoxp-[A-Za-z0-9\-]+/g,    // Slack user tokens
@@ -17,3 +20,36 @@ export function sanitizeError(msg: string): string {
   }
   return sanitized;
 }
+
+/**
+ * Replace editor visible text with masked characters while preserving
+ * ANSI cursor/sequencer codes. Keeps border/metadata lines readable.
+ */
+export function maskEditorLine(line: string): string {
+  if (line.startsWith("─")) {
+    return line;
+  }
+
+  let output = "";
+  let i = 0;
+  while (i < line.length) {
+    if (line.startsWith(CURSOR_MARKER, i)) {
+      output += CURSOR_MARKER;
+      i += CURSOR_MARKER.length;
+      continue;
+    }
+
+    const ansiMatch = /^\x1b\[[0-9;]*m/.exec(line.slice(i));
+    if (ansiMatch) {
+      output += ansiMatch[0];
+      i += ansiMatch[0].length;
+      continue;
+    }
+
+    const ch = line[i] as string;
+    output += ch === " " ? " " : "*";
+    i += 1;
+  }
+
+  return output;
+}

package/src/resources/extensions/subagent/index.ts

@@ -23,6 +23,7 @@ import { StringEnum } from "@gsd/pi-ai";
 import { type ExtensionAPI, getMarkdownTheme } from "@gsd/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { formatTokenCount } from "../shared/mod.js";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
 import {
 	type IsolationEnvironment,
@@ -76,13 +77,6 @@ async function stopLiveSubagents(): Promise<void> {
 	}
 }
 
-function formatTokens(count: number): string {
-	if (count < 1000) return count.toString();
-	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
-	if (count < 1000000) return `${Math.round(count / 1000)}k`;
-	return `${(count / 1000000).toFixed(1)}M`;
-}
-
 function formatUsageStats(
 	usage: {
 		input: number;
@@ -97,13 +91,13 @@ function formatUsageStats(
 ): string {
 	const parts: string[] = [];
 	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
-	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
+	if (usage.input) parts.push(`↑${formatTokenCount(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokenCount(usage.output)}`);
+	if (usage.cacheRead) parts.push(`R${formatTokenCount(usage.cacheRead)}`);
+	if (usage.cacheWrite) parts.push(`W${formatTokenCount(usage.cacheWrite)}`);
 	if (usage.cost) parts.push(`$${(Number(usage.cost) || 0).toFixed(4)}`);
 	if (usage.contextTokens && usage.contextTokens > 0) {
-		parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
+		parts.push(`ctx:${formatTokenCount(usage.contextTokens)}`);
 	}
 	if (model) parts.push(model);
 	return parts.join(" ");

package/src/resources/skills/create-gsd-extension/references/events-reference.md

@@ -61,10 +61,10 @@ pi.on("tool_call", async (event, ctx) => {
 
 **tool_result** — Fired after tool executes. Can modify result. Handlers chain like middleware.
 ```typescript
-import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 pi.on("tool_result", async (event, ctx) => {
-  if (isBashToolResult(event)) {
+  if (isToolResultEventType("bash", event)) {
     // event.details is typed as BashToolDetails
   }
   // Return partial patch: { content, details, isError }
@@ -105,7 +105,7 @@ pi.on("model_select", async (event, ctx) => {
 Built-in type guards for tool events:
 
 ```typescript
-import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isToolResultEventType } from "@mariozechner/pi-coding-agent";
 
 // Tool calls — narrows event.input type
 if (isToolCallEventType("bash", event)) { /* event.input: { command, timeout? } */ }
@@ -114,7 +114,7 @@ if (isToolCallEventType("write", event)) { /* event.input: { path, content } */
 if (isToolCallEventType("edit", event)) { /* event.input: { path, oldText, newText } */ }
 
 // Tool results — narrows event.details type
-if (isBashToolResult(event)) { /* event.details: BashToolDetails */ }
+if (isToolResultEventType("bash", event)) { /* event.details: BashToolDetails */ }
 ```
 
 For custom tools, export your input type and use explicit type params: