@oh-my-pi/pi-coding-agent 14.9.8 → 15.0.0

package/src/tools/read.ts

@@ -6,7 +6,7 @@ import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { glob, type SummaryResult, summarizeCode } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { getRemoteDir, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
+import { getRemoteDir, logger, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { getFileReadCache } from "../edit/file-read-cache";
 import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
@@ -26,7 +26,7 @@ import {
 	truncateHead,
 	truncateHeadBytes,
 } from "../session/streaming-output";
-import { renderCodeCell, renderStatusLine } from "../tui";
+import { renderCodeCell, renderMarkdownCell, renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { ImageInputTooLargeError, loadImageInput, MAX_IMAGE_INPUT_BYTES } from "../utils/image-loading";
@@ -56,7 +56,7 @@ import {
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, formatStyledTruncationWarning, type OutputMeta } from "./output-meta";
 import { expandPath, formatPathRelativeToCwd, resolveReadPath, splitPathAndSel } from "./path-utils";
-import { formatBytes, shortenPath, wrapBrackets } from "./render-utils";
+import { formatBytes, replaceTabs, shortenPath, wrapBrackets } from "./render-utils";
 import {
 	executeReadQuery,
 	getRowByKey,
@@ -1045,12 +1045,25 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		}
 	}
 
+	#routeReadThroughBridge(
+		absolutePath: string,
+		options?: { line?: number; limit?: number },
+	): Promise<string> | undefined {
+		const bridge = this.session.getClientBridge?.();
+		if (!bridge?.capabilities.readTextFile || !bridge.readTextFile) return undefined;
+		return bridge.readTextFile({ path: absolutePath, ...options });
+	}
+
 	async #trySummarize(absolutePath: string, fileSize: number, signal?: AbortSignal): Promise<SummaryResult | null> {
 		if (fileSize > MAX_SUMMARY_BYTES) return null;
 
 		try {
 			throwIfAborted(signal);
-			const code = await Bun.file(absolutePath).text();
+			const bridgePromise = this.#routeReadThroughBridge(absolutePath);
+			const code =
+				bridgePromise !== undefined
+					? await bridgePromise.catch(() => Bun.file(absolutePath).text())
+					: await Bun.file(absolutePath).text();
 			throwIfAborted(signal);
 			if (countTextLines(code) > MAX_SUMMARY_LINES) return null;
 
@@ -1173,7 +1186,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		if (conflictUri) {
 			if (conflictUri.id === "*") {
 				throw new ToolError(
-					"`read conflict://*` is not supported — wildcards are write-only. Use `read <path>:conflicts` for the full list of conflicts in a file, or `read conflict://<N>` to inspect a single block.",
+					"Reading `conflict://*` is not supported — wildcards are write-only. Use the `<path>:conflicts` read selector for the full list of conflicts in a file, or read `conflict://<N>` to inspect a single block.",
 				);
 			}
 			return this.#readConflictRegion(conflictUri.id, conflictUri.scope);
@@ -1211,7 +1224,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		if (internalRouter.canHandle(internalTarget.path)) {
 			const parsed = parseSel(internalTarget.sel);
 			const { offset, limit } = selToOffsetLimit(parsed);
-			return this.#handleInternalUrl(internalTarget.path, offset, limit, { raw: isRawSelector(parsed) });
+			return this.#handleInternalUrl(internalTarget.path, offset, limit, { raw: isRawSelector(parsed) }, signal);
 		}
 
 		const archivePath = await this.#resolveArchiveReadPath(readPath, signal);
@@ -1413,6 +1426,29 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			if (!content) {
 				// Raw text or line-range mode
 				const { offset, limit } = selToOffsetLimit(parsed);
+				// Try ACP bridge first — editor's in-memory buffer is source of truth.
+				// Request full text so local range rendering keeps normal context and line numbers.
+				const bridgePromise = this.#routeReadThroughBridge(absolutePath);
+				if (bridgePromise !== undefined) {
+					try {
+						const bridgeText = await bridgePromise;
+						const bridgeResult = this.#buildInMemoryTextResult(bridgeText, offset, limit, {
+							details: { resolvedPath: absolutePath, suffixResolution },
+							sourcePath: absolutePath,
+							entityLabel: "file",
+							raw: isRawSelector(parsed),
+						});
+						if (suffixResolution) {
+							const notice = `[Path '${suffixResolution.from}' not found; resolved to '${suffixResolution.to}' via suffix match]`;
+							const firstText = bridgeResult.content.find((c): c is TextContent => c.type === "text");
+							if (firstText) firstText.text = `${notice}\n${firstText.text}`;
+						}
+						return bridgeResult;
+					} catch (error) {
+						logger.warn("ACP fs readTextFile failed; falling back to disk", { path: absolutePath, error });
+					}
+				}
+
 				// User-requested 0-indexed range start. Lines BEFORE this become
 				// leading context (added below if offset is explicit).
 				const requestedStart = offset ? Math.max(0, offset - 1) : 0;
@@ -1633,7 +1669,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	}
 
 	/**
-	 * Implement `read <path>:conflicts`: scan the whole file once, register
+	 * Implement the `<path>:conflicts` read selector: scan the whole file once, register
 	 * every block in the session's conflict history, and return a compact
 	 * `#N L_a-L_b` index instead of file content. Designed for heavily
 	 * conflicted files where dumping every body would be wasteful.
@@ -1677,6 +1713,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		offset?: number,
 		limit?: number,
 		options?: { raw?: boolean },
+		signal?: AbortSignal,
 	): Promise<AgentToolResult<ReadToolDetails>> {
 		const internalRouter = InternalUrlRouter.instance();
 
@@ -1703,8 +1740,12 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		}
 
 		// Resolve the internal URL
-		const resource = await internalRouter.resolve(url);
-		const details: ReadToolDetails = { resolvedPath: resource.sourcePath };
+		const resource = await internalRouter.resolve(url, {
+			cwd: this.session.cwd,
+			settings: this.session.settings,
+			signal,
+		});
+		const details: ReadToolDetails = { resolvedPath: resource.sourcePath, contentType: resource.contentType };
 
 		// If extraction was used, return directly (no pagination)
 		if (hasExtraction) {
@@ -1803,20 +1844,44 @@ export const readToolRenderer = {
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: ReadToolDetails },
-		_options: RenderResultOptions,
+		result: { content: Array<{ type: string; text?: string }>; details?: ReadToolDetails; isError?: boolean },
+		options: RenderResultOptions,
 		uiTheme: Theme,
 		args?: ReadRenderArgs,
 	): Component {
 		const urlDetails = result.details as ReadUrlToolDetails | undefined;
 		if (urlDetails?.kind === "url" || isReadableUrlPath(args?.file_path || args?.path || "")) {
 			return renderReadUrlResult(
-				result as { content: Array<{ type: string; text?: string }>; details?: ReadUrlToolDetails },
-				_options,
+				result as {
+					content: Array<{ type: string; text?: string }>;
+					details?: ReadUrlToolDetails;
+					isError?: boolean;
+				},
+				options,
 				uiTheme,
 			);
 		}
 
+		if (result.isError) {
+			const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
+			const errorText = (rawErrorText || "Unknown error").replace(/^Error:\s*/, "");
+			const rawPath = args?.file_path || args?.path || "";
+			const filePath = shortenPath(rawPath);
+			let title = filePath ? `Read ${filePath}` : "Read";
+			if (args?.offset !== undefined || args?.limit !== undefined) {
+				const startLine = args.offset ?? 1;
+				const endLine = args.limit !== undefined ? startLine + args.limit - 1 : "";
+				title += `:${startLine}${endLine ? `-${endLine}` : ""}`;
+			}
+			const header = renderStatusLine({ icon: "error", title }, uiTheme);
+			const errorLines = errorText.split("\n").map(line => uiTheme.fg("error", replaceTabs(line)));
+			const outputBlock = new CachedOutputBlock();
+			return {
+				render: (width: number) =>
+					outputBlock.render({ header, state: "error", sections: [{ lines: errorLines }], width }, uiTheme),
+				invalidate: () => outputBlock.invalidate(),
+			};
+		}
 		const details = result.details;
 		const rawText = result.content?.find(c => c.type === "text")?.text ?? "";
 		// Prefer structured `displayContent` from details when available so the TUI
