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

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

@@ -0,0 +1,196 @@
+/**
+ * Exa TUI Rendering
+ *
+ * Tree-based rendering with collapsed/expanded states for Exa search results.
+ */
+
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import type { Theme } from "../../../modes/interactive/theme/theme.js";
+import type { RenderResultOptions } from "../../custom-tools/types.js";
+import { logViewError } from "./logger.js";
+import type { ExaRenderDetails } from "./types.js";
+
+// Tree formatting constants
+const TREE_MID = "├─";
+const TREE_END = "└─";
+const TREE_PIPE = "│";
+const TREE_SPACE = " ";
+const TREE_HOOK = "⎿";
+
+/** Truncate text to max length with ellipsis */
+function truncate(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	return `${text.slice(0, maxLen - 1)}…`;
+}
+
+/** Extract domain from URL */
+function getDomain(url: string): string {
+	try {
+		const u = new URL(url);
+		return u.hostname.replace(/^www\./, "");
+	} catch {
+		return url;
+	}
+}
+
+/** Get first N lines of text as preview */
+function getPreviewLines(text: string, maxLines: number, maxLineLen: number): string[] {
+	const lines = text.split("\n").filter((l) => l.trim());
+	return lines.slice(0, maxLines).map((l) => truncate(l.trim(), maxLineLen));
+}
+
+/** Render Exa result with tree-based layout */
+export function renderExaResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: ExaRenderDetails },
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	const { expanded } = options;
+	const details = result.details;
+
+	// Handle error case
+	if (details?.error) {
+		logViewError("Exa render error", { error: details.error, toolName: details.toolName });
+		return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+	}
+
+	const response = details?.response;
+	if (!response) {
+		// Non-search response: show raw result
+		if (details?.raw) {
+			const rawText = typeof details.raw === "string" ? details.raw : JSON.stringify(details.raw, null, 2);
+			const preview = expanded ? rawText : truncate(rawText, 200);
+			const toolLabel = details?.toolName ?? "Exa";
+			return new Text(
+				`${theme.fg("success", "●")} ${theme.fg("toolTitle", toolLabel)}\n ${theme.fg("dim", TREE_PIPE)}  ${preview}`,
+				0,
+				0,
+			);
+		}
+		return new Text(theme.fg("error", "No response data"), 0, 0);
+	}
+
+	const results = response.results ?? [];
+	const resultCount = results.length;
+	const cost = response.costDollars?.total;
+	const time = response.searchTime;
+
+	// Build header: ● Exa Search · N results · $X.XX · Xs
+	const icon = resultCount > 0 ? theme.fg("success", "●") : theme.fg("warning", "●");
+	const expandHint = expanded ? "" : theme.fg("dim", " (Ctrl+O to expand)");
+	const toolLabel = details?.toolName ?? "Exa Search";
+
+	let headerParts = `${icon} ${theme.fg("toolTitle", toolLabel)} · ${theme.fg(
+		"dim",
+		`${resultCount} result${resultCount !== 1 ? "s" : ""}`,
+	)}`;
+
+	if (cost !== undefined) {
+		headerParts += ` · ${theme.fg("muted", `$${cost.toFixed(4)}`)}`;
+	}
+	if (time !== undefined) {
+		headerParts += ` · ${theme.fg("muted", `${time.toFixed(2)}s`)}`;
+	}
+
+	let text = headerParts + expandHint;
+
+	if (!expanded) {
+		// Collapsed view: show 3-line preview from first result
+		if (resultCount > 0) {
+			const first = results[0];
+			const previewText = first.text ?? first.title ?? "";
+			const previewLines = getPreviewLines(previewText, 3, 100);
+
+			for (const line of previewLines) {
+				text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", line)}`;
+			}
+
+			const totalLines = previewText.split("\n").filter((l) => l.trim()).length;
+			if (totalLines > 3) {
+				text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("muted", `… ${totalLines - 3} more lines`)}`;
+			}
+
+			if (resultCount > 1) {
+				text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg(
+					"muted",
+					`${resultCount - 1} more result${resultCount !== 2 ? "s" : ""}`,
+				)}`;
+			}
+		}
+	} else {
+		// Expanded view: full results tree
+		if (resultCount > 0) {
+			text += `\n ${theme.fg("dim", TREE_PIPE)}`;
+			text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg("accent", "Results")}`;
+
+			for (let i = 0; i < results.length; i++) {
+				const res = results[i];
+				const isLast = i === results.length - 1;
+				const branch = isLast ? TREE_END : TREE_MID;
+				const cont = isLast ? TREE_SPACE : TREE_PIPE;
+
+				// Title + domain
+				const title = truncate(res.title ?? "Untitled", 60);
+				const domain = res.url ? getDomain(res.url) : "";
+				const domainPart = domain ? theme.fg("dim", ` (${domain})`) : "";
+
+				text += `\n ${theme.fg("dim", TREE_SPACE)} ${theme.fg("dim", branch)} ${theme.fg(
+					"accent",
+					title,
+				)}${domainPart}`;
+
+				// URL
+				if (res.url) {
+					text += `\n ${theme.fg("dim", cont)}   ${theme.fg("dim", TREE_HOOK)} ${theme.fg("mdLinkUrl", res.url)}`;
+				}
+
+				// Author
+				if (res.author) {
+					text += `\n ${theme.fg("dim", cont)}   ${theme.fg("muted", `Author: ${res.author}`)}`;
+				}
+
+				// Published date
+				if (res.publishedDate) {
+					text += `\n ${theme.fg("dim", cont)}   ${theme.fg("muted", `Published: ${res.publishedDate}`)}`;
+				}
+
+				// Text content
+				if (res.text) {
+					const textLines = res.text.split("\n").filter((l) => l.trim());
+					const displayLines = textLines.slice(0, 5); // Show first 5 lines
+					for (const line of displayLines) {
+						text += `\n ${theme.fg("dim", cont)}   ${truncate(line.trim(), 90)}`;
+					}
+					if (textLines.length > 5) {
+						text += `\n ${theme.fg("dim", cont)}   ${theme.fg("muted", `… ${textLines.length - 5} more lines`)}`;
+					}
+				}
+
+				// Highlights
+				if (res.highlights?.length) {
+					text += `\n ${theme.fg("dim", cont)}   ${theme.fg("accent", "Highlights:")}`;
+					for (let j = 0; j < Math.min(res.highlights.length, 3); j++) {
+						const h = res.highlights[j];
+						text += `\n ${theme.fg("dim", cont)}   ${theme.fg("muted", `• ${truncate(h, 80)}`)}`;
+					}
+					if (res.highlights.length > 3) {
+						text += `\n ${theme.fg("dim", cont)}   ${theme.fg("muted", `… ${res.highlights.length - 3} more`)}`;
+					}
+				}
+			}
+		}
+	}
+
+	return new Text(text, 0, 0);
+}
+
+/** Render Exa call (query/args preview) */
+export function renderExaCall(args: Record<string, unknown>, toolName: string, theme: Theme): Component {
+	const query = typeof args.query === "string" ? truncate(args.query, 80) : "";
+	const numResults = typeof args.num_results === "number" ? args.num_results : undefined;
+	const detail = numResults ? theme.fg("dim", ` (${numResults} results)`) : "";
+
+	const text = `${theme.fg("toolTitle", toolName)} ${theme.fg("muted", query)}${detail}`;
+	return new Text(text, 0, 0);
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Exa Researcher Tools
+ *
+ * Async research tasks with polling for completion.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { CustomTool } from "../../custom-tools/types.js";
+import { callExaTool, findApiKey } from "./mcp-client.js";
+import type { ExaRenderDetails } from "./types.js";
+
+const researcherStartTool: CustomTool<any, ExaRenderDetails> = {
+	name: "exa_researcher_start",
+	label: "Start Deep Research",
+	description:
+		"Start an asynchronous deep research task using Exa's researcher. Returns a task_id for polling completion.",
+	parameters: Type.Object({
+		query: Type.String({ description: "Research query to investigate" }),
+		depth: Type.Optional(
+			Type.Number({
+				description: "Research depth (1-5, default: 3)",
+				minimum: 1,
+				maximum: 5,
+			}),
+		),
+		breadth: Type.Optional(
+			Type.Number({
+				description: "Research breadth (1-5, default: 3)",
+				minimum: 1,
+				maximum: 5,
+			}),
+		),
+	}),
+	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: "exa_researcher_start" },
+				};
+			}
+			const result = await callExaTool("deep_researcher_start", params as Record<string, unknown>, apiKey);
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+				details: { raw: result, toolName: "exa_researcher_start" },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message, toolName: "exa_researcher_start" },
+			};
+		}
+	},
+};
+
+const researcherPollTool: CustomTool<any, ExaRenderDetails> = {
+	name: "exa_researcher_poll",
+	label: "Poll Research Status",
+	description:
+		"Poll the status of an asynchronous research task. Returns status (pending|running|completed|failed) and result if completed.",
+	parameters: Type.Object({
+		task_id: Type.String({ description: "Task ID returned from exa_researcher_start" }),
+	}),
+	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: "exa_researcher_poll" },
+				};
+			}
+			const result = await callExaTool("deep_researcher_check", params as Record<string, unknown>, apiKey);
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+				details: { raw: result, toolName: "exa_researcher_poll" },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message, toolName: "exa_researcher_poll" },
+			};
+		}
+	},
+};
+
+export const researcherTools: CustomTool<any, ExaRenderDetails>[] = [researcherStartTool, researcherPollTool];

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

@@ -0,0 +1,337 @@
+/**
+ * Exa Search Tools
+ *
+ * Basic neural/keyword search, deep research, code search, and URL crawling.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { CustomTool } from "../../custom-tools/types.js";
+import type { ExaRenderDetails } from "./types.js";
+
+/** exa_search - Basic neural/keyword search */
+const exaSearchTool: CustomTool<any, ExaRenderDetails> = {
+	name: "exa_search",
+	label: "Exa Search",
+	description: `Search the web using Exa's neural or keyword search.
+
+Returns structured search results with optional text content and highlights.
+
+Parameters:
+- query: Search query (required)
+- type: Search type - "neural" (semantic), "keyword" (exact), or "auto" (default: auto)
+- include_domains: Array of domains to include in results
+- exclude_domains: Array of domains to exclude from results
+- start_published_date: Filter results published after this date (ISO 8601)
+- end_published_date: Filter results published before this date (ISO 8601)
+- use_autoprompt: Let Exa optimize your query automatically (default: true)
+- text: Include page text content in results (default: false, costs more)
+- highlights: Include highlighted relevant snippets (default: false)
+- num_results: Maximum number of results to return (default: 10, max: 100)`,
+
+	parameters: Type.Object({
+		query: Type.String({ description: "Search query" }),
+		type: Type.Optional(
+			Type.Union([Type.Literal("keyword"), Type.Literal("neural"), Type.Literal("auto")], {
+				description: "Search type - neural (semantic), keyword (exact), or auto",
+			}),
+		),
+		include_domains: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Only include results from these domains",
+			}),
+		),
+		exclude_domains: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Exclude results from these domains",
+			}),
+		),
+		start_published_date: Type.Optional(
+			Type.String({
+				description: "Filter results published after this date (ISO 8601 format)",
+			}),
+		),
+		end_published_date: Type.Optional(
+			Type.String({
+				description: "Filter results published before this date (ISO 8601 format)",
+			}),
+		),
+		use_autoprompt: Type.Optional(
+			Type.Boolean({
+				description: "Let Exa optimize your query automatically (default: true)",
+			}),
+		),
+		text: Type.Optional(
+			Type.Boolean({
+				description: "Include page text content in results (costs more, default: false)",
+			}),
+		),
+		highlights: Type.Optional(
+			Type.Boolean({
+				description: "Include highlighted relevant snippets (default: false)",
+			}),
+		),
+		num_results: Type.Optional(
+			Type.Number({
+				description: "Maximum number of results to return (default: 10, max: 100)",
+				minimum: 1,
+				maximum: 100,
+			}),
+		),
+	}),
+
+	async execute(_toolCallId, params, _onUpdate, _ctx, _signal) {
+		try {
+			// Dynamic imports to avoid circular dependencies
+			const { findApiKey, callExaTool, formatSearchResults, isSearchResponse } = await import("./mcp-client.js");
+
+			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: "exa_search" },
+				};
+			}
+			const response = await callExaTool("web_search", params, apiKey);
+
+			if (isSearchResponse(response)) {
+				const formatted = formatSearchResults(response);
+				return {
+					content: [{ type: "text" as const, text: formatted }],
+					details: { response, toolName: "exa_search" },
+				};
+			}
+
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+				details: { raw: response, toolName: "exa_search" },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message, toolName: "exa_search" },
+			};
+		}
+	},
+};
+
+/** exa_search_deep - AI-synthesized deep research */
+const exaSearchDeepTool: CustomTool<any, ExaRenderDetails> = {
+	name: "exa_search_deep",
+	label: "Exa Deep Search",
+	description: `Perform AI-synthesized deep research using Exa.
+
+Returns comprehensive research with synthesized answers and multiple sources.
+
+Similar parameters to exa_search, optimized for research depth.`,
+
+	parameters: Type.Object({
+		query: Type.String({ description: "Research query" }),
+		type: Type.Optional(
+			Type.Union([Type.Literal("keyword"), Type.Literal("neural"), Type.Literal("auto")], {
+				description: "Search type - neural (semantic), keyword (exact), or auto",
+			}),
+		),
+		include_domains: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Only include results from these domains",
+			}),
+		),
+		exclude_domains: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Exclude results from these domains",
+			}),
+		),
+		start_published_date: Type.Optional(
+			Type.String({
+				description: "Filter results published after this date (ISO 8601 format)",
+			}),
+		),
+		end_published_date: Type.Optional(
+			Type.String({
+				description: "Filter results published before this date (ISO 8601 format)",
+			}),
+		),
+		use_autoprompt: Type.Optional(
+			Type.Boolean({
+				description: "Let Exa optimize your query automatically (default: true)",
+			}),
+		),
+		text: Type.Optional(
+			Type.Boolean({
+				description: "Include page text content in results (costs more, default: false)",
+			}),
+		),
+		highlights: Type.Optional(
+			Type.Boolean({
+				description: "Include highlighted relevant snippets (default: false)",
+			}),
+		),
+		num_results: Type.Optional(
+			Type.Number({
+				description: "Maximum number of results to return (default: 10, max: 100)",
+				minimum: 1,
+				maximum: 100,
+			}),
+		),
+	}),
+
+	async execute(_toolCallId, params, _onUpdate, _ctx, _signal) {
+		try {
+			const { findApiKey, callExaTool, formatSearchResults, isSearchResponse } = await import("./mcp-client.js");
+
+			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: "exa_search_deep" },
+				};
+			}
+			const response = await callExaTool("deep_search_exa", params, apiKey);
+
+			if (isSearchResponse(response)) {
+				const formatted = formatSearchResults(response);
+				return {
+					content: [{ type: "text" as const, text: formatted }],
+					details: { response, toolName: "exa_search_deep" },
+				};
+			}
+
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+				details: { raw: response, toolName: "exa_search_deep" },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message, toolName: "exa_search_deep" },
+			};
+		}
+	},
+};
+
+/** exa_search_code - Code-focused search */
+const exaSearchCodeTool: CustomTool<any, ExaRenderDetails> = {
+	name: "exa_search_code",
+	label: "Exa Code Search",
+	description: `Search for code examples and technical documentation using Exa.
+
+Optimized for finding code snippets, API documentation, and technical content.
+
+Parameters:
+- query: Code or technical search query (required)
+- code_context: Additional context about what you're looking for`,
+
+	parameters: Type.Object({
+		query: Type.String({ description: "Code or technical search query" }),
+		code_context: Type.Optional(
+			Type.String({
+				description: "Additional context about what you're looking for",
+			}),
+		),
+	}),
+
+	async execute(_toolCallId, params, _onUpdate, _ctx, _signal) {
+		try {
+			const { findApiKey, callExaTool, formatSearchResults, isSearchResponse } = await import("./mcp-client.js");
+
+			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: "exa_search_code" },
+				};
+			}
+			const response = await callExaTool("get_code_context_exa", params, apiKey);
+
+			if (isSearchResponse(response)) {
+				const formatted = formatSearchResults(response);
+				return {
+					content: [{ type: "text" as const, text: formatted }],
+					details: { response, toolName: "exa_search_code" },
+				};
+			}
+
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+				details: { raw: response, toolName: "exa_search_code" },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message, toolName: "exa_search_code" },
+			};
+		}
+	},
+};
+
+/** exa_crawl - URL content extraction */
+const exaCrawlTool: CustomTool<any, ExaRenderDetails> = {
+	name: "exa_crawl",
+	label: "Exa Crawl",
+	description: `Extract content from a specific URL using Exa.
+
+Returns the page content with optional text and highlights.
+
+Parameters:
+- url: URL to crawl (required)
+- text: Include full page text content (default: false)
+- highlights: Include highlighted relevant snippets (default: false)`,
+
+	parameters: Type.Object({
+		url: Type.String({ description: "URL to crawl and extract content from" }),
+		text: Type.Optional(
+			Type.Boolean({
+				description: "Include full page text content (default: false)",
+			}),
+		),
+		highlights: Type.Optional(
+			Type.Boolean({
+				description: "Include highlighted relevant snippets (default: false)",
+			}),
+		),
+	}),
+
+	async execute(_toolCallId, params, _onUpdate, _ctx, _signal) {
+		try {
+			const { findApiKey, callExaTool, formatSearchResults, isSearchResponse } = await import("./mcp-client.js");
+
+			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: "exa_crawl" },
+				};
+			}
+			const response = await callExaTool("crawling_exa", params, apiKey);
+
+			if (isSearchResponse(response)) {
+				const formatted = formatSearchResults(response);
+				return {
+					content: [{ type: "text" as const, text: formatted }],
+					details: { response, toolName: "exa_crawl" },
+				};
+			}
+
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+				details: { raw: response, toolName: "exa_crawl" },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message, toolName: "exa_crawl" },
+			};
+		}
+	},
+};
+
+export const searchTools: CustomTool<any, ExaRenderDetails>[] = [
+	exaSearchTool,
+	exaSearchDeepTool,
+	exaSearchCodeTool,
+	exaCrawlTool,
+];