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

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";
+import { callWebsetsTool, findApiKey } from "./mcp-client";
+import type { ExaRenderDetails } from "./types";
+
+/** 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,244 @@
+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 findDescription from "../../prompts/tools/find.md" with { type: "text" };
+import { ensureTool } from "../../utils/tools-manager";
+import { untilAborted } from "../utils";
+import { resolveToCwd } from "./path-utils";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
+
+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
+	scopePath?: string;
+	fileCount?: number;
+	files?: string[];
+	truncated?: boolean;
+	error?: string;
+}
+
+export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
+	return {
+		name: "find",
+		label: "Find",
+		description: findDescription,
+		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 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 || ".", cwd);
+				const scopePath = (() => {
+					const relative = path.relative(cwd, searchPath).replace(/\\/g, "/");
+					return relative.length === 0 ? "." : relative;
+				})();
+				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",
+				});
+
+				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) {
+						throw new Error(errorMsg);
+					}
+				}
+
+				if (!output) {
+					return {
+						content: [{ type: "text", text: "No files found matching pattern" }],
+						details: { scopePath, fileCount: 0, files: [], truncated: false },
+					};
+				}
+
+				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 = {
+					scopePath,
+					fileCount: relativized.length,
+					files: relativized,
+					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(". ")}]`;
+				}
+
+				return {
+					content: [{ type: "text", text: resultOutput }],
+					details: Object.keys(details).length > 0 ? details : undefined,
+				};
+			});
+		},
+	};
+}
+
+/** Default find tool using process.cwd() - for backwards compatibility */
+export const findTool = createFindTool(process.cwd());