@@ -1825,7 +1890,7 @@ export const readToolRenderer = {
 		const imageContent = result.content?.find(c => c.type === "image");
 		const rawPath = args?.file_path || args?.path || "";
 		const filePath = shortenPath(rawPath);
-		const lang = getLanguageFromPath(rawPath);
+		const lang = getLanguageFromPath(splitPathAndSel(rawPath).path);
 
 		const warningLines: string[] = [];
 		const truncation = details?.meta?.truncation;
@@ -1893,28 +1958,46 @@ export const readToolRenderer = {
 			const n = details.conflictCount;
 			title += ` ${uiTheme.fg("warning", `(⚠ ${n} conflict${n === 1 ? "" : "s"})`)}`;
 		}
+		const rawRequested = args?.raw === true || isRawSelector(parseSel(splitPathAndSel(rawPath).sel));
+		const isMarkdown = details?.contentType === "text/markdown" && !rawRequested;
 		let cachedWidth: number | undefined;
+		let cachedExpanded: boolean | undefined;
 		let cachedLines: string[] | undefined;
 		return {
 			render: (width: number) => {
-				if (cachedLines && cachedWidth === width) return cachedLines;
-				cachedLines = renderCodeCell(
-					{
-						code: contentText,
-						language: lang,
-						title,
-						status: "complete",
-						output: warningLines.length > 0 ? warningLines.join("\n") : undefined,
-						expanded: true,
-						width,
-					},
-					uiTheme,
-				);
+				const expanded = options.expanded;
+				if (cachedLines && cachedWidth === width && cachedExpanded === expanded) return cachedLines;
+				cachedLines = isMarkdown
+					? renderMarkdownCell(
+							{
+								content: contentText,
+								title,
+								status: "complete",
+								output: warningLines.length > 0 ? warningLines.join("\n") : undefined,
+								expanded,
+								width,
+							},
+							uiTheme,
+						)
+					: renderCodeCell(
+							{
+								code: contentText,
+								language: lang,
+								title,
+								status: "complete",
+								output: warningLines.length > 0 ? warningLines.join("\n") : undefined,
+								expanded,
+								width,
+							},
+							uiTheme,
+						);
 				cachedWidth = width;
+				cachedExpanded = expanded;
 				return cachedLines;
 			},
 			invalidate: () => {
 				cachedWidth = undefined;
+				cachedExpanded = undefined;
 				cachedLines = undefined;
 			},
 		};

package/src/tools/write.ts

@@ -609,6 +609,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		};
 	}
 
