@oh-my-pi/pi-coding-agent 6.2.0 → 6.7.67

package/src/core/tools/index.ts

@@ -1,35 +1,35 @@
-export { type AskToolDetails, askTool, createAskTool } from "./ask";
-export { type BashOperations, type BashToolDetails, type BashToolOptions, createBashTool } from "./bash";
-export { type CalculatorToolDetails, createCalculatorTool } from "./calculator";
-export { createCompleteTool } from "./complete";
-export { createEditTool, type EditToolDetails } from "./edit";
+export { AskTool, type AskToolDetails } from "./ask";
+export { type BashOperations, BashTool, type BashToolDetails, type BashToolOptions } from "./bash";
+export { CalculatorTool, type CalculatorToolDetails } from "./calculator";
+export { CompleteTool } from "./complete";
 // Exa MCP tools (22 tools)
 export { exaTools } from "./exa/index";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
-export { createFindTool, type FindOperations, type FindToolDetails, type FindToolOptions } from "./find";
+export { type FindOperations, FindTool, type FindToolDetails, type FindToolOptions } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
-export { createGitTool, type GitToolDetails, gitTool } from "./git";
-export { createGrepTool, type GrepOperations, type GrepToolDetails, type GrepToolOptions } from "./grep";
-export { createLsTool, type LsOperations, type LsToolDetails, type LsToolOptions } from "./ls";
+export { GitTool, type GitToolDetails } from "./git";
+export { type GrepOperations, GrepTool, type GrepToolDetails, type GrepToolOptions } from "./grep";
+export { type LsOperations, LsTool, type LsToolDetails, type LsToolOptions } from "./ls";
 export {
-	createLspTool,
 	type FileDiagnosticsResult,
 	type FileFormatResult,
 	getLspStatus,
 	type LspServerStatus,
+	LspTool,
 	type LspToolDetails,
 	type LspWarmupOptions,
 	type LspWarmupResult,
 	warmupLspServers,
 } from "./lsp/index";
-export { createNotebookTool, type NotebookToolDetails } from "./notebook";
-export { createOutputTool, type OutputToolDetails } from "./output";
-export { createPythonTool, type PythonToolDetails } from "./python";
-export { createReadTool, type ReadToolDetails } from "./read";
+export { NotebookTool, type NotebookToolDetails } from "./notebook";
+export { OutputTool, type OutputToolDetails } from "./output";
+export { EditTool, type EditToolDetails } from "./patch";
+export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
+export { ReadTool, type ReadToolDetails } from "./read";
 export { reportFindingTool, type SubmitReviewDetails } from "./review";
