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

package/src/core/tools/exa/types.ts

@@ -0,0 +1,168 @@
+/**
+ * Exa MCP Types
+ *
+ * Types for the Exa MCP client and tool implementations.
+ */
+
+import type { TSchema } from "@sinclair/typebox";
+
+/** MCP endpoint URLs */
+export const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
+export const WEBSETS_MCP_URL = "https://websetsmcp.exa.ai/mcp";
+
+/** MCP tool definition from server */
+export interface MCPTool {
+	name: string;
+	description: string;
+	inputSchema: TSchema;
+}
+
+/** Tool wrapper config for dynamic MCP tool creation */
+export interface MCPToolWrapperConfig {
+	/** Our tool name (e.g., "exa_search") */
+	name: string;
+	/** Display label for UI */
+	label: string;
+	/** MCP tool name to call (e.g., "web_search") */
+	mcpToolName: string;
+	/** Whether this is a websets tool (uses different MCP endpoint) */
+	isWebsetsTool?: boolean;
+}
+
+/** MCP tools/list response */
+export interface MCPToolsResponse {
+	result?: {
+		tools: MCPTool[];
+	};
+	error?: {
+		code: number;
+		message: string;
+	};
+}
+
+/** MCP tools/call response */
+export interface MCPCallResponse {
+	result?: {
+		content?: Array<{ type: string; text?: string }>;
+	};
+	error?: {
+		code: number;
+		message: string;
+	};
+}
+
+/** Search result from Exa */
+export interface ExaSearchResult {
+	id?: string;
+	title?: string;
+	url?: string;
+	author?: string;
+	publishedDate?: string;
+	text?: string;
+	highlights?: string[];
+	image?: string;
+	favicon?: string;
+}
+
+/** Search response from Exa */
+export interface ExaSearchResponse {
+	results?: ExaSearchResult[];
+	statuses?: Array<{ id: string; status: string; source?: string }>;
+	costDollars?: { total: number };
+	searchTime?: number;
+	requestId?: string;
+}
+
+/** Researcher task status */
+export interface ResearcherStatus {
+	id: string;
+	status: "pending" | "running" | "completed" | "failed";
+	result?: string;
+	error?: string;
+}
+
+/** Webset definition */
+export interface Webset {
+	id: string;
+	name: string;
+	description?: string;
+	createdAt?: string;
+	updatedAt?: string;
+}
+
+/** Webset item */
+export interface WebsetItem {
+	id: string;
+	websetId: string;
+	url: string;
+	title?: string;
+	content?: string;
+	metadata?: Record<string, unknown>;
+}
+
+/** Webset search */
+export interface WebsetSearch {
+	id: string;
+	websetId: string;
+	query: string;
+	status: "pending" | "running" | "completed" | "cancelled";
+	resultCount?: number;
+}
+
+/** Webset enrichment */
+export interface WebsetEnrichment {
+	id: string;
+	websetId: string;
+	name: string;
+	prompt: string;
+	status: "pending" | "running" | "completed" | "cancelled";
+}
+
+/** Tool name mappings: MCP name -> our tool name */
+export const EXA_TOOL_MAPPINGS = {
+	// Search tools
+	web_search: "exa_search",
+	deep_search_exa: "exa_search_deep",
+	get_code_context_exa: "exa_search_code",
+	crawling_exa: "exa_crawl",
+	// LinkedIn
+	linkedin_search_exa: "exa_linkedin",
+	// Company
+	company_research_exa: "exa_company",
+	// Researcher
+	deep_researcher_start: "exa_researcher_start",
+	deep_researcher_check: "exa_researcher_poll",
+} as const;
+
+export const WEBSETS_TOOL_MAPPINGS = {
+	create_webset: "webset_create",
+	list_websets: "webset_list",
+	get_webset: "webset_get",
+	update_webset: "webset_update",
+	delete_webset: "webset_delete",
+	list_webset_items: "webset_items_list",
+	get_item: "webset_item_get",
+	create_search: "webset_search_create",
+	get_search: "webset_search_get",
+	cancel_search: "webset_search_cancel",
+	create_enrichment: "webset_enrichment_create",
+	get_enrichment: "webset_enrichment_get",
+	update_enrichment: "webset_enrichment_update",
+	delete_enrichment: "webset_enrichment_delete",
+	cancel_enrichment: "webset_enrichment_cancel",
+	create_monitor: "webset_monitor_create",
+} as const;
+
+export type ExaMcpToolName = keyof typeof EXA_TOOL_MAPPINGS;
+export type WebsetsMcpToolName = keyof typeof WEBSETS_TOOL_MAPPINGS;
+export type ExaToolName = (typeof EXA_TOOL_MAPPINGS)[ExaMcpToolName];
+export type WebsetsToolName = (typeof WEBSETS_TOOL_MAPPINGS)[WebsetsMcpToolName];
+
+/** Render details for TUI */
+export interface ExaRenderDetails {
+	response?: ExaSearchResponse;
+	error?: string;
+	toolName?: string;
+	/** Raw result for non-search responses */
+	raw?: unknown;
+}

