@oh-my-pi/pi-coding-agent 1.337.0

package/src/core/tools/index.ts

@@ -0,0 +1,202 @@
+export { type AskToolDetails, askTool, createAskTool } from "./ask.js";
+export { type BashToolDetails, bashTool, createBashTool } from "./bash.js";
+export { createEditTool, editTool } from "./edit.js";
+// Exa MCP tools (22 tools)
+export { exaTools } from "./exa/index.js";
+export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types.js";
+export { createFindTool, type FindToolDetails, findTool } from "./find.js";
+export { createGrepTool, type GrepToolDetails, grepTool } from "./grep.js";
+export { createLsTool, type LsToolDetails, lsTool } from "./ls.js";
+export { createLspTool, type LspToolDetails, lspTool } from "./lsp/index.js";
+export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./notebook.js";
+export { createReadTool, type ReadToolDetails, readTool } from "./read.js";
+export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index.js";
+export type { TruncationResult } from "./truncate.js";
+export { createWebFetchTool, type WebFetchToolDetails, webFetchCustomTool, webFetchTool } from "./web-fetch.js";
+export {
+	companyWebSearchTools,
+	createWebSearchTool,
+	exaWebSearchTools,
+	getWebSearchTools,
+	hasExaWebSearch,
+	linkedinWebSearchTools,
+	type WebSearchProvider,
+	type WebSearchResponse,
+	type WebSearchToolsOptions,
+	webSearchCodeContextTool,
+	webSearchCompanyTool,
+	webSearchCrawlTool,
+	webSearchCustomTool,
+	webSearchDeepTool,
+	webSearchLinkedinTool,
+	webSearchTool,
+} from "./web-search/index.js";
+export { createWriteTool, writeTool } from "./write.js";
+
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { askTool, createAskTool } from "./ask.js";
+import { bashTool, createBashTool } from "./bash.js";
+import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor.js";
+import { createEditTool, editTool } from "./edit.js";
+import { createFindTool, findTool } from "./find.js";
+import { createGrepTool, grepTool } from "./grep.js";
+import { createLsTool, lsTool } from "./ls.js";
+import { createLspTool, lspTool } from "./lsp/index.js";
+import { createNotebookTool, notebookTool } from "./notebook.js";
+import { createReadTool, readTool } from "./read.js";
+import { createTaskTool, taskTool } from "./task/index.js";
+import { createWebFetchTool, webFetchTool } from "./web-fetch.js";
+import { createWebSearchTool, webSearchTool } from "./web-search/index.js";
+import { createWriteTool, writeTool } from "./write.js";
+
+/** Tool type (AgentTool from pi-ai) */
+export type Tool = AgentTool<any, any, any>;
+
+/** Context for tools that need session information */
+export interface SessionContext {
+	getSessionFile: () => string | null;
+}
+
+// Factory function type
+type ToolFactory = (cwd: string, sessionContext?: SessionContext) => Tool;
+
+// Tool definitions: static tools and their factory functions
+const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
+	ask: { tool: askTool, create: createAskTool },
+	read: { tool: readTool, create: createReadTool },
+	bash: { tool: bashTool, create: createBashTool },
+	edit: { tool: editTool, create: createEditTool },
+	write: { tool: writeTool, create: createWriteTool },
+	grep: { tool: grepTool, create: createGrepTool },
+	find: { tool: findTool, create: createFindTool },
+	ls: { tool: lsTool, create: createLsTool },
+	lsp: { tool: lspTool, create: createLspTool },
+	notebook: { tool: notebookTool, create: createNotebookTool },
+	task: { tool: taskTool, create: (cwd, ctx) => createTaskTool(cwd, ctx) },
+	web_fetch: { tool: webFetchTool, create: createWebFetchTool },
+	web_search: { tool: webSearchTool, create: createWebSearchTool },
+};
+
+export type ToolName = keyof typeof toolDefs;
+
+// Tools that require UI (excluded when hasUI is false)
+const uiToolNames: ToolName[] = ["ask"];
+
+// Tool sets defined by name (base sets, without UI-only tools)
+const baseCodingToolNames: ToolName[] = [
+	"read",
+	"bash",
+	"edit",
+	"write",
+	"grep",
+	"find",
+	"ls",
+	"lsp",
+	"notebook",
+	"task",
+	"web_fetch",
+	"web_search",
+];
+const baseReadOnlyToolNames: ToolName[] = ["read", "grep", "find", "ls"];
+
+// Default tools for full access mode (using process.cwd(), no UI)
+export const codingTools: Tool[] = baseCodingToolNames.map((name) => toolDefs[name].tool);
+
+// Read-only tools for exploration without modification (using process.cwd(), no UI)
+export const readOnlyTools: Tool[] = baseReadOnlyToolNames.map((name) => toolDefs[name].tool);
+
+// All available tools (using process.cwd(), no UI)
+export const allTools = Object.fromEntries(Object.entries(toolDefs).map(([name, def]) => [name, def.tool])) as Record<
+	ToolName,
+	Tool
+>;
+
+/**
+ * Create coding tools configured for a specific working directory.
+ * @param cwd - Working directory for tools
+ * @param hasUI - Whether UI is available (includes ask tool if true)
+ * @param sessionContext - Optional session context for tools that need it
+ */
+export function createCodingTools(cwd: string, hasUI = false, sessionContext?: SessionContext): Tool[] {
+	const names = hasUI ? [...baseCodingToolNames, ...uiToolNames] : baseCodingToolNames;
+	return names.map((name) => toolDefs[name].create(cwd, sessionContext));
+}
+
+/**
+ * Create read-only tools configured for a specific working directory.
+ * @param cwd - Working directory for tools
+ * @param hasUI - Whether UI is available (includes ask tool if true)
+ * @param sessionContext - Optional session context for tools that need it
+ */
+export function createReadOnlyTools(cwd: string, hasUI = false, sessionContext?: SessionContext): Tool[] {
+	const names = hasUI ? [...baseReadOnlyToolNames, ...uiToolNames] : baseReadOnlyToolNames;
+	return names.map((name) => toolDefs[name].create(cwd, sessionContext));
+}
+
+/**
+ * Create all tools configured for a specific working directory.
+ * @param cwd - Working directory for tools
+ * @param sessionContext - Optional session context for tools that need it
+ */
+export function createAllTools(cwd: string, sessionContext?: SessionContext): Record<ToolName, Tool> {
+	return Object.fromEntries(
+		Object.entries(toolDefs).map(([name, def]) => [name, def.create(cwd, sessionContext)]),
+	) as Record<ToolName, Tool>;
+}
+
+/**
+ * Wrap a bash tool with interception that redirects common patterns to specialized tools.
+ * This helps prevent LLMs from falling back to shell commands when better tools exist.
+ *
+ * @param bashTool - The bash tool to wrap
+ * @param availableTools - Set of tool names that are available (for context-aware blocking)
+ * @returns Wrapped bash tool with interception
+ */
+export function wrapBashWithInterception(bashTool: Tool, availableTools: Set<string>): Tool {
+	const originalExecute = bashTool.execute;
+
+	return {
+		...bashTool,
+		execute: async (toolCallId, params, signal, onUpdate, context) => {
+			const command = (params as { command: string }).command;
+
+			// Check for forbidden patterns
+			const interception = checkBashInterception(command, availableTools);
+			if (interception.block) {
+				throw new Error(interception.message);
+			}
+
+			// Check for simple ls that should use ls tool
+			const lsInterception = checkSimpleLsInterception(command, availableTools);
+			if (lsInterception.block) {
+				throw new Error(lsInterception.message);
+			}
+
+			// Pass through to original bash tool
+			return originalExecute(toolCallId, params, signal, onUpdate, context);
+		},
+	};
+}
+
+/**
+ * Apply bash interception to a set of tools.
+ * Finds the bash tool and wraps it with interception based on other available tools.
+ *
+ * @param tools - Array of tools to process
+ * @returns Tools with bash interception applied
+ */
+export function applyBashInterception(tools: Tool[]): Tool[] {
+	const toolNames = new Set(tools.map((t) => t.name));
+
+	// If bash isn't in the tools, nothing to do
+	if (!toolNames.has("bash")) {
+		return tools;
+	}
+
+	return tools.map((tool) => {
+		if (tool.name === "bash") {
+			return wrapBashWithInterception(tool, toolNames);
+		}
+		return tool;
+	});
+}

