@oh-my-pi/pi-coding-agent 8.4.0 → 8.4.2

package/src/tools/grep.ts

@@ -107,21 +107,17 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 	private readonly session: ToolSession;
 	private readonly ops: GrepOperations;
 
-	private readonly rgPath: Promise<string | undefined>;
-
 	constructor(session: ToolSession, options?: GrepToolOptions) {
 		this.session = session;
 		this.ops = options?.operations ?? defaultGrepOperations;
 		this.description = renderPromptTemplate(grepDescription);
-		this.rgPath = ensureTool("rg", true);
 	}
 
 	/**
 	 * Validates a pattern against ripgrep's regex engine.
 	 * Uses a quick dry-run against /dev/null to check for parse errors.
 	 */
-	private async validateRegexPattern(pattern: string): Promise<{ valid: boolean; error?: string }> {
-		const rgPath = await this.rgPath;
+	private async validateRegexPattern(pattern: string, rgPath?: string): Promise<{ valid: boolean; error?: string }> {
 		if (!rgPath) {
 			return { valid: true }; // Can't validate, assume valid
 		}
@@ -146,7 +142,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 		params: GrepParams,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<GrepToolDetails>,
-		_context?: AgentToolContext,
+		toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<GrepToolDetails>> {
 		const {
 			pattern,
@@ -167,19 +163,24 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 		return untilAborted(signal, async () => {
 			// Auto-detect invalid regex patterns and switch to literal mode
 			// This handles cases like "abort(" which would cause ripgrep regex parse errors
+			const rgPath = await ensureTool("rg", {
+				silent: true,
+				notify: message => toolContext?.ui?.notify(message, "info"),
+			});
+
+			if (!rgPath) {
+				throw new ToolError("rg is not available and could not be downloaded");
+			}
+
 			let useLiteral = literal ?? false;
 			if (!useLiteral) {
-				const validation = await this.validateRegexPattern(pattern);
+				const validation = await this.validateRegexPattern(pattern, rgPath);
 				if (!validation.valid) {
 					useLiteral = true;
 				}
 			}
 
-			const rgPath = await this.rgPath;
-			if (!rgPath) {
-				throw new ToolError("ripgrep (rg) is not available and could not be downloaded");
-			}
-
+			// rgPath resolved earlier
 			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
 			const scopePath = (() => {
 				const relative = nodePath.relative(this.session.cwd, searchPath).replace(/\\/g, "/");

package/src/tools/index.ts

@@ -8,6 +8,7 @@ import { getPreludeDocs, warmPythonEnvironment } from "../ipy/executor";
 import { checkPythonKernelAvailability } from "../ipy/kernel";
 import { LspTool } from "../lsp";
 import { EditTool } from "../patch";
+import type { PlanModeState } from "../plan-mode/state";
 import type { ArtifactManager } from "../session/artifacts";
 import { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
@@ -18,6 +19,8 @@ import { AskTool } from "./ask";
 import { BashTool } from "./bash";
 import { CalculatorTool } from "./calculator";
 import { CompleteTool } from "./complete";
+import { EnterPlanModeTool } from "./enter-plan-mode";
+import { ExitPlanModeTool } from "./exit-plan-mode";
 import { FetchTool } from "./fetch";
 import { FindTool } from "./find";
 import { GrepTool } from "./grep";
@@ -70,6 +73,8 @@ 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 { type EnterPlanModeDetails, EnterPlanModeTool } from "./enter-plan-mode";
+export { type ExitPlanModeDetails, ExitPlanModeTool } from "./exit-plan-mode";
 export { FetchTool, type FetchToolDetails } from "./fetch";
 export { type FindOperations, FindTool, type FindToolDetails, type FindToolOptions } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
@@ -126,6 +131,8 @@ export interface ToolSession {
 	requireCompleteTool?: boolean;
 	/** Get session file */
 	getSessionFile: () => string | null;
+	/** Get session ID */
+	getSessionId?: () => string | null;
 	/** Cached artifact manager (allocated per ToolSession) */
 	artifactManager?: ArtifactManager;
 	/** Get artifacts directory for artifact:// URLs and $ARTIFACTS env var */
@@ -147,7 +154,10 @@ export interface ToolSession {
 	/** Agent output manager for unique agent:// IDs across task invocations */
 	agentOutputManager?: AgentOutputManager;
 	/** Settings manager for passing to subagents (avoids SQLite access in workers) */
-	settingsManager?: { serialize: () => import("@oh-my-pi/pi-coding-agent/config/settings-manager").Settings };
+	settingsManager?: {
+		serialize: () => import("@oh-my-pi/pi-coding-agent/config/settings-manager").Settings;
+		getPlansDirectory: (cwd?: string) => string;
+	};
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
@@ -165,6 +175,8 @@ export interface ToolSession {
 		getPythonKernelMode?(): "session" | "per-call";
 		getPythonSharedGateway?(): boolean;
 	};
+	/** Plan mode state (if active) */
+	getPlanModeState?: () => PlanModeState | undefined;
 }
 
 type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
@@ -187,11 +199,13 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	fetch: s => new FetchTool(s),
 	web_search: s => new WebSearchTool(s),
 	write: s => new WriteTool(s),
+	enter_plan_mode: s => new EnterPlanModeTool(s),
 };
 
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 	complete: s => new CompleteTool(s),
 	report_finding: () => reportFindingTool,
+	exit_plan_mode: s => new ExitPlanModeTool(s),
 };
 
 export type ToolName = keyof typeof BUILTIN_TOOLS;
@@ -234,6 +248,9 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const includeComplete = session.requireCompleteTool === true;
 	const enableLsp = session.enableLsp ?? true;
 	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
+	if (requestedTools && !requestedTools.includes("exit_plan_mode")) {
+		requestedTools.push("exit_plan_mode");
+	}
 	const pythonMode = getPythonModeFromEnv() ?? session.settings?.getPythonToolMode?.() ?? "ipy-only";
 	const skipPythonPreflight = session.skipPythonPreflight === true;
 	let pythonAvailable = true;
@@ -296,6 +313,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			: [
 					...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name)),
 					...(includeComplete ? ([["complete", HIDDEN_TOOLS.complete]] as const) : []),
+					...([["exit_plan_mode", HIDDEN_TOOLS.exit_plan_mode]] as const),
 				];
 	time("createTools:beforeFactories");
 	const slowTools: Array<{ name: string; ms: number }> = [];

package/src/tools/plan-mode-guard.ts

@@ -0,0 +1,46 @@
+import { resolvePlanUrlToPath } from "@oh-my-pi/pi-coding-agent/internal-urls";
+import type { ToolSession } from ".";
+import { resolveToCwd } from "./path-utils";
+import { ToolError } from "./tool-errors";
+
+const PLAN_URL_PREFIX = "plan://";
+
+export function resolvePlanPath(session: ToolSession, targetPath: string): string {
+	if (!targetPath.startsWith(PLAN_URL_PREFIX)) {
+		return resolveToCwd(targetPath, session.cwd);
+	}
+
+	const settingsManager = session.settingsManager;
+	if (!settingsManager) {
+		throw new ToolError("Plan mode: settings manager unavailable for plan path resolution.");
+	}
+
+	return resolvePlanUrlToPath(targetPath, {
+		getPlansDirectory: settingsManager.getPlansDirectory.bind(settingsManager),
+		cwd: session.cwd,
+	});
+}
+
+export function enforcePlanModeWrite(
+	session: ToolSession,
+	targetPath: string,
+	options?: { rename?: string; op?: "create" | "update" | "delete" },
+): void {
+	const state = session.getPlanModeState?.();
+	if (!state?.enabled) return;
+
+	const resolvedTarget = resolvePlanPath(session, targetPath);
+	const resolvedPlan = resolvePlanPath(session, state.planFilePath);
+
+	if (options?.rename) {
+		throw new ToolError("Plan mode: renaming files is not allowed.");
+	}
+
+	if (options?.op === "delete") {
+		throw new ToolError("Plan mode: deleting files is not allowed.");
+	}
+
+	if (resolvedTarget !== resolvedPlan) {
+		throw new ToolError(`Plan mode: only the plan file may be modified (${state.planFilePath}).`);
+	}
+}

package/src/tools/read.ts

@@ -162,10 +162,11 @@ function similarityScore(a: string, b: string): number {
 async function listCandidateFiles(
 	searchRoot: string,
 	signal?: AbortSignal,
+	notify?: (message: string) => void,
 ): Promise<{ files: string[]; truncated: boolean; error?: string }> {
 	let fdPath: string | undefined;
 	try {
-		fdPath = await ensureTool("fd", true);
+		fdPath = await ensureTool("fd", { silent: true, notify });
 	} catch {
 		return { files: [], truncated: false, error: "fd not available" };
 	}
@@ -248,6 +249,7 @@ async function findReadPathSuggestions(
 	rawPath: string,
 	cwd: string,
 	signal?: AbortSignal,
+	notify?: (message: string) => void,
 ): Promise<{ suggestions: string[]; scopeLabel?: string; truncated?: boolean; error?: string } | null> {
 	const resolvedPath = resolveToCwd(rawPath, cwd);
 	const searchRoot = await findExistingDirectory(path.dirname(resolvedPath), signal);
@@ -262,7 +264,7 @@ async function findReadPathSuggestions(
 		}
 	}
 
-	const { files, truncated, error } = await listCandidateFiles(searchRoot, signal);
+	const { files, truncated, error } = await listCandidateFiles(searchRoot, signal, notify);
 	const scopeLabel = formatScopeLabel(searchRoot, cwd);
 
 	if (error && files.length === 0) {
@@ -418,7 +420,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		params: ReadParams,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<ReadToolDetails>,
-		_context?: AgentToolContext,
+		toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<ReadToolDetails>> {
 		const { path: readPath, offset, limit, lines } = params;
 
@@ -442,7 +444,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 				// Skip fuzzy matching for remote mounts (sshfs) to avoid hangs
 				if (!isRemoteMountPath(absolutePath)) {
-					const suggestions = await findReadPathSuggestions(readPath, this.session.cwd, signal);
+					const suggestions = await findReadPathSuggestions(readPath, this.session.cwd, signal, message =>
+						toolContext?.ui?.notify(message, "info"),
+					);
 
 					if (suggestions?.suggestions.length) {
 						const scopeLabel = suggestions.scopeLabel ? ` in ${suggestions.scopeLabel}` : "";

package/src/tools/write.ts

@@ -17,7 +17,7 @@ import writeDescription from "../prompts/tools/write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { renderStatusLine } from "../tui";
 import { type OutputMeta, outputMeta } from "./output-meta";
-import { resolveToCwd } from "./path-utils";
+import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
 import {
 	formatDiagnostics,
 	formatExpandHint,
@@ -94,7 +94,8 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<WriteToolDetails>> {
 		return untilAborted(signal, async () => {
-			const absolutePath = resolveToCwd(path, this.session.cwd);
+			enforcePlanModeWrite(this.session, path, { op: "create" });
+			const absolutePath = resolvePlanPath(this.session, path);
 			const batchRequest = getLspBatchRequest(context?.toolCall);
 
 			const diagnostics = await this.writethrough(absolutePath, content, signal, undefined, batchRequest);

package/src/utils/tools-manager.ts

@@ -6,6 +6,7 @@ import { $ } from "bun";
 import { APP_NAME, getBinDir } from "../config";
 
 const TOOLS_DIR = getBinDir();
+const TOOL_DOWNLOAD_TIMEOUT_MS = 15000;
 
 interface ToolConfig {
 	name: string;
@@ -159,9 +160,18 @@ export async function getToolPath(tool: ToolName): Promise<string | null> {
 
 // Fetch latest release version from GitHub
 async function getLatestVersion(repo: string): Promise<string> {
-	const response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
-		headers: { "User-Agent": `${APP_NAME}-coding-agent` },
-	});
+	let response: Response;
+	try {
+		response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+			headers: { "User-Agent": `${APP_NAME}-coding-agent` },
+			signal: AbortSignal.timeout(TOOL_DOWNLOAD_TIMEOUT_MS),
+		});
+	} catch (err) {
+		if (err instanceof Error && err.name === "AbortError") {
+			throw new Error("GitHub API request timed out");
+		}
+		throw err;
+	}
 
 	if (!response.ok) {
 		throw new Error(`GitHub API error: ${response.status}`);
@@ -173,7 +183,17 @@ async function getLatestVersion(repo: string): Promise<string> {
 
 // Download a file from URL
 async function downloadFile(url: string, dest: string): Promise<void> {
-	const response = await fetch(url);
+	let response: Response;
+	try {
+		response = await fetch(url, {
+			signal: AbortSignal.timeout(TOOL_DOWNLOAD_TIMEOUT_MS),
+		});
+	} catch (err) {
+		if (err instanceof Error && err.name === "AbortError") {
+			throw new Error(`Download timed out: ${url}`);
+		}
+		throw err;
+	}
 	if (!response.ok) {
 		throw new Error(`Failed to download: ${response.status}`);
 	} else if (!response.body) {
@@ -223,15 +243,12 @@ async function downloadTool(tool: ToolName): Promise<string> {
 	const tmp = await TempDir.create("@omp-tools-extract-");
 
 	try {
-		if (assetName.endsWith(".tar.gz")) {
+		if (assetName.endsWith(".tar.gz") || assetName.endsWith(".zip")) {
 			const archive = new Bun.Archive(await Bun.file(archivePath).arrayBuffer());
 			const files = await archive.files();
 			for (const [filePath, file] of files) {
 				await Bun.write(path.join(tmp.path(), filePath), file);
 			}
-		} else if (assetName.endsWith(".zip")) {
-			await fs.mkdir(tmp.path(), { recursive: true });
-			await $`unzip -o ${archivePath} -d ${tmp.path()}`.quiet().nothrow();
 		}
 
 		// Find the binary in extracted files
@@ -284,7 +301,17 @@ async function installPythonPackage(pkg: string): Promise<boolean> {
 
 // Ensure a tool is available, downloading if necessary
 // Returns the path to the tool, or null if unavailable
-export async function ensureTool(tool: ToolName, silent: boolean = false): Promise<string | undefined> {
+type EnsureToolOptions = {
+	silent?: boolean;
+	notify?: (message: string) => void;
+};
+
+export async function ensureTool(
+	tool: ToolName,
+	silentOrOptions: boolean | EnsureToolOptions = false,
+): Promise<string | undefined> {
+	const options = typeof silentOrOptions === "object" ? silentOrOptions : { silent: silentOrOptions };
+	const silent = options.silent ?? false;
 	const existingPath = await getToolPath(tool);
 	if (existingPath) {
 		return existingPath;
@@ -296,6 +323,7 @@ export async function ensureTool(tool: ToolName, silent: boolean = false): Promi
 		if (!silent) {
 			logger.debug(`${pythonConfig.name} not found. Installing via uv/pip...`);
 		}
+		options.notify?.(`Installing ${pythonConfig.name}...`);
 		const success = await installPythonPackage(pythonConfig.package);
 		if (success) {
 			// Re-check for the command after installation
@@ -320,6 +348,7 @@ export async function ensureTool(tool: ToolName, silent: boolean = false): Promi
 	if (!silent) {
 		logger.debug(`${config.name} not found. Downloading...`);
 	}
+	options.notify?.(`Downloading ${config.name}...`);
 
 	try {
 		const path = await downloadTool(tool);

package/src/web/search/providers/perplexity.ts

@@ -169,7 +169,9 @@ export async function searchPerplexity(params: PerplexitySearchParams): Promise<
 		model: "sonar-pro",
 		messages,
 		return_related_questions: true,
-		search_context_size: "high",
+		web_search_options: {
+			search_context_size: "high",
+		},
 	};
 
 	if (params.search_recency_filter) {

package/src/web/search/types.ts

@@ -163,7 +163,9 @@ export interface PerplexityRequest {
 	search_recency_filter?: "day" | "week" | "month" | "year";
 	return_images?: boolean;
 	return_related_questions?: boolean;
-	search_context_size?: "low" | "medium" | "high";
+	web_search_options?: {
+		search_context_size?: "low" | "medium" | "high";
+	};
 }
 
 export interface PerplexitySearchResult {