gsd-pi 2.4.0 → 2.5.1

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

@@ -1,40 +1,50 @@
 /**
- * GSD Slice Branch Management
+ * GSD Slice Branch Management — Thin Facade
  *
  * Simple branch-per-slice workflow. No worktrees, no registry.
  * Runtime state (metrics, activity, lock, STATE.md) is gitignored
  * so branch switches are clean.
  *
+ * All git-mutation functions delegate to GitServiceImpl from git-service.ts.
+ * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
+ * SLICE_BRANCH_RE) remain standalone.
+ *
  * Flow:
  *   1. ensureSliceBranch() — create + checkout slice branch
  *   2. agent does work, commits
  *   3. mergeSliceToMain() — checkout main, squash-merge, delete branch
  */
 
-import { existsSync } from "node:fs";
-import { execSync } from "node:child_process";
 import { sep } from "node:path";
 
-export interface MergeSliceResult {
-  branch: string;
-  mergedCommitMessage: string;
-  deletedBranch: boolean;
-}
+import { GitServiceImpl } from "./git-service.ts";
+import { loadEffectiveGSDPreferences } from "./preferences.ts";
 
-function runGit(basePath: string, args: string[], options: { allowFailure?: boolean } = {}): string {
-  try {
-    return execSync(`git ${args.join(" ")}`, {
-      cwd: basePath,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf-8",
-    }).trim();
-  } catch (error) {
-    if (options.allowFailure) return "";
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`git ${args.join(" ")} failed in ${basePath}: ${message}`);
+// Re-export MergeSliceResult from the canonical source (D014 — type-only re-export)
+export type { MergeSliceResult } from "./git-service.ts";
+
+// ─── Lazy GitServiceImpl Cache ─────────────────────────────────────────────
+
+let cachedService: GitServiceImpl | null = null;
+let cachedBasePath: string | null = null;
+
+/**
+ * Get or create a GitServiceImpl for the given basePath.
+ * Resets the cache if basePath changes between calls.
+ * Lazy construction: only instantiated at call-time, never at module-evaluation.
+ */
+function getService(basePath: string): GitServiceImpl {
+  if (cachedService === null || cachedBasePath !== basePath) {
+    const loaded = loadEffectiveGSDPreferences();
+    const gitPrefs = loaded?.preferences?.git ?? {};
+    cachedService = new GitServiceImpl(basePath, gitPrefs);
+    cachedBasePath = basePath;
   }
+  return cachedService;
 }
 
+// ─── Pure Utility Functions (unchanged) ────────────────────────────────────
+
 /**
  * Detect the active worktree name from the current working directory.
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
@@ -86,6 +96,8 @@ export function parseSliceBranch(branchName: string): {
   };
 }
 
+// ─── Git-Mutation Functions (delegate to GitServiceImpl) ───────────────────
+
 /**
  * Get the "main" branch for GSD slice operations.
  *
@@ -98,46 +110,11 @@ export function parseSliceBranch(branchName: string): {
  * /worktree merge.
  */
 export function getMainBranch(basePath: string): string {
-  // When inside a worktree, slice branches should merge into the worktree's
-  // own branch (worktree/<name>), not main — main is checked out by the
-  // parent working tree and git would refuse the checkout.
-  const wtName = detectWorktreeName(basePath);
-  if (wtName) {
-    const wtBranch = `worktree/${wtName}`;
-    // Verify the branch exists (it should — createWorktree made it)
-    const exists = runGit(basePath, ["show-ref", "--verify", `refs/heads/${wtBranch}`], { allowFailure: true });
-    if (exists) return wtBranch;
-    // Worktree branch is gone — return current branch rather than falling
-    // through to main/master which would cause a checkout conflict
-    return runGit(basePath, ["branch", "--show-current"]);
-  }
-
-  const symbolic = runGit(basePath, ["symbolic-ref", "refs/remotes/origin/HEAD"], { allowFailure: true });
-  if (symbolic) {
-    const match = symbolic.match(/refs\/remotes\/origin\/(.+)$/);
-    if (match) return match[1]!;
-  }
-
-  const mainExists = runGit(basePath, ["show-ref", "--verify", "refs/heads/main"], { allowFailure: true });
-  if (mainExists) return "main";
-
-  const masterExists = runGit(basePath, ["show-ref", "--verify", "refs/heads/master"], { allowFailure: true });
-  if (masterExists) return "master";
-
-  return runGit(basePath, ["branch", "--show-current"]);
+  return getService(basePath).getMainBranch();
 }
 
 export function getCurrentBranch(basePath: string): string {
-  return runGit(basePath, ["branch", "--show-current"]);
-}
-
-function branchExists(basePath: string, branch: string): boolean {
-  try {
-    runGit(basePath, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
-    return true;
-  } catch {
-    return false;
-  }
+  return getService(basePath).getCurrentBranch();
 }
 
 /**
@@ -150,49 +127,7 @@ function branchExists(basePath: string, branch: string): boolean {
  * Returns true if the branch was newly created.
  */
 export function ensureSliceBranch(basePath: string, milestoneId: string, sliceId: string): boolean {
-  const wtName = detectWorktreeName(basePath);
-  const branch = getSliceBranchName(milestoneId, sliceId, wtName);
-  const current = getCurrentBranch(basePath);
-
-  if (current === branch) return false;
-
-  let created = false;
-
-  if (!branchExists(basePath, branch)) {
-    // Branch from the current branch when it's a normal working branch
-    // (not itself a slice branch). This ensures the new slice branch
-    // inherits planning artifacts that may only exist on the working
-    // branch and haven't been merged to main yet.
-    // If we're already on a slice branch (e.g. creating S02 while S01
-    // wasn't merged yet), fall back to main to avoid chaining slice branches.
-    const mainBranch = getMainBranch(basePath);
-    const base = SLICE_BRANCH_RE.test(current) ? mainBranch : current;
-    runGit(basePath, ["branch", branch, base]);
-    created = true;
-  } else {
-    // Check if the branch is already checked out in another worktree
-    const worktreeList = runGit(basePath, ["worktree", "list", "--porcelain"]);
-    if (worktreeList.includes(`branch refs/heads/${branch}`)) {
-      throw new Error(
-        `Branch "${branch}" is already in use by another worktree. ` +
-        `Remove that worktree first, or switch it to a different branch.`,
-      );
-    }
-  }
-
-  // Auto-commit dirty files before checkout to prevent "would be overwritten" errors.
-  // This handles cases where doctor, STATE.md rebuild, or agent work left uncommitted changes.
-  const status = runGit(basePath, ["status", "--short"]);
-  if (status.trim()) {
-    runGit(basePath, ["add", "-A"]);
-    const staged = runGit(basePath, ["diff", "--cached", "--stat"]);
-    if (staged.trim()) {
-      runGit(basePath, ["commit", "-m", `"chore: auto-commit before switching to ${branch}"`]);
-    }
-  }
-
-  runGit(basePath, ["checkout", branch]);
-  return created;
+  return getService(basePath).ensureSliceBranch(milestoneId, sliceId);
 }
 
 /**
@@ -202,31 +137,14 @@ export function ensureSliceBranch(basePath: string, milestoneId: string, sliceId
 export function autoCommitCurrentBranch(
   basePath: string, unitType: string, unitId: string,
 ): string | null {
-  const status = runGit(basePath, ["status", "--short"]);
-  if (!status.trim()) return null;
-
-  runGit(basePath, ["add", "-A"]);
-
-  const staged = runGit(basePath, ["diff", "--cached", "--stat"]);
-  if (!staged.trim()) return null;
-
-  const message = `chore(${unitId}): auto-commit after ${unitType}`;
-  runGit(basePath, ["commit", "-m", JSON.stringify(message)]);
-  return message;
+  return getService(basePath).autoCommit(unitType, unitId);
 }
 
 /**
  * Switch to main, auto-committing any dirty files on the current branch first.
  */
 export function switchToMain(basePath: string): void {
-  const mainBranch = getMainBranch(basePath);
-  const current = getCurrentBranch(basePath);
-  if (current === mainBranch) return;
-
-  // Auto-commit if dirty
-  autoCommitCurrentBranch(basePath, "pre-switch", current);
-
-  runGit(basePath, ["checkout", mainBranch]);
+  getService(basePath).switchToMain();
 }
 
 /**
@@ -236,37 +154,12 @@ export function switchToMain(basePath: string): void {
  */
 export function mergeSliceToMain(
   basePath: string, milestoneId: string, sliceId: string, sliceTitle: string,
-): MergeSliceResult {
-  const wtName = detectWorktreeName(basePath);
-  const branch = getSliceBranchName(milestoneId, sliceId, wtName);
-  const mainBranch = getMainBranch(basePath);
-
-  const current = getCurrentBranch(basePath);
-  if (current !== mainBranch) {
-    throw new Error(`Expected to be on ${mainBranch}, found ${current}`);
-  }
-
-  if (!branchExists(basePath, branch)) {
-    throw new Error(`Slice branch ${branch} does not exist`);
-  }
-
-  const ahead = runGit(basePath, ["rev-list", "--count", `${mainBranch}..${branch}`]);
-  if (Number(ahead) <= 0) {
-    throw new Error(`Slice branch ${branch} has no commits ahead of ${mainBranch}`);
-  }
-
-  runGit(basePath, ["merge", "--squash", branch]);
-  const mergedCommitMessage = `feat(${milestoneId}/${sliceId}): ${sliceTitle}`;
-  runGit(basePath, ["commit", "-m", JSON.stringify(mergedCommitMessage)]);
-  runGit(basePath, ["branch", "-D", branch]);
-
-  return {
-    branch,
-    mergedCommitMessage,
-    deletedBranch: true,
-  };
+): import("./git-service.ts").MergeSliceResult {
+  return getService(basePath).mergeSliceToMain(milestoneId, sliceId, sliceTitle);
 }
 
+// ─── Query Functions (delegate to GitServiceImpl) ──────────────────────────
+
 /**
  * Check if we're currently on a slice branch (not main).
  * Handles both plain (gsd/M001/S01) and worktree-namespaced (gsd/wt/M001/S01) branches.

package/src/resources/extensions/search-the-web/index.ts

@@ -1,5 +1,5 @@
 /**
- * Web Search Extension v3
+ * Web Search Extension v4
  *
  * Provides three tools for grounding the agent in real-world web content:
  *
@@ -15,6 +15,15 @@
  *                      Returns pre-extracted, relevance-scored page content.
  *                      Best when you need content, not just links.
  *
+ * v4: Native Anthropic web search
+ * - When using an Anthropic provider, injects the native `web_search_20250305`
+ *   server-side tool via `before_provider_request`. This eliminates the need for
+ *   a BRAVE_API_KEY when using Anthropic models — search is billed through the
+ *   existing Anthropic API key ($0.01/search).
+ * - Custom Brave-based tools (search-the-web, search_and_read) are disabled when
+ *   Anthropic + no BRAVE_API_KEY to avoid confusing the LLM with broken tools.
+ * - fetch_page (Jina) remains available — it works without a key at lower rate limits.
+ *
  * v3 improvements over v2:
  * - search_and_read: New tool — Brave LLM Context API (search + read in one call)
  * - Structured error taxonomy: auth_error, rate_limited, network_error, etc.
@@ -30,7 +39,8 @@
  * - Cache timer cleanup: purge timers use unref() to not block process exit
  *
  * Environment variables:
- *   BRAVE_API_KEY  — Required for search. Get one at brave.com/search/api
+ *   BRAVE_API_KEY  — Optional with Anthropic models (built-in search available).
+ *                    Required for non-Anthropic providers. Get one at brave.com/search/api
  *   JINA_API_KEY   — Optional. Higher rate limits for page extraction.
  */
 
@@ -39,36 +49,17 @@ import { registerSearchTool } from "./tool-search";
 import { registerFetchPageTool } from "./tool-fetch-page";
 import { registerLLMContextTool } from "./tool-llm-context";
 import { registerSearchProviderCommand } from "./command-search-provider.ts";
+import { registerNativeSearchHooks } from "./native-search";
 
 export default function (pi: ExtensionAPI) {
-  // Register all tools
   registerSearchTool(pi);
   registerFetchPageTool(pi);
   registerLLMContextTool(pi);
 
+
   // Register slash commands
   registerSearchProviderCommand(pi);
 
-  // Startup diagnostics
-  pi.on("session_start", async (_event, ctx) => {
-    const hasBrave = !!process.env.BRAVE_API_KEY;
-    const hasTavily = !!process.env.TAVILY_API_KEY;
-    const hasJina = !!process.env.JINA_API_KEY;
-    const hasAnswers = !!process.env.BRAVE_ANSWERS_KEY;
-
-    if (!hasBrave && !hasTavily) {
-      ctx.ui.notify(
-        "Web search: Set BRAVE_API_KEY or TAVILY_API_KEY for web search capability",
-        "warning"
-      );
-    }
-
-    const parts: string[] = ["Web search v3"];
-    if (hasTavily) parts.push("Tavily ✓");
-    if (hasBrave) parts.push("Search ✓");
-    if (hasAnswers) parts.push("Answers ✓");
-    if (hasJina) parts.push("Jina ✓");
-
-    ctx.ui.notify(parts.join(" · "), "info");
-  });
+  // Register native Anthropic web search hooks
+  registerNativeSearchHooks(pi);
 }

package/src/resources/extensions/search-the-web/native-search.ts

@@ -0,0 +1,157 @@
+/**
+ * Native Anthropic web search hook logic.
+ *
+ * Extracted from index.ts so it can be unit-tested without importing
+ * the heavy tool-registration modules.
+ */
+
+/** Tool names for the Brave-backed custom search tools */
+export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
+
+/** Thinking block types that require signature validation by the API */
+const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
+
+/** Minimal interface matching the subset of ExtensionAPI we use */
+export interface NativeSearchPI {
+  on(event: string, handler: (...args: any[]) => any): void;
+  getActiveTools(): string[];
+  setActiveTools(tools: string[]): void;
+}
+
+/**
+ * Strip thinking/redacted_thinking blocks from assistant messages in the
+ * conversation history.
+ *
+ * Why: The Pi SDK's streaming parser drops `server_tool_use` and
+ * `web_search_tool_result` content blocks (unknown types). When the
+ * conversation is replayed, the assistant messages are incomplete — missing
+ * those blocks. The Anthropic API detects the modification and rejects the
+ * request with "thinking blocks cannot be modified."
+ *
+ * Fix: Remove thinking blocks from all assistant messages in the history.
+ * In Anthropic's Messages API, the messages array always ends with a user
+ * message, so every assistant message is from a previous turn that has been
+ * through a store/replay cycle. The model generates fresh thinking for the
+ * current turn regardless.
+ */
+export function stripThinkingFromHistory(
+  messages: Array<Record<string, unknown>>
+): void {
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+
+    const content = msg.content;
+    if (!Array.isArray(content)) continue;
+
+    msg.content = content.filter(
+      (block: any) => !THINKING_TYPES.has(block?.type)
+    );
+  }
+}
+
+/**
+ * Register model_select, before_provider_request, and session_start hooks
+ * for native Anthropic web search injection.
+ *
+ * Returns the isAnthropicProvider getter for testing.
+ */
+export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic: () => boolean } {
+  let isAnthropicProvider = false;
+
+  // Track provider changes via model selection — also handles diagnostics
+  // since model_select fires AFTER session_start and knows the provider.
+  pi.on("model_select", async (event: any, ctx: any) => {
+    const wasAnthropic = isAnthropicProvider;
+    isAnthropicProvider = event.model.provider === "anthropic";
+
+    const hasBrave = !!process.env.BRAVE_API_KEY;
+
+    // When Anthropic + no Brave key: disable custom search tools (they'd fail)
+    if (isAnthropicProvider && !hasBrave) {
+      const active = pi.getActiveTools();
+      pi.setActiveTools(
+        active.filter((t: string) => !BRAVE_TOOL_NAMES.includes(t))
+      );
+    } else if (!isAnthropicProvider && wasAnthropic && !hasBrave) {
+      // Switching away from Anthropic without Brave — re-enable so the user
+      // sees the "missing key" error rather than tools silently vanishing.
+      // Only add tools not already active to avoid duplicates on repeated toggles.
+      const active = pi.getActiveTools();
+      const toAdd = BRAVE_TOOL_NAMES.filter((t) => !active.includes(t));
+      if (toAdd.length > 0) {
+        pi.setActiveTools([...active, ...toAdd]);
+      }
+    }
+
+    // Show provider-aware diagnostics on first selection or provider change
+    if (isAnthropicProvider && !wasAnthropic && event.source !== "restore") {
+      ctx.ui.notify("Native Anthropic web search active", "info");
+    } else if (!isAnthropicProvider && !hasBrave) {
+      ctx.ui.notify(
+        "Web search: Set BRAVE_API_KEY or use an Anthropic model for built-in search",
+        "warning"
+      );
+    }
+  });
+
+  // Inject native web search into Anthropic API requests
+  pi.on("before_provider_request", (event: any) => {
+    const payload = event.payload as Record<string, unknown>;
+    if (!payload) return;
+
+    // Detect Anthropic by model name prefix (works even before model_select fires)
+    const model = payload.model as string | undefined;
+    if (!model || !model.startsWith("claude")) return;
+
+    // Keep provider tracking in sync
+    isAnthropicProvider = true;
+
+    // Strip thinking blocks from history to avoid signature validation errors
+    // caused by the SDK dropping server_tool_use/web_search_tool_result blocks.
+    const messages = payload.messages as Array<Record<string, unknown>> | undefined;
+    if (Array.isArray(messages)) {
+      stripThinkingFromHistory(messages);
+    }
+
+    if (!Array.isArray(payload.tools)) payload.tools = [];
+
+    let tools = payload.tools as Array<Record<string, unknown>>;
+
+    // Don't double-inject if already present
+    if (tools.some((t) => t.type === "web_search_20250305")) return;
+
+    // When no Brave key, remove Brave-based search tool definitions from the
+    // payload so Claude doesn't see (and try to call) broken tools.
+    // This is more reliable than setActiveTools since model_select may not fire.
+    const hasBrave = !!process.env.BRAVE_API_KEY;
+    if (!hasBrave) {
+      tools = tools.filter(
+        (t) => !BRAVE_TOOL_NAMES.includes(t.name as string)
+      );
+      payload.tools = tools;
+    }
+
+    tools.push({
+      type: "web_search_20250305",
+      name: "web_search",
+    });
+
+    return payload;
+  });
+
+  // Basic startup diagnostics — provider-specific info comes from model_select
+  pi.on("session_start", async (_event: any, ctx: any) => {
+    const hasBrave = !!process.env.BRAVE_API_KEY;
+    const hasJina = !!process.env.JINA_API_KEY;
+    const hasAnswers = !!process.env.BRAVE_ANSWERS_KEY;
+
+    const parts: string[] = ["Web search v4 loaded"];
+    if (hasBrave) parts.push("Brave ✓");
+    if (hasAnswers) parts.push("Answers ✓");
+    if (hasJina) parts.push("Jina ✓");
+
+    ctx.ui.notify(parts.join(" · "), "info");
+  });
+
+  return { getIsAnthropic: () => isAnthropicProvider };
+}