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

package/src/core/tools/web-search/render.ts

@@ -0,0 +1,182 @@
+/**
+ * Web Search TUI Rendering
+ *
+ * Tree-based rendering with collapsed/expanded states for web 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 type { WebSearchResponse } 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 */
+export function truncate(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	return `${text.slice(0, maxLen - 1)}…`;
+}
+
+/** Extract domain from URL */
+export function getDomain(url: string): string {
+	try {
+		const u = new URL(url);
+		return u.hostname.replace(/^www\./, "");
+	} catch {
+		return url;
+	}
+}
+
+/** Format age string from seconds */
+export function formatAge(ageSeconds: number | null | undefined): string {
+	if (!ageSeconds) return "";
+	const mins = Math.floor(ageSeconds / 60);
+	const hours = Math.floor(mins / 60);
+	const days = Math.floor(hours / 24);
+	const weeks = Math.floor(days / 7);
+	const months = Math.floor(days / 30);
+
+	if (months > 0) return `${months}mo ago`;
+	if (weeks > 0) return `${weeks}w ago`;
+	if (days > 0) return `${days}d ago`;
+	if (hours > 0) return `${hours}h ago`;
+	if (mins > 0) return `${mins}m ago`;
+	return "just now";
+}
+
+/** Get first N lines of text as preview */
+export 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));
+}
+
+export interface WebSearchRenderDetails {
+	response: WebSearchResponse;
+	error?: string;
+}
+
+/** Render web search result with tree-based layout */
+export function renderWebSearchResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: WebSearchRenderDetails },
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	const { expanded } = options;
+	const details = result.details;
+
+	// Handle error case
+	if (details?.error) {
+		return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+	}
+
+	const response = details?.response;
+	if (!response) {
+		return new Text(theme.fg("error", "No response data"), 0, 0);
+	}
+
+	const sources = response.sources ?? [];
+	const sourceCount = sources.length;
+	const _modelName = response.model ?? response.provider;
+	const provider = response.provider;
+
+	// Build header: ● Web Search (provider/model) · N sources
+	const icon = sourceCount > 0 ? theme.fg("success", "●") : theme.fg("warning", "●");
+	const expandHint = expanded ? "" : theme.fg("dim", " (Ctrl+O to expand)");
+	const providerLabel = provider === "anthropic" ? "Anthropic" : "Perplexity";
+	let text = `${icon} ${theme.fg("toolTitle", "Web Search")} ${theme.fg("dim", `(${providerLabel})`)} · ${theme.fg(
+		"dim",
+		`${sourceCount} source${sourceCount !== 1 ? "s" : ""}`,
+	)}${expandHint}`;
+
+	// Get answer text
+	const contentText = response.answer ?? result.content[0]?.text ?? "";
+
+	if (!expanded) {
+		// Collapsed view: show 2-3 preview lines of answer
+		const previewLines = getPreviewLines(contentText, 3, 100);
+		for (const line of previewLines) {
+			text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", line)}`;
+		}
+		const totalLines = contentText.split("\n").filter((l) => l.trim()).length;
+		if (totalLines > 3) {
+			text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("muted", `… ${totalLines - 3} more lines`)}`;
+		}
+
+		// Show source count summary
+		if (sourceCount > 0) {
+			text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg(
+				"muted",
+				`${sourceCount} source${sourceCount !== 1 ? "s" : ""}`,
+			)}`;
+		}
+	} else {
+		// Expanded view: full answer + source tree
+		const answerLines = contentText.split("\n");
+		for (const line of answerLines) {
+			text += `\n ${theme.fg("dim", TREE_PIPE)}  ${line}`;
+		}
+
+		// Render sources as tree
+		const hasRelatedQuestions = response.relatedQuestions && response.relatedQuestions.length > 0;
+
+		if (sourceCount > 0) {
+			text += `\n ${theme.fg("dim", TREE_PIPE)}`;
+			const sourcesBranch = hasRelatedQuestions ? TREE_MID : TREE_END;
+			text += `\n ${theme.fg("dim", sourcesBranch)} ${theme.fg("accent", "Sources")}`;
+
+			for (let i = 0; i < sources.length; i++) {
+				const src = sources[i];
+				const isLast = i === sources.length - 1;
+				const branch = isLast ? TREE_END : TREE_MID;
+				const cont = isLast ? TREE_SPACE : TREE_PIPE;
+				const indent = hasRelatedQuestions ? TREE_PIPE : TREE_SPACE;
+
+				// Title + domain + age
+				const title = truncate(src.title, 60);
+				const domain = getDomain(src.url);
+				const age = formatAge(src.ageSeconds) || src.publishedDate;
+				const agePart = age ? theme.fg("muted", ` · ${age}`) : "";
+
+				text += `\n ${theme.fg("dim", indent)} ${theme.fg("dim", branch)} ${theme.fg("accent", title)} ${theme.fg(
+					"dim",
+					`(${domain})`,
+				)}${agePart}`;
+				text += `\n ${theme.fg("dim", indent)} ${theme.fg("dim", `${cont}  ${TREE_HOOK} `)}${theme.fg(
+					"mdLinkUrl",
+					src.url,
+				)}`;
+			}
+		}
+
+		// Render related questions (Perplexity only)
+		if (hasRelatedQuestions) {
+			text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg("accent", "Related Questions")}`;
+			const questions = response.relatedQuestions!;
+			for (let i = 0; i < questions.length; i++) {
+				const question = questions[i];
+				const isLast = i === questions.length - 1;
+				const branch = isLast ? TREE_END : TREE_MID;
+				text += `\n ${theme.fg("dim", TREE_SPACE)} ${theme.fg("dim", branch)} ${theme.fg("muted", question)}`;
+			}
+		}
+	}
+
+	return new Text(text, 0, 0);
+}
+
+/** Render web search call (query preview) */
+export function renderWebSearchCall(
+	args: { query: string; provider?: string; [key: string]: unknown },
+	theme: Theme,
+): Component {
+	const provider = args.provider ?? "auto";
+	const query = truncate(args.query, 80);
+	const text = `${theme.fg("toolTitle", "Web Search")} ${theme.fg("dim", `(${provider})`)} ${theme.fg("muted", query)}`;
+	return new Text(text, 0, 0);
+}

package/src/core/tools/web-search/types.ts

@@ -0,0 +1,180 @@
+/**
+ * Web Search Types
+ *
+ * Unified types for web search responses across Anthropic and Perplexity providers.
+ */
+
+/** Supported web search providers */
+export type WebSearchProvider = "exa" | "anthropic" | "perplexity";
+
+/** Source returned by search (all providers) */
+export interface WebSearchSource {
+	title: string;
+	url: string;
+	snippet?: string;
+	/** ISO date string or relative ("2d ago") */
+	publishedDate?: string;
+	/** Age in seconds for consistent formatting */
+	ageSeconds?: number;
+	author?: string;
+}
+
+/** Citation with text reference (anthropic, perplexity) */
+export interface WebSearchCitation {
+	url: string;
+	title: string;
+	citedText?: string;
+}
+
+/** Usage metrics */
+export interface WebSearchUsage {
+	inputTokens?: number;
+	outputTokens?: number;
+	/** Anthropic: number of web search requests made */
+	searchRequests?: number;
+	/** Perplexity: combined token count */
+	totalTokens?: number;
+}
+
+/** Unified response across providers */
+export interface WebSearchResponse {
+	provider: WebSearchProvider;
+	/** Synthesized answer text (anthropic, perplexity) */
+	answer?: string;
+	/** Search result sources */
+	sources: WebSearchSource[];
+	/** Text citations with context */
+	citations?: WebSearchCitation[];
+	/** Follow-up questions (perplexity) */
+	relatedQuestions?: string[];
+	/** Intermediate search queries (anthropic) */
+	searchQueries?: string[];
+	/** Token usage metrics */
+	usage?: WebSearchUsage;
+	/** Model used */
+	model?: string;
+	/** Request ID for debugging */
+	requestId?: string;
+}
+
+/** Auth configuration for Anthropic */
+export interface AnthropicAuthConfig {
+	apiKey: string;
+	baseUrl: string;
+	isOAuth: boolean;
+}
+
+/** models.json structure for provider resolution */
+export interface ModelsJson {
+	providers?: Record<
+		string,
+		{
+			baseUrl?: string;
+			apiKey?: string;
+			api?: string;
+		}
+	>;
+}
+
+/** auth.json structure for OAuth credentials */
+export interface AuthJson {
+	anthropic?: {
+		type: "oauth";
+		access: string;
+		refresh?: string;
+		/** Expiry timestamp in milliseconds */
+		expires: number;
+	};
+}
+
+/** Anthropic API response types */
+export interface AnthropicWebSearchResult {
+	type: "web_search_result";
+	title: string;
+	url: string;
+	encrypted_content: string;
+	page_age: string | null;
+}
+
+export interface AnthropicCitation {
+	type: "web_search_result_location";
+	url: string;
+	title: string;
+	cited_text: string;
+	encrypted_index: string;
+}
+
+export interface AnthropicContentBlock {
+	type: string;
+	/** Text content (for type="text") */
+	text?: string;
+	/** Citations in text block */
+	citations?: AnthropicCitation[];
+	/** Tool name (for type="server_tool_use") */
+	name?: string;
+	/** Tool input (for type="server_tool_use") */
+	input?: { query: string };
+	/** Search results (for type="web_search_tool_result") */
+	content?: AnthropicWebSearchResult[];
+}
+
+export interface AnthropicApiResponse {
+	id: string;
+	model: string;
+	content: AnthropicContentBlock[];
+	usage: {
+		input_tokens: number;
+		output_tokens: number;
+		cache_read_input_tokens?: number;
+		cache_creation_input_tokens?: number;
+		server_tool_use?: { web_search_requests: number };
+	};
+}
+
+/** Perplexity API types */
+export interface PerplexityMessage {
+	role: "system" | "user" | "assistant";
+	content: string;
+}
+
+export interface PerplexityRequest {
+	model: string;
+	messages: PerplexityMessage[];
+	temperature?: number;
+	max_tokens?: number;
+	search_domain_filter?: string[];
+	search_recency_filter?: "day" | "week" | "month" | "year";
+	return_images?: boolean;
+	return_related_questions?: boolean;
+	search_context_size?: "low" | "medium" | "high";
+}
+
+export interface PerplexitySearchResult {
+	title: string;
+	url: string;
+	date?: string;
+	snippet?: string;
+}
+
+export interface PerplexityResponse {
+	id: string;
+	model: string;
+	created: number;
+	usage: {
+		prompt_tokens: number;
+		completion_tokens: number;
+		total_tokens: number;
+		search_context_size?: string;
+	};
+	citations?: string[];
+	search_results?: PerplexitySearchResult[];
+	related_questions?: string[];
+	choices: Array<{
+		index: number;
+		finish_reason: string;
+		message: {
+			role: string;
+			content: string;
+		};
+	}>;
+}

package/src/core/tools/write.ts

@@ -0,0 +1,99 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Type } from "@sinclair/typebox";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { resolveToCwd } from "./path-utils.js";
+
+const writeSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
+	content: Type.String({ description: "Content to write to the file" }),
+});
+
+export function createWriteTool(cwd: string): AgentTool<typeof writeSchema> {
+	return {
+		name: "write",
+		label: "Write",
+		description: `Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`,
+		parameters: writeSchema,
+		execute: async (
+			_toolCallId: string,
+			{ path, content }: { path: string; content: string },
+			signal?: AbortSignal,
+		) => {
+			const absolutePath = resolveToCwd(path, cwd);
+			const dir = dirname(absolutePath);
+
+			return new Promise<{ content: Array<{ type: "text"; text: string }>; details: undefined }>(
+				(resolve, reject) => {
+					// Check if already aborted
+					if (signal?.aborted) {
+						reject(new Error("Operation aborted"));
+						return;
+					}
+
+					let aborted = false;
+
+					// Set up abort handler
+					const onAbort = () => {
+						aborted = true;
+						reject(new Error("Operation aborted"));
+					};
+
+					if (signal) {
+						signal.addEventListener("abort", onAbort, { once: true });
+					}
+
+					// Perform the write operation
+					(async () => {
+						try {
+							// Create parent directories if needed
+							await mkdir(dir, { recursive: true });
+
+							// Check if aborted before writing
+							if (aborted) {
+								return;
+							}
+
+							// Write the file
+							await writeFile(absolutePath, content, "utf-8");
+
+							// Check if aborted after writing
+							if (aborted) {
+								return;
+							}
+
+							// Clean up abort handler
+							if (signal) {
+								signal.removeEventListener("abort", onAbort);
+							}
+
+							resolve({
+								content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
+								details: undefined,
+							});
+						} catch (error: any) {
+							// Clean up abort handler
+							if (signal) {
+								signal.removeEventListener("abort", onAbort);
+							}
+
+							if (!aborted) {
+								reject(error);
+							}
+						}
+					})();
+				},
+			);
+		},
+	};
+}
+
+/** Default write tool using process.cwd() - for backwards compatibility */
+export const writeTool = createWriteTool(process.cwd());

package/src/index.ts

@@ -0,0 +1,176 @@
+// Core session management
+
+// Re-export TUI components for custom tool rendering
+export { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
+export {
+	AgentSession,
+	type AgentSessionConfig,
+	type AgentSessionEvent,
+	type AgentSessionEventListener,
+	type ModelCycleResult,
+	type PromptOptions,
+	type SessionStats,
+} from "./core/agent-session.js";
+// Auth and model registry
+export { type ApiKeyCredential, type AuthCredential, AuthStorage, type OAuthCredential } from "./core/auth-storage.js";
+// Compaction
+export {
+	type BranchPreparation,
+	type BranchSummaryResult,
+	type CollectEntriesResult,
+	type CompactionResult,
+	type CutPointResult,
+	calculateContextTokens,
+	collectEntriesForBranchSummary,
+	compact,
+	DEFAULT_COMPACTION_SETTINGS,
+	estimateTokens,
+	type FileOperations,
+	findCutPoint,
+	findTurnStartIndex,
+	type GenerateBranchSummaryOptions,
+	generateBranchSummary,
+	generateSummary,
+	getLastAssistantUsage,
+	prepareBranchEntries,
+	serializeConversation,
+	shouldCompact,
+} from "./core/compaction/index.js";
+// Custom tools
+export type {
+	AgentToolUpdateCallback,
+	CustomTool,
+	CustomToolAPI,
+	CustomToolContext,
+	CustomToolFactory,
+	CustomToolSessionEvent,
+	CustomToolsLoadResult,
+	CustomToolUIContext,
+	ExecResult,
+	LoadedCustomTool,
+	RenderResultOptions,
+} from "./core/custom-tools/index.js";
+export { discoverAndLoadCustomTools, loadCustomTools } from "./core/custom-tools/index.js";
+export type * from "./core/hooks/index.js";
+// Hook system types and type guards
+export {
+	isBashToolResult,
+	isEditToolResult,
+	isFindToolResult,
+	isGrepToolResult,
+	isLsToolResult,
+	isReadToolResult,
+	isWriteToolResult,
+} from "./core/hooks/index.js";
+export { convertToLlm } from "./core/messages.js";
+export { ModelRegistry } from "./core/model-registry.js";
+// SDK for programmatic usage
+export {
+	type BuildSystemPromptOptions,
+	buildSystemPrompt,
+	type CreateAgentSessionOptions,
+	type CreateAgentSessionResult,
+	// Factory
+	createAgentSession,
+	createBashTool,
+	// Tool factories (for custom cwd)
+	createCodingTools,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadOnlyTools,
+	createReadTool,
+	createWriteTool,
+	// Discovery
+	discoverAuthStorage,
+	discoverContextFiles,
+	discoverCustomTools,
+	discoverHooks,
+	discoverModels,
+	discoverSkills,
+	discoverSlashCommands,
+	type FileSlashCommand,
+	// Hook types
+	type HookAPI,
+	type HookContext,
+	type HookFactory,
+	loadSettings,
+	// Pre-built tools (use process.cwd())
+	readOnlyTools,
+} from "./core/sdk.js";
+export {
+	type BranchSummaryEntry,
+	buildSessionContext,
+	type CompactionEntry,
+	CURRENT_SESSION_VERSION,
+	type CustomEntry,
+	type CustomMessageEntry,
+	type FileEntry,
+	getLatestCompactionEntry,
+	type ModelChangeEntry,
+	migrateSessionEntries,
+	type NewSessionOptions,
+	parseSessionEntries,
+	type SessionContext,
+	type SessionEntry,
+	type SessionEntryBase,
+	type SessionHeader,
+	type SessionInfo,
+	SessionManager,
+	type SessionMessageEntry,
+	type ThinkingLevelChangeEntry,
+} from "./core/session-manager.js";
+export {
+	type CompactionSettings,
+	type RetrySettings,
+	type Settings,
+	SettingsManager,
+	type SkillsSettings,
+} from "./core/settings-manager.js";
+// Skills
+export {
+	formatSkillsForPrompt,
+	type LoadSkillsFromDirOptions,
+	type LoadSkillsResult,
+	loadSkills,
+	loadSkillsFromDir,
+	type Skill,
+	type SkillFrontmatter,
+	type SkillWarning,
+} from "./core/skills.js";
+// Tools
+export {
+	type BashToolDetails,
+	bashTool,
+	codingTools,
+	editTool,
+	type FindToolDetails,
+	findTool,
+	type GrepToolDetails,
+	grepTool,
+	type LsToolDetails,
+	lsTool,
+	type ReadToolDetails,
+	readTool,
+	type TruncationResult,
+	writeTool,
+} from "./core/tools/index.js";
+// Main entry point
+export { main } from "./main.js";
+// UI components for hooks and custom tools
+export { BorderedLoader } from "./modes/interactive/components/bordered-loader.js";
+// Theme utilities for custom tools
+export { getMarkdownTheme } from "./modes/interactive/theme/theme.js";
+
+// TypeBox helper for string enums (convenience for custom tools)
+import { type TSchema, Type } from "@sinclair/typebox";
+export function StringEnum<T extends readonly string[]>(
+	values: T,
+	options?: { description?: string; default?: T[number] },
+): TSchema {
+	return Type.Union(
+		values.map((v) => Type.Literal(v)),
+		options,
+	);
+}