-export { createSshTool, type SSHToolDetails } from "./ssh";
-export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
-export { createTodoWriteTool, type TodoItem, type TodoWriteToolDetails } from "./todo-write";
+export { loadSshTool, type SSHToolDetails, SshTool } from "./ssh";
+export { BUNDLED_AGENTS, TaskTool } from "./task/index";
+export { type TodoItem, TodoWriteTool, type TodoWriteToolDetails } from "./todo-write";
 export {
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
@@ -40,10 +40,9 @@ export {
 	truncateLine,
 	truncateTail,
 } from "./truncate";
-export { createWebFetchTool, type WebFetchToolDetails } from "./web-fetch";
+export { WebFetchTool, type WebFetchToolDetails } from "./web-fetch";
 export {
 	companyWebSearchTools,
-	createWebSearchTool,
 	exaWebSearchTools,
 	getWebSearchTools,
 	hasExaWebSearch,
@@ -51,6 +50,7 @@ export {
 	setPreferredWebSearchProvider,
 	type WebSearchProvider,
 	type WebSearchResponse,
+	WebSearchTool,
 	type WebSearchToolsOptions,
 	webSearchCodeContextTool,
 	webSearchCompanyTool,
@@ -58,9 +58,8 @@ export {
 	webSearchCustomTool,
 	webSearchDeepTool,
 	webSearchLinkedinTool,
-	webSearchTool,
 } from "./web-search/index";
-export { createWriteTool, type WriteToolDetails } from "./write";
+export { WriteTool, type WriteToolDetails } from "./write";
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { EventBus } from "../event-bus";
@@ -68,27 +67,27 @@ import { logger } from "../logger";
 import { getPreludeDocs, warmPythonEnvironment } from "../python-executor";
 import { checkPythonKernelAvailability } from "../python-kernel";
 import type { BashInterceptorRule } from "../settings-manager";
-import { createAskTool } from "./ask";
-import { createBashTool } from "./bash";
-import { createCalculatorTool } from "./calculator";
-import { createCompleteTool } from "./complete";
-import { createEditTool } from "./edit";
-import { createFindTool } from "./find";
-import { createGitTool } from "./git";
-import { createGrepTool } from "./grep";
-import { createLsTool } from "./ls";
-import { createLspTool } from "./lsp/index";
-import { createNotebookTool } from "./notebook";
-import { createOutputTool } from "./output";
-import { createPythonTool } from "./python";
-import { createReadTool } from "./read";
+import { AskTool } from "./ask";
+import { BashTool } from "./bash";
+import { CalculatorTool } from "./calculator";
+import { CompleteTool } from "./complete";
+import { FindTool } from "./find";
+import { GitTool } from "./git";
+import { GrepTool } from "./grep";
+import { LsTool } from "./ls";
+import { LspTool } from "./lsp/index";
+import { NotebookTool } from "./notebook";
+import { OutputTool } from "./output";
+import { EditTool } from "./patch";
+import { PythonTool } from "./python";
+import { ReadTool } from "./read";
 import { reportFindingTool } from "./review";
-import { createSshTool } from "./ssh";
-import { createTaskTool } from "./task/index";
-import { createTodoWriteTool } from "./todo-write";
-import { createWebFetchTool } from "./web-fetch";
-import { createWebSearchTool } from "./web-search/index";
-import { createWriteTool } from "./write";
+import { loadSshTool } from "./ssh";
+import { TaskTool } from "./task/index";
+import { TodoWriteTool } from "./todo-write";
+import { WebFetchTool } from "./web-fetch";
+import { WebSearchTool } from "./web-search/index";
+import { WriteTool } from "./write";
 
 /** Tool type (AgentTool from pi-ai) */
 export type Tool = AgentTool<any, any, any>;
@@ -126,10 +125,13 @@ export interface ToolSession {
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
+		getReadLineNumbers?(): boolean;
 		getLspFormatOnWrite(): boolean;
 		getLspDiagnosticsOnWrite(): boolean;
 		getLspDiagnosticsOnEdit(): boolean;
 		getEditFuzzyMatch(): boolean;
+		getEditFuzzyThreshold?(): number;
+		getEditPatchMode?(): boolean;
 		getGitToolEnabled(): boolean;
 		getBashInterceptorEnabled(): boolean;
 		getBashInterceptorSimpleLsEnabled(): boolean;
@@ -143,29 +145,29 @@ export interface ToolSession {
 type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
-	ask: createAskTool,
-	bash: createBashTool,
-	python: createPythonTool,
-	calc: createCalculatorTool,
-	ssh: createSshTool,
-	edit: createEditTool,
-	find: createFindTool,
-	git: createGitTool,
-	grep: createGrepTool,
-	ls: createLsTool,
-	lsp: createLspTool,
-	notebook: createNotebookTool,
-	output: createOutputTool,
-	read: createReadTool,
-	task: createTaskTool,
-	todo_write: createTodoWriteTool,
-	web_fetch: createWebFetchTool,
-	web_search: createWebSearchTool,
-	write: createWriteTool,
+	ask: AskTool.createIf,
+	bash: (s) => new BashTool(s),
+	python: (s) => new PythonTool(s),
+	calc: (s) => new CalculatorTool(s),
+	ssh: loadSshTool,
+	edit: (s) => new EditTool(s),
+	find: (s) => new FindTool(s),
+	git: GitTool.createIf,
+	grep: (s) => new GrepTool(s),
+	ls: (s) => new LsTool(s),
+	lsp: LspTool.createIf,
+	notebook: (s) => new NotebookTool(s),
+	output: (s) => new OutputTool(s),
+	read: (s) => new ReadTool(s),
+	task: TaskTool.create,
+	todo_write: (s) => new TodoWriteTool(s),
+	web_fetch: (s) => new WebFetchTool(s),
+	web_search: (s) => new WebSearchTool(s),
+	write: (s) => new WriteTool(s),
 };
 
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
-	complete: createCompleteTool,
+	complete: (s) => new CompleteTool(s),
 	report_finding: () => reportFindingTool,
 };
 

package/src/core/tools/ls.ts

@@ -1,7 +1,6 @@
 import nodePath from "node:path";
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import type { RenderResultOptions } from "../custom-tools/types";
@@ -69,129 +68,135 @@ const defaultLsOperations: LsOperations = {
 	},
 };
 
-export function createLsTool(session: ToolSession, options?: LsToolOptions): AgentTool<typeof lsSchema> {
-	const ops = options?.operations ?? defaultLsOperations;
-
-	return {
-		name: "ls",
-		label: "Ls",
-		description: `List directory contents with modification times. Returns entries sorted alphabetically, with '/' suffix for directories and relative age (e.g., "2d ago", "just now"). Includes dotfiles. Output is truncated to 500 entries or 50KB (whichever is hit first).`,
-		parameters: lsSchema,
-		execute: async (
-			_toolCallId: string,
-			{ path, limit }: { path?: string; limit?: number },
-			signal?: AbortSignal,
-		) => {
-			return untilAborted(signal, async () => {
-				const dirPath = resolveToCwd(path || ".", session.cwd);
-				const effectiveLimit = limit ?? DEFAULT_LIMIT;
-
-				// Check if path exists and is a directory
-				const dirStat = await ops.stat(dirPath);
-				if (!dirStat) {
-					throw new Error(`Path not found: ${dirPath}`);
-				}
+export class LsTool implements AgentTool<typeof lsSchema, LsToolDetails> {
+	public readonly name = "ls";
+	public readonly label = "Ls";
+	public readonly description =
+		'List directory contents with modification times. Returns entries sorted alphabetically, with \'/\' suffix for directories and relative age (e.g., "2d ago", "just now"). Includes dotfiles. Output is truncated to 500 entries or 50KB (whichever is hit first).';
+	public readonly parameters = lsSchema;
+
+	private readonly session: ToolSession;
+	private readonly ops: LsOperations;
+
+	constructor(session: ToolSession, options?: LsToolOptions) {
+		this.session = session;
+		this.ops = options?.operations ?? defaultLsOperations;
+	}
+
+	public async execute(
+		_toolCallId: string,
+		{ path, limit }: { path?: string; limit?: number },
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<LsToolDetails>> {
+		return untilAborted(signal, async () => {
+			const dirPath = resolveToCwd(path || ".", this.session.cwd);
+			const effectiveLimit = limit ?? DEFAULT_LIMIT;
+
+			// Check if path exists and is a directory
+			const dirStat = await this.ops.stat(dirPath);
+			if (!dirStat) {
+				throw new Error(`Path not found: ${dirPath}`);
+			}
 
-				if (!dirStat.isDirectory()) {
-					throw new Error(`Not a directory: ${dirPath}`);
-				}
+			if (!dirStat.isDirectory()) {
+				throw new Error(`Not a directory: ${dirPath}`);
+			}
 
-				// Read directory entries
-				let entries: string[];
-				try {
-					entries = await ops.readdir(dirPath);
-				} catch (error) {
-					const message = error instanceof Error ? error.message : String(error);
-					throw new Error(`Cannot read directory: ${message}`);
-				}
+			// Read directory entries
+			let entries: string[];
+			try {
+				entries = await this.ops.readdir(dirPath);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(`Cannot read directory: ${message}`);
+			}
 
-				// Sort alphabetically (case-insensitive)
-				entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-
-				// Format entries with directory indicators
-				const results: string[] = [];
-				let entryLimitReached = false;
-				let dirCount = 0;
-				let fileCount = 0;
-
-				for (const entry of entries) {
-					signal?.throwIfAborted();
-					if (results.length >= effectiveLimit) {
-						entryLimitReached = true;
-						break;
-					}
-
-					const fullPath = nodePath.join(dirPath, entry);
-					let suffix = "";
-					let age = "";
-
-					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);
-				}
+			// Sort alphabetically (case-insensitive)
+			entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
 
-				if (results.length === 0) {
-					return { content: [{ type: "text", text: "(empty directory)" }], details: undefined };
-				}
+			// Format entries with directory indicators
+			const results: string[] = [];
+			let entryLimitReached = false;
+			let dirCount = 0;
+			let fileCount = 0;
 
-				// Apply byte truncation (no line limit since we already have entry limit)
-				const rawOutput = results.join("\n");
-				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-
-				let output = truncation.content;
-				const details: LsToolDetails = {
-					entries: results,
-					dirCount,
-					fileCount,
-				};
-				const truncationReasons: Array<"entryLimit" | "byteLimit"> = [];
-
-				// Build notices
-				const notices: string[] = [];
-
-				if (entryLimitReached) {
-					notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
-					details.entryLimitReached = effectiveLimit;
-					truncationReasons.push("entryLimit");
+			for (const entry of entries) {
+				signal?.throwIfAborted();
+				if (results.length >= effectiveLimit) {
+					entryLimitReached = true;
+					break;
 				}
 
-				if (truncation.truncated) {
-					notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-					details.truncation = truncation;
-					truncationReasons.push("byteLimit");
-				}
+				const fullPath = nodePath.join(dirPath, entry);
+				let suffix = "";
+				let age = "";
 
-				if (truncationReasons.length > 0) {
-					details.truncationReasons = truncationReasons;
+				const entryStat = await this.ops.stat(fullPath);
+				if (!entryStat) {
+					// Skip entries we can't stat
+					continue;
 				}
 
-				if (notices.length > 0) {
-					output += `\n\n[${notices.join(". ")}]`;
+				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);
+			}
+
+			if (results.length === 0) {
+				return { content: [{ type: "text", text: "(empty directory)" }], details: {} };
+			}
+
+			// Apply byte truncation (no line limit since we already have entry limit)
+			const rawOutput = results.join("\n");
+			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+
+			let output = truncation.content;
+			const details: LsToolDetails = {
+				entries: results,
+				dirCount,
+				fileCount,
+			};
+			const truncationReasons: Array<"entryLimit" | "byteLimit"> = [];
+
+			// Build notices
+			const notices: string[] = [];
+
+			if (entryLimitReached) {
+				notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
+				details.entryLimitReached = effectiveLimit;
+				truncationReasons.push("entryLimit");
+			}
+
+			if (truncation.truncated) {
+				notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+				details.truncation = truncation;
+				truncationReasons.push("byteLimit");
+			}
+
+			if (truncationReasons.length > 0) {
+				details.truncationReasons = truncationReasons;
+			}
+
+			if (notices.length > 0) {
+				output += `\n\n[${notices.join(". ")}]`;
+			}
 
-				return {
-					content: [{ type: "text", text: output }],
-					details,
-				};
-			});
-		},
-	};
+			return {
+				content: [{ type: "text", text: output }],
+				details,
+			};
+		});
+	}
 }
 
 // =============================================================================

package/src/core/tools/lsp/clients/biome-client.ts

@@ -110,6 +110,11 @@ export class BiomeClient implements LinterClient {
 	private config: ServerConfig;
 	private cwd: string;
 
+	/** Factory method for creating BiomeClient instances */
+	static create(config: ServerConfig, cwd: string): LinterClient {
+		return new BiomeClient(config, cwd);
+	}
+
 	constructor(config: ServerConfig, cwd: string) {
 		this.config = config;
 		this.cwd = cwd;
@@ -198,10 +203,3 @@ export class BiomeClient implements LinterClient {
 		// Nothing to dispose for CLI client
 	}
 }
-
-/**
- * Factory function to create a Biome client.
- */
-export function createBiomeClient(config: ServerConfig, cwd: string): LinterClient {
-	return new BiomeClient(config, cwd);
-}

package/src/core/tools/lsp/clients/index.ts

@@ -5,11 +5,11 @@
  * Different implementations can use LSP protocol, CLI tools, or other mechanisms.
  */
 
-export { BiomeClient, createBiomeClient } from "./biome-client";
-export { createLspLinterClient, LspLinterClient } from "./lsp-linter-client";
+export { BiomeClient } from "./biome-client";
+export { LspLinterClient } from "./lsp-linter-client";
 
 import type { LinterClient, ServerConfig } from "../types";
-import { createLspLinterClient } from "./lsp-linter-client";
+import { LspLinterClient } from "./lsp-linter-client";
 
 // Cache of linter clients by server name + cwd
 const clientCache = new Map<string, LinterClient>();
@@ -31,7 +31,7 @@ export function getLinterClient(serverName: string, config: ServerConfig, cwd: s
 		client = config.createClient(config, cwd);
 	} else {
 		// Default to LSP
-		client = createLspLinterClient(config, cwd);
+		client = LspLinterClient.create(config, cwd);
 	}
 
 	clientCache.set(key, client);

package/src/core/tools/lsp/clients/lsp-linter-client.ts

@@ -26,6 +26,11 @@ export class LspLinterClient implements LinterClient {
 	private cwd: string;
 	private client: LspClient | null = null;
 
+	/** Factory method for creating LspLinterClient instances */
+	static create(config: ServerConfig, cwd: string): LinterClient {
+		return new LspLinterClient(config, cwd);
+	}
+
 	constructor(config: ServerConfig, cwd: string) {
 		this.config = config;
 		this.cwd = cwd;
@@ -89,10 +94,3 @@ export class LspLinterClient implements LinterClient {
 		// Client lifecycle is managed globally, nothing to dispose here
 	}
 }
-
-/**
- * Factory function to create an LSP linter client.
- */
-export function createLspLinterClient(config: ServerConfig, cwd: string): LinterClient {
-	return new LspLinterClient(config, cwd);
-}

package/src/core/tools/lsp/config.ts

@@ -4,7 +4,7 @@ import { YAML } from "bun";
 import { globSync } from "glob";
 import { getConfigDirPaths } from "../../../config";
 import { logger } from "../../logger";
-import { createBiomeClient } from "./clients/biome-client";
+import { BiomeClient } from "./clients/biome-client";
 import DEFAULTS from "./defaults.json" with { type: "json" };
 import type { ServerConfig } from "./types";
 
@@ -137,7 +137,7 @@ function applyRuntimeDefaults(servers: Record<string, ServerConfig>): Record<str
 	const updated: Record<string, ServerConfig> = { ...servers };
 
 	if (updated.biome) {
-		updated.biome = { ...updated.biome, createClient: createBiomeClient };
+		updated.biome = { ...updated.biome, createClient: BiomeClient.create };
 	}
 
 	if (updated.omnisharp?.args) {