package/src/core/tools/exa/websets.ts

@@ -0,0 +1,248 @@
+/**
+ * Exa Websets Tools
+ *
+ * CRUD operations for websets, items, searches, enrichments, and monitoring.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { CustomTool } from "../../custom-tools/types.js";
+import { callWebsetsTool, findApiKey } from "./mcp-client.js";
+import type { ExaRenderDetails } from "./types.js";
+
+/** Helper to create a websets tool with proper execute signature */
+function createWebsetTool(
+	name: string,
+	label: string,
+	description: string,
+	parameters: ReturnType<typeof Type.Object>,
+	mcpToolName: string,
+): CustomTool<any, ExaRenderDetails> {
+	return {
+		name,
+		label,
+		description,
+		parameters,
+		async execute(_toolCallId, params, _onUpdate, _ctx, _signal) {
+			try {
+				const apiKey = await findApiKey();
+				if (!apiKey) {
+					return {
+						content: [{ type: "text" as const, text: "Error: EXA_API_KEY not found" }],
+						details: { error: "EXA_API_KEY not found", toolName: name },
+					};
+				}
+				const result = await callWebsetsTool(apiKey, mcpToolName, params as Record<string, unknown>);
+				return {
+					content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+					details: { raw: result, toolName: name },
+				};
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text" as const, text: `Error: ${message}` }],
+					details: { error: message, toolName: name },
+				};
+			}
+		},
+	};
+}
+
+// CRUD Operations
+const websetCreateTool = createWebsetTool(
+	"webset_create",
+	"Create Webset",
+	"Create a new webset collection for organizing web content.",
+	Type.Object({
+		name: Type.String({ description: "Name of the webset" }),
+		description: Type.Optional(Type.String({ description: "Optional description" })),
+	}),
+	"create_webset",
+);
+
+const websetListTool = createWebsetTool(
+	"webset_list",
+	"List Websets",
+	"List all websets in your account.",
+	Type.Object({}),
+	"list_websets",
+);
+
+const websetGetTool = createWebsetTool(
+	"webset_get",
+	"Get Webset",
+	"Get details of a specific webset by ID.",
+	Type.Object({
+		id: Type.String({ description: "Webset ID" }),
+	}),
+	"get_webset",
+);
+
+const websetUpdateTool = createWebsetTool(
+	"webset_update",
+	"Update Webset",
+	"Update a webset's name or description.",
+	Type.Object({
+		id: Type.String({ description: "Webset ID" }),
+		name: Type.Optional(Type.String({ description: "New name" })),
+		description: Type.Optional(Type.String({ description: "New description" })),
+	}),
+	"update_webset",
+);
+
+const websetDeleteTool = createWebsetTool(
+	"webset_delete",
+	"Delete Webset",
+	"Delete a webset and all its contents.",
+	Type.Object({
+		id: Type.String({ description: "Webset ID" }),
+	}),
+	"delete_webset",
+);
+
+// Item Management
+const websetItemsListTool = createWebsetTool(
+	"webset_items_list",
+	"List Webset Items",
+	"List items in a webset with optional pagination.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		limit: Type.Optional(Type.Number({ description: "Number of items to return" })),
+		offset: Type.Optional(Type.Number({ description: "Pagination offset" })),
+	}),
+	"list_webset_items",
+);
+
+const websetItemGetTool = createWebsetTool(
+	"webset_item_get",
+	"Get Webset Item",
+	"Get a specific item from a webset.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		item_id: Type.String({ description: "Item ID" }),
+	}),
+	"get_item",
+);
+
+// Search Operations
+const websetSearchCreateTool = createWebsetTool(
+	"webset_search_create",
+	"Create Webset Search",
+	"Create a new search within a webset.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		query: Type.String({ description: "Search query" }),
+	}),
+	"create_search",
+);
+
+const websetSearchGetTool = createWebsetTool(
+	"webset_search_get",
+	"Get Webset Search",
+	"Get the status and results of a webset search.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		search_id: Type.String({ description: "Search ID" }),
+	}),
+	"get_search",
+);
+
+const websetSearchCancelTool = createWebsetTool(
+	"webset_search_cancel",
+	"Cancel Webset Search",
+	"Cancel a running webset search.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		search_id: Type.String({ description: "Search ID" }),
+	}),
+	"cancel_search",
+);
+
+// Enrichment Operations
+const websetEnrichmentCreateTool = createWebsetTool(
+	"webset_enrichment_create",
+	"Create Enrichment",
+	"Create a new enrichment task for a webset.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		name: Type.String({ description: "Enrichment name" }),
+		prompt: Type.String({ description: "Enrichment prompt" }),
+	}),
+	"create_enrichment",
+);
+
+const websetEnrichmentGetTool = createWebsetTool(
+	"webset_enrichment_get",
+	"Get Enrichment",
+	"Get the status and results of an enrichment task.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		enrichment_id: Type.String({ description: "Enrichment ID" }),
+	}),
+	"get_enrichment",
+);
+
+const websetEnrichmentUpdateTool = createWebsetTool(
+	"webset_enrichment_update",
+	"Update Enrichment",
+	"Update an enrichment's name or prompt.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		enrichment_id: Type.String({ description: "Enrichment ID" }),
+		name: Type.Optional(Type.String({ description: "New name" })),
+		prompt: Type.Optional(Type.String({ description: "New prompt" })),
+	}),
+	"update_enrichment",
+);
+
+const websetEnrichmentDeleteTool = createWebsetTool(
+	"webset_enrichment_delete",
+	"Delete Enrichment",
+	"Delete an enrichment task.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		enrichment_id: Type.String({ description: "Enrichment ID" }),
+	}),
+	"delete_enrichment",
+);
+
+const websetEnrichmentCancelTool = createWebsetTool(
+	"webset_enrichment_cancel",
+	"Cancel Enrichment",
+	"Cancel a running enrichment task.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		enrichment_id: Type.String({ description: "Enrichment ID" }),
+	}),
+	"cancel_enrichment",
+);
+
+// Monitoring
+const websetMonitorCreateTool = createWebsetTool(
+	"webset_monitor_create",
+	"Create Monitor",
+	"Create a monitoring task for a webset with optional webhook notifications.",
+	Type.Object({
+		webset_id: Type.String({ description: "Webset ID" }),
+		webhook_url: Type.Optional(Type.String({ description: "Webhook URL for notifications" })),
+	}),
+	"create_monitor",
+);
+
+export const websetsTools: CustomTool<any, ExaRenderDetails>[] = [
+	websetCreateTool,
+	websetListTool,
+	websetGetTool,
+	websetUpdateTool,
+	websetDeleteTool,
+	websetItemsListTool,
+	websetItemGetTool,
+	websetSearchCreateTool,
+	websetSearchGetTool,
+	websetSearchCancelTool,
+	websetEnrichmentCreateTool,
+	websetEnrichmentGetTool,
+	websetEnrichmentUpdateTool,
+	websetEnrichmentDeleteTool,
+	websetEnrichmentCancelTool,
+	websetMonitorCreateTool,
+];

