@oh-my-pi/pi-coding-agent 3.37.1 → 4.0.0

package/src/core/tools/find.ts

@@ -44,6 +44,22 @@ export interface FindToolDetails {
 	error?: string;
 }
 
+/**
+ * Pluggable operations for the find tool.
+ * Override these to delegate file search to remote systems (e.g., SSH).
+ */
+export interface FindOperations {
+	/** Check if path exists */
+	exists: (absolutePath: string) => Promise<boolean> | boolean;
+	/** Find files matching glob pattern. Returns relative paths. */
+	glob: (pattern: string, cwd: string, options: { ignore: string[]; limit: number }) => Promise<string[]> | string[];
+}
+
+export interface FindToolOptions {
+	/** Custom operations for find. Default: local filesystem + fd */
+	operations?: FindOperations;
+}
+
 async function captureCommandOutput(
 	command: string,
 	args: string[],
@@ -91,7 +107,9 @@ async function captureCommandOutput(
 	return { stdout, stderr, exitCode, aborted: scope.aborted };
 }
 
-export function createFindTool(session: ToolSession): AgentTool<typeof findSchema> {
+export function createFindTool(session: ToolSession, options?: FindToolOptions): AgentTool<typeof findSchema> {
+	const customOps = options?.operations;
+
 	return {
 		name: "find",
 		label: "Find",
@@ -117,12 +135,6 @@ export function createFindTool(session: ToolSession): AgentTool<typeof findSchem
 			signal?: AbortSignal,
 		) => {
 			return untilAborted(signal, async () => {
-				// Ensure fd is available
-				const fdPath = await ensureTool("fd", true);
-				if (!fdPath) {
-					throw new Error("fd is not available and could not be downloaded");
-				}
-
 				const searchPath = resolveToCwd(searchDir || ".", session.cwd);
 				const scopePath = (() => {
 					const relative = path.relative(session.cwd, searchPath).replace(/\\/g, "/");
@@ -133,6 +145,73 @@ export function createFindTool(session: ToolSession): AgentTool<typeof findSchem
 				const includeHidden = hidden ?? false;
 				const shouldSortByMtime = sortByMtime ?? false;
 
+				// If custom operations provided with glob, use that instead of fd
+				if (customOps?.glob) {
+					if (!(await customOps.exists(searchPath))) {
+						throw new Error(`Path not found: ${searchPath}`);
+					}
+
+					const results = await customOps.glob(pattern, searchPath, {
+						ignore: ["**/node_modules/**", "**/.git/**"],
+						limit: effectiveLimit,
+					});
+
+					if (results.length === 0) {
+						return {
+							content: [{ type: "text", text: "No files found matching pattern" }],
+							details: { scopePath, fileCount: 0, files: [], truncated: false },
+						};
+					}
+
+					// Relativize paths
+					const relativized = results.map((p) => {
+						if (p.startsWith(searchPath)) {
+							return p.slice(searchPath.length + 1);
+						}
+						return path.relative(searchPath, p);
+					});
+
+					const resultLimitReached = relativized.length >= effectiveLimit;
+					const rawOutput = relativized.join("\n");
+					const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+
+					let resultOutput = truncation.content;
+					const details: FindToolDetails = {
+						scopePath,
+						fileCount: relativized.length,
+						files: relativized,
+						truncated: resultLimitReached || truncation.truncated,
+					};
+					const notices: string[] = [];
+
+					if (resultLimitReached) {
+						notices.push(
+							`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`,
+						);
+						details.resultLimitReached = effectiveLimit;
+					}
+
+					if (truncation.truncated) {
+						notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+						details.truncation = truncation;
+					}
+
+					if (notices.length > 0) {
+						resultOutput += `\n\n[${notices.join(". ")}]`;
+					}
+
+					return {
+						content: [{ type: "text", text: resultOutput }],
+						details: Object.keys(details).length > 0 ? details : undefined,
+					};
+				}
+
+				// Default: use fd
+				const fdPath = await ensureTool("fd", true);
+				if (!fdPath) {
+					throw new Error("fd is not available and could not be downloaded");
+				}
+
 				// Build fd arguments
 				// When pattern contains path separators (e.g. "reports/**"), use --full-path
 				// so fd matches against the full path, not just the filename.

package/src/core/tools/grep.ts

@@ -70,7 +70,29 @@ export interface GrepToolDetails {
 	error?: string;
 }
 
-export function createGrepTool(session: ToolSession): AgentTool<typeof grepSchema> {
+/**
+ * Pluggable operations for the grep tool.
+ * Override these to delegate search to remote systems (e.g., SSH).
+ */
+export interface GrepOperations {
+	/** Check if path is a directory. Throws if path doesn't exist. */
+	isDirectory: (absolutePath: string) => Promise<boolean> | boolean;
+	/** Read file contents for context lines */
+	readFile: (absolutePath: string) => Promise<string> | string;
+}
+
+const defaultGrepOperations: GrepOperations = {
+	isDirectory: async (p) => (await Bun.file(p).stat()).isDirectory(),
+	readFile: (p) => Bun.file(p).text(),
+};
+
+export interface GrepToolOptions {
+	/** Custom operations for grep. Default: local filesystem + ripgrep */
+	operations?: GrepOperations;
+}
+
+export function createGrepTool(session: ToolSession, options?: GrepToolOptions): AgentTool<typeof grepSchema> {
+	const ops = options?.operations ?? defaultGrepOperations;
 	return {
 		name: "grep",
 		label: "Grep",
@@ -120,14 +142,13 @@ export function createGrepTool(session: ToolSession): AgentTool<typeof grepSchem
 					const relative = nodePath.relative(session.cwd, searchPath).replace(/\\/g, "/");
 					return relative.length === 0 ? "." : relative;
 				})();
-				let searchStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
+
+				let isDirectory: boolean;
 				try {
-					searchStat = await Bun.file(searchPath).stat();
+					isDirectory = await ops.isDirectory(searchPath);
 				} catch {
 					throw new Error(`Path not found: ${searchPath}`);
 				}
-
-				const isDirectory = searchStat.isDirectory();
 				const contextValue = context && context > 0 ? context : 0;
 				const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
 				const effectiveOutputMode = outputMode ?? "content";
@@ -150,7 +171,7 @@ export function createGrepTool(session: ToolSession): AgentTool<typeof grepSchem
 					if (!linesPromise) {
 						linesPromise = (async () => {
 							try {
-								const content = await Bun.file(filePath).text();
+								const content = await ops.readFile(filePath);
 								return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
 							} catch {
 								return [];

package/src/core/tools/index.ts

@@ -1,16 +1,16 @@
 export { type AskToolDetails, askTool, createAskTool } from "./ask";
-export { type BashToolDetails, createBashTool } from "./bash";
+export { type BashOperations, type BashToolDetails, createBashTool } from "./bash";
 export { type CalculatorToolDetails, createCalculatorTool } from "./calculator";
 export { createCompleteTool } from "./complete";
-export { createEditTool } from "./edit";
+export { createEditTool, type EditToolDetails } from "./edit";
 // Exa MCP tools (22 tools)
 export { exaTools } from "./exa/index";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
-export { createFindTool, type FindToolDetails } from "./find";
+export { createFindTool, type FindOperations, type FindToolDetails, type FindToolOptions } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
 export { createGitTool, type GitToolDetails, gitTool } from "./git";
-export { createGrepTool, type GrepToolDetails } from "./grep";
-export { createLsTool, type LsToolDetails } from "./ls";
+export { createGrepTool, type GrepOperations, type GrepToolDetails, type GrepToolOptions } from "./grep";
+export { createLsTool, type LsOperations, type LsToolDetails, type LsToolOptions } from "./ls";
 export {
 	createLspTool,
 	type FileDiagnosticsResult,
@@ -29,7 +29,16 @@ export { reportFindingTool, type SubmitReviewDetails } from "./review";
 export { filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
 export { createSshTool, type SSHToolDetails } from "./ssh";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
-export type { TruncationResult } from "./truncate";
+export {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	type TruncationOptions,
+	type TruncationResult,
+	truncateHead,
+	truncateLine,
+	truncateTail,
+} from "./truncate";
 export { createWebFetchTool, type WebFetchToolDetails } from "./web-fetch";
 export {
 	companyWebSearchTools,

package/src/core/tools/ls.ts

@@ -28,6 +28,22 @@ const lsSchema = Type.Object({
 
 const DEFAULT_LIMIT = 500;
 
+/**
+ * Pluggable operations for the ls tool.
+ * Override these to delegate directory listing to remote systems (e.g., SSH).
+ */
+export interface LsOperations {
+	/** Check if path exists and return stats. Returns undefined if not found. */
+	stat: (absolutePath: string) => Promise<{ isDirectory: () => boolean; mtimeMs: number } | undefined>;
+	/** Read directory entries (names only) */
+	readdir: (absolutePath: string) => Promise<string[]>;
+}
+
+export interface LsToolOptions {
+	/** Custom operations for directory listing. Default: local filesystem via Bun */
+	operations?: LsOperations;
+}
+
 export interface LsToolDetails {
 	entries?: string[];
 	dirCount?: number;
@@ -37,7 +53,24 @@ export interface LsToolDetails {
 	entryLimitReached?: number;
 }
 
-export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
+/** Default operations using Bun APIs */
+const defaultLsOperations: LsOperations = {
+	async stat(absolutePath: string) {
+		try {
+			const s = await Bun.file(absolutePath).stat();
+			return { isDirectory: () => s.isDirectory(), mtimeMs: s.mtimeMs };
+		} catch {
+			return undefined;
+		}
+	},
+	async readdir(absolutePath: string) {
+		return Array.fromAsync(new Bun.Glob("*").scan({ cwd: absolutePath, dot: true, onlyFiles: false }));
+	},
+};
+
+export function createLsTool(session: ToolSession, options?: LsToolOptions): AgentTool<typeof lsSchema> {
+	const ops = options?.operations ?? defaultLsOperations;
+
 	return {
 		name: "ls",
 		label: "Ls",
@@ -53,10 +86,8 @@ export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
 
 				// Check if path exists and is a directory
-				let dirStat: Awaited<ReturnType<Bun.BunFile["stat"]>>;
-				try {
-					dirStat = await Bun.file(dirPath).stat();
-				} catch {
+				const dirStat = await ops.stat(dirPath);
+				if (!dirStat) {
 					throw new Error(`Path not found: ${dirPath}`);
 				}
 
@@ -67,7 +98,7 @@ export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
 				// Read directory entries
 				let entries: string[];
 				try {
-					entries = await Array.fromAsync(new Bun.Glob("*").scan({ cwd: dirPath, dot: true, onlyFiles: false }));
+					entries = await ops.readdir(dirPath);
 				} catch (error) {
 					const message = error instanceof Error ? error.message : String(error);
 					throw new Error(`Cannot read directory: ${message}`);
@@ -93,22 +124,22 @@ export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
 					let suffix = "";
 					let age = "";
 
-					try {
-						const entryStat = await Bun.file(fullPath).stat();
-						if (entryStat.isDirectory()) {
-							suffix = "/";
-							dirCount += 1;
-						} else {
-							fileCount += 1;
-						}
-						// Calculate age from mtime
-						const ageSeconds = Math.floor((Date.now() - entryStat.mtimeMs) / 1000);
-						age = formatAge(ageSeconds);
-					} catch {
+					const entryStat = await ops.stat(fullPath);
+					if (!entryStat) {
 						// Skip entries we can't stat
 						continue;
 					}
 
+					if (entryStat.isDirectory()) {
+						suffix = "/";
+						dirCount += 1;
+					} else {
+						fileCount += 1;
+					}
+					// Calculate age from mtime
+					const ageSeconds = Math.floor((Date.now() - entryStat.mtimeMs) / 1000);
+					age = formatAge(ageSeconds);
+
 					// Format: "name/ (2d ago)" or "name (just now)"
 					const line = age ? `${entry}${suffix} (${age})` : entry + suffix;
 					results.push(line);

package/src/core/tools/render-utils.ts

@@ -5,6 +5,7 @@
  * tool renderers to ensure a unified TUI experience.
  */
 
+import { homedir } from "node:os";
 import type { Theme } from "../../modes/interactive/theme/theme";
 
 // =============================================================================
@@ -490,7 +491,7 @@ export function truncateDiffByHunk(
 // =============================================================================
 
 export function shortenPath(filePath: string, homeDir?: string): string {
-	const home = homeDir ?? process.env.HOME ?? process.env.USERPROFILE;
+	const home = homeDir ?? homedir();
 	if (home && filePath.startsWith(home)) {
 		return `~${filePath.slice(home.length)}`;
 	}

package/src/core/tools/task/worker.ts

@@ -197,20 +197,43 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 		// Note: Does not support --extension CLI flag or extension CLI flags
 		const extensionRunner = session.extensionRunner;
 		if (extensionRunner) {
-			extensionRunner.initialize({
-				getModel: () => session.model,
-				sendMessageHandler: (message, options) => {
-					session.sendCustomMessage(message, options).catch((e) => {
-						console.error(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}`);
-					});
+			extensionRunner.initialize(
+				// ExtensionActions
+				{
+					sendMessage: (message, options) => {
+						session.sendCustomMessage(message, options).catch((e) => {
+							console.error(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}`);
+						});
+					},
+					sendUserMessage: (content, options) => {
+						session.sendUserMessage(content, options).catch((e) => {
+							console.error(`Extension sendUserMessage failed: ${e instanceof Error ? e.message : String(e)}`);
+						});
+					},
+					appendEntry: (customType, data) => {
+						session.sessionManager.appendCustomEntry(customType, data);
+					},
+					getActiveTools: () => session.getActiveToolNames(),
+					getAllTools: () => session.getAllToolNames(),
+					setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
+					setModel: async (model) => {
+						const key = await session.modelRegistry.getApiKey(model);
+						if (!key) return false;
+						await session.setModel(model);
+						return true;
+					},
+					getThinkingLevel: () => session.thinkingLevel,
+					setThinkingLevel: (level) => session.setThinkingLevel(level),
 				},
-				appendEntryHandler: (customType, data) => {
-					session.sessionManager.appendCustomEntry(customType, data);
+				// ExtensionContextActions
+				{
+					getModel: () => session.model,
+					isIdle: () => !session.isStreaming,
+					abort: () => session.abort(),
+					hasPendingMessages: () => session.queuedMessageCount > 0,
+					shutdown: () => {},
 				},
-				getActiveToolsHandler: () => session.getActiveToolNames(),
-				getAllToolsHandler: () => session.getAllToolNames(),
-				setActiveToolsHandler: (toolNamesList: string[]) => session.setActiveToolsByName(toolNamesList),
-			});
+			);
 			extensionRunner.onError((err) => {
 				console.error(`Extension error (${err.extensionPath}): ${err.error}`);
 			});

package/src/core/tools/web-search/auth.ts

@@ -10,6 +10,7 @@
 
 import * as os from "node:os";
 import * as path from "node:path";
+import { buildBetaHeader, claudeCodeHeaders, claudeCodeVersion } from "@oh-my-pi/pi-ai";
 import { getConfigDirPaths } from "../../../config";
 import type { AnthropicAuthConfig, AnthropicOAuthCredential, AuthJson, ModelsJson } from "./types";
 
@@ -162,46 +163,50 @@ export async function findAnthropicAuth(): Promise<AnthropicAuthConfig | null> {
 	return null;
 }
 
-/** Build headers for Anthropic API request */
-export function buildAnthropicHeaders(auth: AnthropicAuthConfig): Record<string, string> {
-	const betas = ["web-search-2025-03-05"];
-
-	if (auth.isOAuth) {
-		// OAuth requires additional beta headers and stainless telemetry
-		betas.push("oauth-2025-04-20", "claude-code-20250219", "prompt-caching-2024-07-31");
-
-		return {
-			"anthropic-version": "2023-06-01",
-			authorization: `Bearer ${auth.apiKey}`,
-			accept: "application/json",
-			"content-type": "application/json",
-			"anthropic-dangerous-direct-browser-access": "true",
-			"anthropic-beta": betas.join(","),
-			"user-agent": "claude-code/2.0.20",
-			"x-app": "cli",
-			// Stainless SDK telemetry headers (required for OAuth)
-			"x-stainless-arch": process.arch,
-			"x-stainless-lang": "js",
-			"x-stainless-os": process.platform,
-			"x-stainless-package-version": "1.0.0",
-			"x-stainless-retry-count": "0",
-			"x-stainless-runtime": "bun",
-			"x-stainless-runtime-version": Bun.version,
-		};
+function isAnthropicBaseUrl(baseUrl: string): boolean {
+	try {
+		const url = new URL(baseUrl);
+		return url.protocol === "https:" && url.hostname === "api.anthropic.com";
+	} catch {
+		return false;
 	}
+}
 
-	// Standard API key auth
-	return {
-		"anthropic-version": "2023-06-01",
-		"x-api-key": auth.apiKey,
+/** Build headers for Anthropic API request */
+export function buildAnthropicHeaders(auth: AnthropicAuthConfig): Record<string, string> {
+	const baseBetas = auth.isOAuth
+		? [
+				"claude-code-20250219",
+				"oauth-2025-04-20",
+				"interleaved-thinking-2025-05-14",
+				"fine-grained-tool-streaming-2025-05-14",
+			]
+		: ["fine-grained-tool-streaming-2025-05-14"];
+	const betaHeader = buildBetaHeader(baseBetas, ["web-search-2025-03-05"]);
+
+	const headers: Record<string, string> = {
 		accept: "application/json",
 		"content-type": "application/json",
-		"anthropic-beta": betas.join(","),
+		"anthropic-dangerous-direct-browser-access": "true",
+		"anthropic-beta": betaHeader,
+		"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
+		"x-app": "cli",
+		"accept-encoding": "gzip, deflate, br, zstd",
+		connection: "keep-alive",
+		...claudeCodeHeaders,
 	};
+
+	if (auth.isOAuth || !isAnthropicBaseUrl(auth.baseUrl)) {
+		headers.authorization = `Bearer ${auth.apiKey}`;
+	} else {
+		headers["x-api-key"] = auth.apiKey;
+	}
+
+	return headers;
 }
 
 /** Build API URL (OAuth requires ?beta=true) */
 export function buildAnthropicUrl(auth: AnthropicAuthConfig): string {
 	const base = `${auth.baseUrl}/v1/messages`;
-	return auth.isOAuth ? `${base}?beta=true` : base;
+	return `${base}?beta=true`;
 }

package/src/core/tools/web-search/providers/anthropic.ts

@@ -5,6 +5,7 @@
  * Returns synthesized answers with citations and source metadata.
  */
 
+import { applyClaudeToolPrefix, buildAnthropicSystemBlocks, stripClaudeToolPrefix } from "@oh-my-pi/pi-ai";
 import { buildAnthropicHeaders, buildAnthropicUrl, findAnthropicAuth, getEnv } from "../auth";
 import type {
 	AnthropicApiResponse,
@@ -18,6 +19,12 @@ import { WebSearchProviderError } from "../types";
 
 const DEFAULT_MODEL = "claude-haiku-4-5";
 const DEFAULT_MAX_TOKENS = 4096;
+const WEB_SEARCH_TOOL_NAME = "web_search";
+const WEB_SEARCH_TOOL_TYPE = "web_search_20250305";
+
+const applySearchToolPrefix = (name: string, isOAuth: boolean): string => {
+	return isOAuth ? applyClaudeToolPrefix(name) : name;
+};
 
 export interface AnthropicSearchParams {
 	query: string;
@@ -31,6 +38,21 @@ async function getModel(): Promise<string> {
 	return (await getEnv("ANTHROPIC_SEARCH_MODEL")) ?? DEFAULT_MODEL;
 }
 
+function buildSystemBlocks(
+	auth: AnthropicAuthConfig,
+	model: string,
+	systemPrompt?: string,
+): ReturnType<typeof buildAnthropicSystemBlocks> {
+	const includeClaudeCode = !model.startsWith("claude-3-5-haiku");
+	const extraInstructions = auth.isOAuth ? ["You are a helpful AI assistant with web search capabilities."] : [];
+
+	return buildAnthropicSystemBlocks(systemPrompt, {
+		includeClaudeCodeInstruction: includeClaudeCode,
+		includeCacheControl: auth.isOAuth,
+		extraInstructions,
+	});
+}
+
 /** Call Anthropic API with web search */
 async function callWebSearch(
 	auth: AnthropicAuthConfig,
@@ -42,34 +64,21 @@ async function callWebSearch(
 	const url = buildAnthropicUrl(auth);
 	const headers = buildAnthropicHeaders(auth);
 
-	// Build system blocks
-	const systemBlocks: Array<{ type: string; text: string; cache_control?: { type: string } }> = [];
-
-	if (auth.isOAuth) {
-		// OAuth requires Claude Code identity with cache_control
-		systemBlocks.push({
-			type: "text",
-			text: "You are a helpful AI assistant with web search capabilities.",
-			cache_control: { type: "ephemeral" },
-		});
-	}
-
-	if (systemPrompt) {
-		systemBlocks.push({
-			type: "text",
-			text: systemPrompt,
-			...(auth.isOAuth ? { cache_control: { type: "ephemeral" } } : {}),
-		});
-	}
+	const systemBlocks = buildSystemBlocks(auth, model, systemPrompt);
 
 	const body: Record<string, unknown> = {
 		model,
 		max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
 		messages: [{ role: "user", content: query }],
-		tools: [{ type: "web_search_20250305", name: "web_search" }],
+		tools: [
+			{
+				type: WEB_SEARCH_TOOL_TYPE,
+				name: applySearchToolPrefix(WEB_SEARCH_TOOL_NAME, auth.isOAuth),
+			},
+		],
 	};
 
-	if (systemBlocks.length > 0) {
+	if (systemBlocks && systemBlocks.length > 0) {
 		body.system = systemBlocks;
 	}
 
@@ -131,7 +140,11 @@ function parseResponse(response: AnthropicApiResponse): WebSearchResponse {
 	const citations: WebSearchCitation[] = [];
 
 	for (const block of response.content) {
-		if (block.type === "server_tool_use" && block.name === "web_search") {
+		if (
+			block.type === "server_tool_use" &&
+			block.name &&
+			stripClaudeToolPrefix(block.name) === WEB_SEARCH_TOOL_NAME
+		) {
 			// Intermediate search query
 			if (block.input?.query) {
 				searchQueries.push(block.input.query);