@oh-my-pi/pi-coding-agent 7.0.0 → 8.0.0

package/src/{core/tools → tools}/index.ts

@@ -1,14 +1,6 @@
-export { AskTool, type AskToolDetails } from "./ask";
-export { BashTool, type BashToolDetails, type BashToolOptions } from "./bash";
-export { CalculatorTool, type CalculatorToolDetails } from "./calculator";
-export { CompleteTool } from "./complete";
 // Exa MCP tools (22 tools)
-export { exaTools } from "./exa/index";
-export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
-export { type FindOperations, FindTool, type FindToolDetails, type FindToolOptions } from "./find";
-export { setPreferredImageProvider } from "./gemini-image";
-export { type GrepOperations, GrepTool, type GrepToolDetails, type GrepToolOptions } from "./grep";
-export { type LsOperations, LsTool, type LsToolDetails, type LsToolOptions } from "./ls";
+export { exaTools } from "$c/exa/index";
+export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "$c/exa/types";
 export {
 	type FileDiagnosticsResult,
 	type FileFormatResult,
@@ -19,27 +11,9 @@ export {
 	type LspWarmupOptions,
 	type LspWarmupResult,
 	warmupLspServers,
-} from "./lsp/index";
-export { NotebookTool, type NotebookToolDetails } from "./notebook";
-export { OutputTool, type OutputToolDetails } from "./output";
-export { EditTool, type EditToolDetails } from "./patch";
-export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
-export { ReadTool, type ReadToolDetails } from "./read";
-export { reportFindingTool, type SubmitReviewDetails } from "./review";
-export { loadSshTool, type SSHToolDetails, SshTool } from "./ssh";
-export { BUNDLED_AGENTS, TaskTool } from "./task/index";
-export { type TodoItem, TodoWriteTool, type TodoWriteToolDetails } from "./todo-write";
-export {
-	DEFAULT_MAX_BYTES,
-	DEFAULT_MAX_LINES,
-	formatSize,
-	type TruncationOptions,
-	type TruncationResult,
-	truncateHead,
-	truncateLine,
-	truncateTail,
-} from "./truncate";
-export { WebFetchTool, type WebFetchToolDetails } from "./web-fetch";
+} from "$c/lsp/index";
+export { EditTool, type EditToolDetails } from "$c/patch";
+export { BUNDLED_AGENTS, TaskTool } from "$c/task/index";
 export {
 	companyWebSearchTools,
 	exaWebSearchTools,
@@ -57,34 +31,61 @@ export {
 	webSearchCustomTool,
 	webSearchDeepTool,
 	webSearchLinkedinTool,
-} from "./web-search/index";
+} from "$c/web/search/index";
+export { AskTool, type AskToolDetails } from "./ask";
+export { BashTool, type BashToolDetails, type BashToolOptions } from "./bash";
+export { CalculatorTool, type CalculatorToolDetails } from "./calculator";
+export { CompleteTool } from "./complete";
+export { FetchTool, type FetchToolDetails } from "./fetch";
+export { type FindOperations, FindTool, type FindToolDetails, type FindToolOptions } from "./find";
+export { setPreferredImageProvider } from "./gemini-image";
+export { type GrepOperations, GrepTool, type GrepToolDetails, type GrepToolOptions } from "./grep";
+export { type LsOperations, LsTool, type LsToolDetails, type LsToolOptions } from "./ls";
+export { NotebookTool, type NotebookToolDetails } from "./notebook";
+export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
+export { ReadTool, type ReadToolDetails } from "./read";
+export { reportFindingTool, type SubmitReviewDetails } from "./review";
+export { loadSshTool, type SSHToolDetails, SshTool } from "./ssh";
+export { type TodoItem, TodoWriteTool, type TodoWriteToolDetails } from "./todo-write";
+export {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	type TruncationOptions,
+	type TruncationResult,
+	truncateHead,
+	truncateLine,
+	truncateTail,
+} from "./truncate";
 export { WriteTool, type WriteToolDetails } from "./write";
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { logger } from "@oh-my-pi/pi-utils";
-import type { EventBus } from "../event-bus";
-import { getPreludeDocs, warmPythonEnvironment } from "../python-executor";
-import { checkPythonKernelAvailability } from "../python-kernel";
-import type { BashInterceptorRule } from "../settings-manager";
+import type { BashInterceptorRule } from "$c/config/settings-manager";
+import type { InternalUrlRouter } from "$c/internal-urls";
+import { getPreludeDocs, warmPythonEnvironment } from "$c/ipy/executor";
+import { checkPythonKernelAvailability } from "$c/ipy/kernel";
+import { LspTool } from "$c/lsp/index";
+import { EditTool } from "$c/patch";
+import type { ArtifactManager } from "$c/session/artifacts";
+import { TaskTool } from "$c/task/index";
+import type { EventBus } from "$c/utils/event-bus";
+import { WebSearchTool } from "$c/web/search/index";
 import { AskTool } from "./ask";
 import { BashTool } from "./bash";
 import { CalculatorTool } from "./calculator";
 import { CompleteTool } from "./complete";