package/src/core/tools/ls.ts

@@ -0,0 +1,140 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { existsSync, readdirSync, statSync } from "fs";
+import nodePath from "path";
+import { resolveToCwd } from "./path-utils.js";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
+
+const lsSchema = Type.Object({
+	path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),
+	limit: Type.Optional(Type.Number({ description: "Maximum number of entries to return (default: 500)" })),
+});
+
+const DEFAULT_LIMIT = 500;
+
+export interface LsToolDetails {
+	truncation?: TruncationResult;
+	entryLimitReached?: number;
+}
+
+export function createLsTool(cwd: string): AgentTool<typeof lsSchema> {
+	return {
+		name: "ls",
+		label: "Ls",
+		description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to 500 entries or 50KB (whichever is hit first). List structure helps with directory navigation and finding target files.`,
+		parameters: lsSchema,
+		execute: async (
+			_toolCallId: string,
+			{ path, limit }: { path?: string; limit?: number },
+			signal?: AbortSignal,
+		) => {
+			return new Promise((resolve, reject) => {
+				if (signal?.aborted) {
+					reject(new Error("Operation aborted"));
+					return;
+				}
+
+				const onAbort = () => reject(new Error("Operation aborted"));
+				signal?.addEventListener("abort", onAbort, { once: true });
+
+				try {
+					const dirPath = resolveToCwd(path || ".", cwd);
+					const effectiveLimit = limit ?? DEFAULT_LIMIT;
+
+					// Check if path exists
+					if (!existsSync(dirPath)) {
+						reject(new Error(`Path not found: ${dirPath}`));
+						return;
+					}
+
+					// Check if path is a directory
+					const stat = statSync(dirPath);
+					if (!stat.isDirectory()) {
+						reject(new Error(`Not a directory: ${dirPath}`));
+						return;
+					}
+
+					// Read directory entries
+					let entries: string[];
+					try {
+						entries = readdirSync(dirPath);
+					} catch (e: any) {
+						reject(new Error(`Cannot read directory: ${e.message}`));
+						return;
+					}
+
+					// Sort alphabetically (case-insensitive)
+					entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+
+					// Format entries with directory indicators
+					const results: string[] = [];
+					let entryLimitReached = false;
+
+					for (const entry of entries) {
+						if (results.length >= effectiveLimit) {
+							entryLimitReached = true;
+							break;
+						}
+
+						const fullPath = nodePath.join(dirPath, entry);
+						let suffix = "";
+
+						try {
+							const entryStat = statSync(fullPath);
+							if (entryStat.isDirectory()) {
+								suffix = "/";
+							}
+						} catch {
+							// Skip entries we can't stat
+							continue;
+						}
+
+						results.push(entry + suffix);
+					}
+
+					signal?.removeEventListener("abort", onAbort);
+
+					if (results.length === 0) {
+						resolve({ content: [{ type: "text", text: "(empty directory)" }], details: undefined });
+						return;
+					}
+
+					// 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 = {};
+
+					// Build notices
+					const notices: string[] = [];
+
+					if (entryLimitReached) {
+						notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
+						details.entryLimitReached = effectiveLimit;
+					}
+
+					if (truncation.truncated) {
+						notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+						details.truncation = truncation;
+					}
+
+					if (notices.length > 0) {
+						output += `\n\n[${notices.join(". ")}]`;
+					}
+
+					resolve({
+						content: [{ type: "text", text: output }],
+						details: Object.keys(details).length > 0 ? details : undefined,
+					});
+				} catch (e: any) {
+					signal?.removeEventListener("abort", onAbort);
+					reject(e);
+				}
+			});
+		},
+	};
+}
+
+/** Default ls tool using process.cwd() - for backwards compatibility */
+export const lsTool = createLsTool(process.cwd());