package/src/core/tools/find.ts

@@ -0,0 +1,261 @@
+import { existsSync, type Stats, statSync } from "node:fs";
+import path from "node:path";
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { globSync } from "glob";
+import { ensureTool } from "../../utils/tools-manager.js";
+import { resolveToCwd } from "./path-utils.js";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
+
+const findSchema = Type.Object({
+	pattern: Type.String({
+		description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'",
+	}),
+	path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
+	limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
+	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files (default: false)" })),
+	sortByMtime: Type.Optional(
+		Type.Boolean({ description: "Sort results by modification time, most recent first (default: false)" }),
+	),
+	type: Type.Optional(
+		Type.Union([Type.Literal("file"), Type.Literal("dir"), Type.Literal("all")], {
+			description:
+				"Filter by type: 'file' for files only, 'dir' for directories only, 'all' for both (default: 'all')",
+		}),
+	),
+});
+
+const DEFAULT_LIMIT = 1000;
+
+export interface FindToolDetails {
+	truncation?: TruncationResult;
+	resultLimitReached?: number;
+	// Fields for TUI rendering
+	fileCount?: number;
+	files?: string[];
+	truncated?: boolean;
+	error?: string;
+}
+
+export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
+	return {
+		name: "find",
+		label: "Find",
+		description: `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
+- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.`,
+		parameters: findSchema,
+		execute: async (
+			_toolCallId: string,
+			{
+				pattern,
+				path: searchDir,
+				limit,
+				hidden,
+				sortByMtime,
+				type,
+			}: {
+				pattern: string;
+				path?: string;
+				limit?: number;
+				hidden?: boolean;
+				sortByMtime?: boolean;
+				type?: "file" | "dir" | "all";
+			},
+			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 });
+
+				(async () => {
+					try {
+						// Ensure fd is available
+						const fdPath = await ensureTool("fd", true);
+						if (!fdPath) {
+							reject(new Error("fd is not available and could not be downloaded"));
+							return;
+						}
+
+						const searchPath = resolveToCwd(searchDir || ".", cwd);
+						const effectiveLimit = limit ?? DEFAULT_LIMIT;
+						const effectiveType = type ?? "all";
+						const includeHidden = hidden ?? false;
+						const shouldSortByMtime = sortByMtime ?? false;
+
+						// Build fd arguments
+						const args: string[] = [
+							"--glob", // Use glob pattern
+							"--color=never", // No ANSI colors
+							"--max-results",
+							String(effectiveLimit),
+						];
+
+						if (includeHidden) {
+							args.push("--hidden");
+						}
+
+						// Add type filter
+						if (effectiveType === "file") {
+							args.push("--type", "f");
+						} else if (effectiveType === "dir") {
+							args.push("--type", "d");
+						}
+
+						// Include .gitignore files (root + nested) so fd respects them even outside git repos
+						const gitignoreFiles = new Set<string>();
+						const rootGitignore = path.join(searchPath, ".gitignore");
+						if (existsSync(rootGitignore)) {
+							gitignoreFiles.add(rootGitignore);
+						}
+
+						try {
+							const nestedGitignores = globSync("**/.gitignore", {
+								cwd: searchPath,
+								dot: true,
+								absolute: true,
+								ignore: ["**/node_modules/**", "**/.git/**"],
+							});
+							for (const file of nestedGitignores) {
+								gitignoreFiles.add(file);
+							}
+						} catch {
+							// Ignore glob errors
+						}
+
+						for (const gitignorePath of gitignoreFiles) {
+							args.push("--ignore-file", gitignorePath);
+						}
+
+						// Pattern and path
+						args.push(pattern, searchPath);
+
+						// Run fd
+						const result = Bun.spawnSync([fdPath, ...args], {
+							stdin: "ignore",
+							stdout: "pipe",
+							stderr: "pipe",
+						});
+
+						signal?.removeEventListener("abort", onAbort);
+
+						const output = result.stdout.toString().trim();
+
+						if (result.exitCode !== 0) {
+							const errorMsg = result.stderr.toString().trim() || `fd exited with code ${result.exitCode}`;
+							// fd returns non-zero for some errors but may still have partial output
+							if (!output) {
+								reject(new Error(errorMsg));
+								return;
+							}
+						}
+
+						if (!output) {
+							resolve({
+								content: [{ type: "text", text: "No files found matching pattern" }],
+								details: { fileCount: 0, files: [], truncated: false },
+							});
+							return;
+						}
+
+						const lines = output.split("\n");
+						const relativized: string[] = [];
+						const mtimes: number[] = [];
+
+						for (const rawLine of lines) {
+							const line = rawLine.replace(/\r$/, "").trim();
+							if (!line) {
+								continue;
+							}
+
+							const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
+							let relativePath = line;
+							if (line.startsWith(searchPath)) {
+								relativePath = line.slice(searchPath.length + 1); // +1 for the /
+							} else {
+								relativePath = path.relative(searchPath, line);
+							}
+
+							if (hadTrailingSlash && !relativePath.endsWith("/")) {
+								relativePath += "/";
+							}
+
+							relativized.push(relativePath);
+
+							// Collect mtime if sorting is requested
+							if (shouldSortByMtime) {
+								try {
+									const fullPath = path.join(searchPath, relativePath);
+									const stat: Stats = statSync(fullPath);
+									mtimes.push(stat.mtimeMs);
+								} catch {
+									mtimes.push(0);
+								}
+							}
+						}
+
+						// Sort by mtime if requested (most recent first)
+						if (shouldSortByMtime && relativized.length > 0) {
+							const indexed = relativized.map((path, idx) => ({ path, mtime: mtimes[idx] || 0 }));
+							indexed.sort((a, b) => b.mtime - a.mtime);
+							relativized.length = 0;
+							relativized.push(...indexed.map((item) => item.path));
+						}
+
+						// Check if we hit the result limit
+						const resultLimitReached = relativized.length >= effectiveLimit;
+
+						// Apply byte truncation (no line limit since we already have result limit)
+						const rawOutput = relativized.join("\n");
+						const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+
+						let resultOutput = truncation.content;
+						const details: FindToolDetails = {
+							fileCount: relativized.length,
+							files: relativized.slice(0, 50),
+							truncated: resultLimitReached || truncation.truncated,
+						};
+
+						// Build notices
+						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(". ")}]`;
+						}
+
+						resolve({
+							content: [{ type: "text", text: resultOutput }],
+							details: Object.keys(details).length > 0 ? details : undefined,
+						});
+					} catch (e: any) {
+						signal?.removeEventListener("abort", onAbort);
+						reject(e);
+					}
+				})();
+			});
+		},
+	};
+}
+
+/** Default find tool using process.cwd() - for backwards compatibility */
+export const findTool = createFindTool(process.cwd());