+import { FetchTool } from "./fetch";
 import { FindTool } from "./find";
 import { GrepTool } from "./grep";
 import { LsTool } from "./ls";
-import { LspTool } from "./lsp/index";
 import { NotebookTool } from "./notebook";
-import { OutputTool } from "./output";
-import { EditTool } from "./patch";
+import { wrapToolsWithMetaNotice } from "./output-meta";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
 import { reportFindingTool } from "./review";
 import { loadSshTool } from "./ssh";
-import { TaskTool } from "./task/index";
 import { TodoWriteTool } from "./todo-write";
-import { WebFetchTool } from "./web-fetch";
-import { WebSearchTool } from "./web-search/index";
 import { WriteTool } from "./write";
 
 /** Tool type (AgentTool from pi-ai) */
@@ -106,6 +107,10 @@ export interface ToolSession {
 	requireCompleteTool?: boolean;
 	/** Get session file */
 	getSessionFile: () => string | null;
+	/** Cached artifact manager (allocated per ToolSession) */
+	artifactManager?: ArtifactManager;
+	/** Get artifacts directory for artifact:// URLs and $ARTIFACTS env var */
+	getArtifactsDir?: () => string | null;
 	/** Get session spawns */
 	getSessionSpawns: () => string | null;
 	/** Get resolved model string if explicitly set for this session */
@@ -113,13 +118,15 @@ export interface ToolSession {
 	/** Get the current session model string, regardless of how it was chosen */
 	getActiveModelString?: () => string | undefined;
 	/** Auth storage for passing to subagents (avoids re-discovery) */
-	authStorage?: import("../auth-storage").AuthStorage;
+	authStorage?: import("$c/session/auth-storage").AuthStorage;
 	/** Model registry for passing to subagents (avoids re-discovery) */
-	modelRegistry?: import("../model-registry").ModelRegistry;
+	modelRegistry?: import("$c/config/model-registry").ModelRegistry;
 	/** MCP manager for proxying MCP calls through parent */
 	mcpManager?: import("../mcp/manager").MCPManager;
+	/** Internal URL router for agent:// and skill:// URLs */
+	internalRouter?: InternalUrlRouter;
 	/** Settings manager for passing to subagents (avoids SQLite access in workers) */
-	settingsManager?: { serialize: () => import("../settings-manager").Settings };
+	settingsManager?: { serialize: () => import("$c/config/settings-manager").Settings };
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
@@ -153,11 +160,10 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ls: (s) => new LsTool(s),
 	lsp: LspTool.createIf,
 	notebook: (s) => new NotebookTool(s),
-	output: (s) => new OutputTool(s),
 	read: (s) => new ReadTool(s),
 	task: TaskTool.create,
 	todo_write: (s) => new TodoWriteTool(s),
-	web_fetch: (s) => new WebFetchTool(s),
+	fetch: (s) => new FetchTool(s),
 	web_search: (s) => new WebSearchTool(s),
 	write: (s) => new WriteTool(s),
 };
@@ -222,13 +228,13 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		} else if (!isTestEnv && getPreludeDocs().length === 0) {
 			const sessionFile = session.getSessionFile?.() ?? undefined;
 			const warmSessionId = sessionFile ? `session:${sessionFile}:cwd:${session.cwd}` : `cwd:${session.cwd}`;
-			void warmPythonEnvironment(session.cwd, warmSessionId, session.settings?.getPythonSharedGateway?.()).catch(
-				(err) => {
-					logger.warn("Failed to warm Python environment", {
-						error: err instanceof Error ? err.message : String(err),
-					});
-				},
-			);
+			try {
+				await warmPythonEnvironment(session.cwd, warmSessionId, session.settings?.getPythonSharedGateway?.());
+			} catch (err) {
+				logger.warn("Failed to warm Python environment", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
 		}
 	}
 
@@ -266,11 +272,12 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 				];
 	const results = await Promise.all(entries.map(([, factory]) => factory(session)));
 	const tools = results.filter((t): t is Tool => t !== null);