+	#routeWriteThroughBridge(absolutePath: string, content: string): Promise<void> | undefined {
+		const bridge = this.session.getClientBridge?.();
+		if (!bridge?.capabilities.writeTextFile || !bridge.writeTextFile) return undefined;
+		return bridge.writeTextFile({ path: absolutePath, content });
+	}
 	async execute(
 		_toolCallId: string,
 		{ path, content }: WriteParams,
@@ -623,7 +628,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			if (conflictUri) {
 				if (conflictUri.scope) {
 					throw new ToolError(
-						`Conflict URI scope '/${conflictUri.scope}' is read-only — use \`read conflict://${conflictUri.id}/${conflictUri.scope}\` to inspect that side. To write, drop the scope (\`conflict://${conflictUri.id}\`) and put the chosen content (or shorthand like \`@${conflictUri.scope}\`) in \`content\`.`,
+						`Conflict URI scope '/${conflictUri.scope}' is read-only — read \`conflict://${conflictUri.id}/${conflictUri.scope}\` to inspect that side. To write, drop the scope (\`conflict://${conflictUri.id}\`) and put the chosen content (or shorthand like \`@${conflictUri.scope}\`) in \`content\`.`,
 					);
 				}
 				if (conflictUri.id === "*") {
@@ -682,6 +687,23 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				await assertEditableFile(absolutePath, path);
 			}
 
+			// Try ACP bridge first — no disk write when client handles it
+			const bridgePromise = this.#routeWriteThroughBridge(absolutePath, cleanContent);
+			if (bridgePromise !== undefined) {
+				try {
+					await bridgePromise;
+				} catch (error) {
+					throw new ToolError(error instanceof Error ? error.message : String(error));
+				}
+				invalidateFsScanAfterWrite(absolutePath);
+				const displayPath = formatPathRelativeToCwd(absolutePath, this.session.cwd);
+				let resultText = `Successfully wrote ${cleanContent.length} bytes to ${displayPath}`;
+				if (stripped) {
+					resultText += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
+				}
+				return { content: [{ type: "text", text: resultText }], details: {} };
+			}
+
 			const diagnostics = await this.#writethrough(absolutePath, cleanContent, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);
 

package/src/tui/code-cell.ts

@@ -1,7 +1,8 @@
 /**
- * Render a code cell with optional output section.
+ * Render a code or markdown cell with optional output section.
  */
-import { highlightCode, type Theme } from "../modes/theme/theme";
+import { Markdown } from "@oh-my-pi/pi-tui";
+import { getMarkdownTheme, highlightCode, type Theme } from "../modes/theme/theme";
 import {
 	formatDuration,
 	formatExpandHint,
@@ -116,3 +117,70 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 
 	return renderOutputBlock({ header: title, headerMeta: meta, state, sections, width }, theme);
 }
+
+export interface MarkdownCellOptions {
+	content: string;
+	index?: number;
+	total?: number;
+	title?: string;
+	status?: "pending" | "running" | "warning" | "complete" | "error";
+	spinnerFrame?: number;
+	duration?: number;
+	output?: string;
+	outputMaxLines?: number;
+	contentMaxLines?: number;
+	expanded?: boolean;
+	width: number;
+}
+
+export function renderMarkdownCell(options: MarkdownCellOptions, theme: Theme): string[] {
+	const { content, output, expanded = false, outputMaxLines = 6, contentMaxLines = 12, width } = options;
+	const codeOptions: CodeCellOptions = {
+		code: "",
+		index: options.index,
+		total: options.total,
+		title: options.title,
+		status: options.status,
+		spinnerFrame: options.spinnerFrame,
+		duration: options.duration,
+		width,
+	};
+	const { title, meta } = formatHeader(codeOptions, theme);
+	const state = getState(options.status);
+
+	// Markdown component manages its own wrapping at the inner content width.
+	// `renderOutputBlock` adds a `│ ` prefix + `│` suffix → 3 visible columns.
+	const innerWidth = Math.max(20, width - 3);
+	const allLines = content.trim() ? new Markdown(content, 0, 0, getMarkdownTheme()).render(innerWidth) : [];
+	const maxContentLines = expanded ? allLines.length : Math.min(allLines.length, contentMaxLines);
+	const contentLines = allLines.slice(0, maxContentLines);
+	const hiddenContentLines = allLines.length - maxContentLines;
+	if (hiddenContentLines > 0) {
+		const hint = formatExpandHint(theme, expanded, hiddenContentLines > 0);
+		const moreLine = `${formatMoreItems(hiddenContentLines, "line")}${hint ? ` ${hint}` : ""}`;
+		contentLines.push(theme.fg("dim", moreLine));
+	}
+
+	const outputLines: string[] = [];
+	if (output?.trim()) {
+		const rawLines = output.split("\n");
+		const maxLines = expanded ? rawLines.length : Math.min(rawLines.length, outputMaxLines);
+		const displayLines = rawLines
+			.slice(0, maxLines)
+			.map(line => (line.includes("\x1b[") ? replaceTabs(line) : theme.fg("toolOutput", replaceTabs(line))));
+		outputLines.push(...displayLines);
+		const remaining = rawLines.length - maxLines;
+		if (remaining > 0) {
+			const hint = formatExpandHint(theme, expanded, remaining > 0);
+			const moreLine = `${formatMoreItems(remaining, "line")}${hint ? ` ${hint}` : ""}`;
+			outputLines.push(theme.fg("dim", moreLine));
+		}
+	}
+
+	const sections: Array<{ label?: string; lines: string[] }> = [{ lines: contentLines }];
+	if (outputLines.length > 0) {
+		sections.push({ label: theme.fg("toolTitle", "Output"), lines: outputLines });
+	}
+
+	return renderOutputBlock({ header: title, headerMeta: meta, state, sections, width }, theme);
+}

package/src/utils/git.ts

@@ -895,6 +895,11 @@ export async function readTree(
 	await runEffect(cwd, ["read-tree", treeish], options);
 }
 
+/** Write the current index as a tree and return its object id. */
+export async function writeTree(cwd: string, options: Pick<CommandOptions, "env" | "signal"> = {}): Promise<string> {
+	return (await runText(cwd, ["write-tree"], options)).trim();
+}
+
 // ════════════════════════════════════════════════════════════════════════════
 // API: show
 // ════════════════════════════════════════════════════════════════════════════

package/src/task/isolation-backend.ts

@@ -1,94 +0,0 @@
-import { projfsOverlayProbe } from "@oh-my-pi/pi-natives";
-import { Snowflake } from "@oh-my-pi/pi-utils";
-import { cleanupProjfsOverlay, ensureProjfsOverlay, isProjfsUnavailableError } from "./worktree";
-
-export type TaskIsolationMode = "none" | "worktree" | "fuse-overlay" | "fuse-projfs";
-
-export interface IsolationBackendResolution {
-	effectiveIsolationMode: TaskIsolationMode;
-	warning: string;
-}
-
-type ProcessorEnv = Partial<Pick<NodeJS.ProcessEnv, "PROCESSOR_ARCHITECTURE" | "PROCESSOR_ARCHITEW6432">>;
-
-function isWindowsArm64HostUnderX64Emulation(
-	platform: NodeJS.Platform,
-	arch: NodeJS.Architecture,
-	env: ProcessorEnv,
-): boolean {
-	if (platform !== "win32" || arch !== "x64") return false;
-	return (
-		env.PROCESSOR_ARCHITECTURE?.toUpperCase() === "ARM64" || env.PROCESSOR_ARCHITEW6432?.toUpperCase() === "ARM64"
-	);
-}
-
-export async function resolveIsolationBackendForTaskExecution(
-	requestedMode: TaskIsolationMode,
-	isIsolated: boolean,
-	repoRoot: string | null,
-	platform: NodeJS.Platform = process.platform,
-	arch: NodeJS.Architecture = process.arch,
-	env: ProcessorEnv = process.env as ProcessorEnv,
-): Promise<IsolationBackendResolution> {
-	let effectiveIsolationMode = requestedMode;
-	let warning = "";
-	if (!(isIsolated && repoRoot)) {
-		return { effectiveIsolationMode, warning };
-	}
-
-	if (requestedMode === "fuse-overlay" && platform === "win32") {
-		effectiveIsolationMode = "worktree";
-		warning =
-			'<system-notification>fuse-overlay isolation is unavailable on Windows. Use task.isolation.mode = "fuse-projfs" for ProjFS. Falling back to worktree isolation.</system-notification>';
-		return { effectiveIsolationMode, warning };
-	}
-
-	if (requestedMode === "fuse-projfs" && platform !== "win32") {
-		effectiveIsolationMode = "worktree";
-		warning =
-			"<system-notification>fuse-projfs isolation is only available on Windows. Falling back to worktree isolation.</system-notification>";
-		return { effectiveIsolationMode, warning };
-	}
-
-	if (!(requestedMode === "fuse-projfs" && platform === "win32")) {
-		return { effectiveIsolationMode, warning };
-	}
-
-	if (isWindowsArm64HostUnderX64Emulation(platform, arch, env)) {
-		effectiveIsolationMode = "worktree";
-		warning =
-			"<system-notification>ProjFS isolation is disabled on Windows ARM64 x64 emulation. Falling back to worktree isolation.</system-notification>";
-		return { effectiveIsolationMode, warning };
-	}
-
-	const probe = projfsOverlayProbe();
-	if (!probe.available) {
-		effectiveIsolationMode = "worktree";
-		const reason = probe.reason ? ` Reason: ${probe.reason}` : "";
-		warning = `<system-notification>ProjFS is unavailable on this host. Falling back to worktree isolation.${reason}</system-notification>`;
-		return { effectiveIsolationMode, warning };
-	}
-
-	const probeIsolationId = `probe-${Snowflake.next()}`;
-	let probeIsolationDir: string | null = null;
-	try {
-		probeIsolationDir = await ensureProjfsOverlay(repoRoot, probeIsolationId);
-	} catch (err) {
-		if (isProjfsUnavailableError(err)) {
-			effectiveIsolationMode = "worktree";
-			const raw = err instanceof Error ? err.message : String(err);
-			const reason = raw.replace(/^PROJFS_UNAVAILABLE:\s*/, "");
-			const detail = reason ? ` Reason: ${reason}` : "";
-			warning = `<system-notification>ProjFS prerequisites are unavailable for this repository. Falling back to worktree isolation.${detail}</system-notification>`;
-		} else {
-			const message = err instanceof Error ? err.message : String(err);
-			throw new Error(`ProjFS isolation initialization failed. ${message}`);
-		}
-	} finally {
-		if (probeIsolationDir) {
-			await cleanupProjfsOverlay(probeIsolationDir);
-		}
-	}
-
-	return { effectiveIsolationMode, warning };
-}