+	const wrappedTools = wrapToolsWithMetaNotice(tools);
 
 	if (filteredRequestedTools !== undefined) {
 		const allowed = new Set(filteredRequestedTools);
-		return tools.filter((tool) => allowed.has(tool.name));
+		return wrappedTools.filter((tool) => allowed.has(tool.name));
 	}
 
-	return tools;
+	return wrappedTools;
 }

package/src/tools/list-limit.ts

@@ -0,0 +1,40 @@
+import type { LimitsMeta } from "$c/tools/output-meta";
+
+export interface ListLimitResult<T> {
+	items: T[];
+	limitReached?: number;
+	meta: Partial<LimitsMeta>;
+}
+
+export interface ListLimitOptions {
+	limit?: number;
+	headLimit?: number;
+	limitType?: "match" | "result";
+}
+
+export function applyListLimit<T>(items: T[], options: ListLimitOptions): ListLimitResult<T> {
+	const meta: Partial<LimitsMeta> = {};
+	const limitType = options.limitType ?? "result";
+	const effectiveLimit = options.limit !== undefined && options.limit > 0 ? options.limit : undefined;
+	const effectiveHeadLimit = options.headLimit !== undefined && options.headLimit > 0 ? options.headLimit : undefined;
+	let limited = items;
+	let limitReached: number | undefined;
+
+	if (effectiveLimit !== undefined && items.length >= effectiveLimit) {
+		limited = items.slice(0, effectiveLimit);
+		limitReached = effectiveLimit;
+		const suggestion = effectiveLimit * 2;
+		if (limitType === "match") {
+			meta.matchLimit = { reached: effectiveLimit, suggestion };
+		} else {
+			meta.resultLimit = { reached: effectiveLimit, suggestion };
+		}
+	}
+
+	if (effectiveHeadLimit !== undefined && limited.length > effectiveHeadLimit) {
+		limited = limited.slice(0, effectiveHeadLimit);
+		meta.headLimit = { reached: effectiveHeadLimit, suggestion: effectiveHeadLimit * 2 };
+	}
+
+	return { items: limited, limitReached, meta };
+}

package/src/{core/tools → tools}/ls.ts

@@ -3,9 +3,12 @@ import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
-import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
-import type { RenderResultOptions } from "../custom-tools/types";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import { getLanguageFromPath, type Theme } from "$c/modes/theme/theme";
+import type { OutputMeta } from "$c/tools/output-meta";
+import { ToolError, throwIfAborted } from "$c/tools/tool-errors";
 import type { ToolSession } from "./index";
+import { applyListLimit } from "./list-limit";
 import { resolveToCwd } from "./path-utils";
 import {
 	formatAge,
@@ -19,7 +22,8 @@ import {
 	formatTruncationSuffix,
 	PREVIEW_LIMITS,
 } from "./render-utils";
-import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
+import { toolResult } from "./tool-result";
+import { type TruncationResult, truncateHead } from "./truncate";
 
 const lsSchema = Type.Object({
 	path: Type.Optional(Type.String({ description: "Directory to list (default: current directory)" })),
@@ -46,11 +50,14 @@ export interface LsToolOptions {
 
 export interface LsToolDetails {
 	entries?: string[];
+	/** Raw entry names (with / suffix for dirs) without age suffix, for icon detection */
+	rawEntries?: string[];
 	dirCount?: number;
 	fileCount?: number;
 	truncation?: TruncationResult;
 	truncationReasons?: Array<"entryLimit" | "byteLimit">;
 	entryLimitReached?: number;
+	meta?: OutputMeta;
 }
 
 /** Default operations using Bun APIs */
@@ -95,11 +102,11 @@ export class LsTool implements AgentTool<typeof lsSchema, LsToolDetails> {
 			// Check if path exists and is a directory
 			const dirStat = await this.ops.stat(dirPath);
 			if (!dirStat) {
-				throw new Error(`Path not found: ${dirPath}`);
+				throw new ToolError(`Path not found: ${dirPath}`);
 			}
 
 			if (!dirStat.isDirectory()) {
-				throw new Error(`Not a directory: ${dirPath}`);
+				throw new ToolError(`Not a directory: ${dirPath}`);
 			}
 
 			// Read directory entries
@@ -108,25 +115,24 @@ export class LsTool implements AgentTool<typeof lsSchema, LsToolDetails> {
 				entries = await this.ops.readdir(dirPath);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
-				throw new Error(`Cannot read directory: ${message}`);
+				throw new ToolError(`Cannot read directory: ${message}`);
 			}
 
 			// Sort alphabetically (case-insensitive)
 			entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
 
+			const listLimit = applyListLimit(entries, { limit: effectiveLimit });
+			const limitedEntries = listLimit.items;
+			const limitMeta = listLimit.meta;
+
 			// Format entries with directory indicators
 			const results: string[] = [];
-			let entryLimitReached = false;
+			const rawResults: string[] = [];
 			let dirCount = 0;
 			let fileCount = 0;
 
-			for (const entry of entries) {
-				signal?.throwIfAborted();
-				if (results.length >= effectiveLimit) {
-					entryLimitReached = true;
-					break;
-				}
-
+			for (const entry of limitedEntries) {
+				throwIfAborted(signal);
 				const fullPath = nodePath.join(dirPath, entry);
 				let suffix = "";
 				let age = "";
@@ -150,6 +156,7 @@ export class LsTool implements AgentTool<typeof lsSchema, LsToolDetails> {
 				// Format: "name/ (2d ago)" or "name (just now)"
 				const line = age ? `${entry}${suffix} (${age})` : entry + suffix;
 				results.push(line);
+				rawResults.push(entry + suffix);
 			}
 
 			if (results.length === 0) {
@@ -160,25 +167,21 @@ export class LsTool implements AgentTool<typeof lsSchema, LsToolDetails> {
 			const rawOutput = results.join("\n");
 			const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
-			let output = truncation.content;
+			const output = truncation.content;
 			const details: LsToolDetails = {
 				entries: results,
+				rawEntries: rawResults,
 				dirCount,
 				fileCount,
 			};
 			const truncationReasons: Array<"entryLimit" | "byteLimit"> = [];
 
-			// Build notices
-			const notices: string[] = [];
-
-			if (entryLimitReached) {
-				notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
-				details.entryLimitReached = effectiveLimit;
+			if (limitMeta.resultLimit) {
+				details.entryLimitReached = limitMeta.resultLimit.reached;
 				truncationReasons.push("entryLimit");
 			}
 
 			if (truncation.truncated) {
-				notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
 				details.truncation = truncation;
 				truncationReasons.push("byteLimit");
 			}
@@ -187,14 +190,12 @@ export class LsTool implements AgentTool<typeof lsSchema, LsToolDetails> {
 				details.truncationReasons = truncationReasons;
 			}
 
-			if (notices.length > 0) {
-				output += `\n\n[${notices.join(". ")}]`;
+			const resultBuilder = toolResult(details).text(output).limits({ resultLimit: limitMeta.resultLimit?.reached });
+			if (truncation.truncated) {
+				resultBuilder.truncation(truncation, { direction: "head" });
 			}
 
-			return {
-				content: [{ type: "text", text: output }],
-				details,
-			};
+			return resultBuilder.done();
 		});
 	}
 }
@@ -243,9 +244,11 @@ export const lsToolRenderer = {
 		}
 
 		let entries: string[] = details?.entries ? [...details.entries] : [];
+		let rawEntries: string[] | undefined = details?.rawEntries;
 		if (entries.length === 0) {
 			const rawLines = textContent.split("\n").filter((l: string) => l.trim());
 			entries = rawLines.filter((line) => !/^\[.*\]$/.test(line.trim()));
+			rawEntries = undefined; // Can't reliably extract raw paths from text
 		}
 
 		if (entries.length === 0) {
@@ -266,7 +269,9 @@ export const lsToolRenderer = {
 			}
 		}
 
-		const truncated = Boolean(details?.truncation?.truncated || details?.entryLimitReached);
+		const truncation = details?.meta?.truncation;
+		const limits = details?.meta?.limits;
+		const truncated = Boolean(details?.entryLimitReached || truncation || limits?.resultLimit || limits?.headLimit);
 		const icon = truncated
 			? uiTheme.styledSymbol("status.warning", "warning")
 			: uiTheme.styledSymbol("status.success", "success");
@@ -281,21 +286,25 @@ export const lsToolRenderer = {
 		let text = `  ${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${expandHint}`;
 
 		const truncationReasons: string[] = [];
-		if (details?.entryLimitReached) {
-			truncationReasons.push(`entry limit ${details.entryLimitReached}`);
+		if (limits?.resultLimit) {
+			truncationReasons.push(`entry limit ${limits.resultLimit.reached}`);
+		}
+		if (truncation) {
+			truncationReasons.push(`output cap ${formatBytes(truncation.outputBytes)}`);
 		}
-		if (details?.truncation?.truncated) {
-			truncationReasons.push(`output cap ${formatBytes(details.truncation.maxBytes)}`);
+		if (truncation?.artifactId) {
+			truncationReasons.push(`full output: artifact://${truncation.artifactId}`);
 		}
 
 		const hasTruncation = truncationReasons.length > 0;
 
 		for (let i = 0; i < maxEntries; i++) {
 			const entry = entries[i];
+			const rawEntry = rawEntries?.[i] ?? entry;
 			const isLast = i === maxEntries - 1 && !hasMoreEntries && !hasTruncation;
 			const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-			const isDir = entry.endsWith("/");
-			const entryPath = isDir ? entry.slice(0, -1) : entry;
+			const isDir = rawEntry.endsWith("/");
+			const entryPath = isDir ? rawEntry.slice(0, -1) : rawEntry;
 			const lang = isDir ? undefined : getLanguageFromPath(entryPath);
 			const entryIcon = isDir
 				? uiTheme.fg("accent", uiTheme.icon.folder)

package/src/{core/tools → tools}/notebook.ts

@@ -4,9 +4,9 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import type { Theme } from "../../modes/interactive/theme/theme";
-import type { RenderResultOptions } from "../custom-tools/types";
-import type { ToolSession } from "../sdk";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import type { Theme } from "$c/modes/theme/theme";
+import type { ToolSession } from "$c/sdk";
 import { resolveToCwd } from "./path-utils";
 import {
 	formatCount,