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

package/src/tools/read.ts

@@ -33,6 +33,17 @@ import { ImageInputTooLargeError, loadImageInput, MAX_IMAGE_INPUT_BYTES } from "
 import { convertFileWithMarkit } from "../utils/markit";
 import { buildDirectoryTree, type DirectoryTree } from "../workspace-tree";
 import { type ArchiveReader, openArchive, parseArchivePathCandidates } from "./archive-reader";
+import {
+	type ConflictEntry,
+	type ConflictScope,
+	formatConflictSummary,
+	formatConflictWarning,
+	getConflictHistory,
+	parseConflictUri,
+	renderConflictRegion,
+	scanConflictLines,
+	scanFileForConflicts,
+} from "./conflict-detect";
 import {
 	executeReadUrl,
 	isReadableUrlPath,
@@ -455,6 +466,8 @@ export interface ReadToolDetails {
 	 * so the TUI can render the file content with its own gutter without re-parsing the formatted text. */
 	displayContent?: { text: string; startLine: number };
 	summary?: { lines: number; elidedSpans: number };
+	/** Number of unresolved git conflicts surfaced by this read (TUI uses for inline `⚠ N` badge). */
+	conflictCount?: number;
 }
 
 type ReadParams = ReadToolInput;
@@ -463,6 +476,7 @@ type ReadParams = ReadToolInput;
 type ParsedSelector =
 	| { kind: "none" }
 	| { kind: "raw" }
+	| { kind: "conflicts" }
 	| { kind: "lines"; startLine: number; endLine: number | undefined; raw?: boolean };
 
 const LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+))?$/i;
@@ -521,6 +535,7 @@ function parseSel(sel: string | undefined): ParsedSelector {
 	}
 
 	if (sel.toLowerCase() === "raw") return { kind: "raw" };
+	if (sel.toLowerCase() === "conflicts") return { kind: "conflicts" };
 	const range = parseLineRangeChunk(sel);
 	if (range) {
 		return { kind: "lines", startLine: range.startLine, endLine: range.endLine };
@@ -1153,6 +1168,16 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		if (readPath.startsWith("file://")) {
 			readPath = expandPath(readPath);
 		}
+
+		const conflictUri = parseConflictUri(readPath);
+		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.",
+				);
+			}
+			return this.#readConflictRegion(conflictUri.id, conflictUri.scope);
+		}
 		const displayMode = resolveFileDisplayMode(this.session);
 
 		const parsedUrlTarget = parseReadUrlTarget(readPath);
@@ -1257,6 +1282,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return dirResult;
 		}
 
+		if (parsed.kind === "conflicts") {
+			return this.#readFileConflicts(absolutePath, suffixResolution, signal);
+		}
+
 		const imageMetadata = await readImageMetadata(absolutePath);
 		const mimeType = imageMetadata?.mimeType;
 		const ext = path.extname(absolutePath).toLowerCase();
@@ -1517,6 +1546,38 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					details.displayContent = capturedDisplayContent;
 				}
 
+				if (!firstLineExceedsLimit && collectedLines.length > 0) {
+					const blocks = scanConflictLines(collectedLines, startLineDisplay);
+					if (blocks.length > 0) {
+						const history = getConflictHistory(this.session);
+						const displayPathForWarning = formatPathRelativeToCwd(absolutePath, this.session.cwd);
+						const entries = blocks.map(block =>
+							history.register({
+								absolutePath,
+								displayPath: displayPathForWarning,
+								...block,
+							}),
+						);
+						// Cheap full-file scan only when the window already showed
+						// at least one conflict — otherwise pay nothing on clean files.
+						let totalInFile = entries.length;
+						let scanTruncated = false;
+						try {
+							const fileScan = await scanFileForConflicts(absolutePath);
+							totalInFile = Math.max(entries.length, fileScan.blocks.length);
+							scanTruncated = fileScan.scanTruncated;
+						} catch {
+							// Best-effort enrichment; fall back to window-only count.
+						}
+						outputText += formatConflictWarning(entries, {
+							totalInFile,
+							displayPath: displayPathForWarning,
+							scanTruncated,
+						});
+						details.conflictCount = entries.length;
+					}
+				}
+
 				content = [{ type: "text", text: outputText }];
 			}
 		}
@@ -1542,6 +1603,71 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		return resultBuilder.done();
 	}
 
+	/**
+	 * Render a `conflict://<N>` (or `conflict://<N>/<scope>`) region as
+	 * regular file content. The lines are emitted with their original
+	 * file line numbers so hashline anchors line up with the source
+	 * file, and no truncation footer is appended.
+	 */
+	async #readConflictRegion(id: number, scope: ConflictScope | undefined): Promise<AgentToolResult<ReadToolDetails>> {
+		const entry: ConflictEntry | undefined = getConflictHistory(this.session).get(id);
+		if (!entry) {
+			throw new ToolError(
+				`Conflict #${id} not found. Conflict ids are registered when \`read\` surfaces a marker block; re-read the file to get a current id.`,
+			);
+		}
+
+		const region = renderConflictRegion(entry, scope);
+		const displayMode = resolveFileDisplayMode(this.session);
+		const shouldAddHashLines = displayMode.hashLines;
+		const shouldAddLineNumbers = shouldAddHashLines ? false : displayMode.lineNumbers;
+
+		const rawText = region.lines.join("\n");
+		const formattedText = formatTextWithMode(rawText, region.startLine, shouldAddHashLines, shouldAddLineNumbers);
+
+		const details: ReadToolDetails = {
+			resolvedPath: entry.absolutePath,
+			displayContent: { text: rawText, startLine: region.startLine },
+		};
+		return toolResult<ReadToolDetails>(details).text(formattedText).sourcePath(entry.absolutePath).done();
+	}
+
+	/**
+	 * Implement `read <path>:conflicts`: 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.
+	 */
+	async #readFileConflicts(
+		absolutePath: string,
+		suffixResolution: { from: string; to: string } | undefined,
+		signal: AbortSignal | undefined,
+	): Promise<AgentToolResult<ReadToolDetails>> {
+		throwIfAborted(signal);
+		const scan = await scanFileForConflicts(absolutePath);
+		const displayPath = formatPathRelativeToCwd(absolutePath, this.session.cwd);
+		const history = getConflictHistory(this.session);
+		const entries = scan.blocks.map(block =>
+			history.register({
+				absolutePath,
+				displayPath,
+				...block,
+			}),
+		);
+
+		const summary =
+			entries.length === 0
+				? `No unresolved git merge conflicts in ${displayPath}.`
+				: formatConflictSummary(entries, { displayPath, scanTruncated: scan.scanTruncated });
+
+		const details: ReadToolDetails = {
+			resolvedPath: absolutePath,
+			suffixResolution,
+			conflictCount: entries.length,
+		};
+		return toolResult<ReadToolDetails>(details).text(summary).sourcePath(absolutePath).done();
+	}
+
 	/**
 	 * Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://).
 	 * Supports pagination via offset/limit but rejects them when query extraction is used.
@@ -1763,6 +1889,10 @@ export const readToolRenderer = {
 		if (details?.summary) {
 			title += ` (summary: ${details.summary.elidedSpans} elided span${details.summary.elidedSpans === 1 ? "" : "s"})`;
 		}
+		if (details?.conflictCount && details.conflictCount > 0) {
+			const n = details.conflictCount;
+			title += ` ${uiTheme.fg("warning", `(⚠ ${n} conflict${n === 1 ? "" : "s"})`)}`;
+		}
 		let cachedWidth: number | undefined;
 		let cachedLines: string[] | undefined;
 		return {

package/src/tools/write.ts

@@ -16,6 +16,13 @@ import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth }
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import { parseArchivePathCandidates } from "./archive-reader";
 import { assertEditableFile } from "./auto-generated-guard";
+import {
+	type ConflictEntry,
+	expandContentTokens,
+	getConflictHistory,
+	parseConflictUri,
+	spliceConflict,
+} from "./conflict-detect";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { type OutputMeta, outputMeta } from "./output-meta";
 import { formatPathRelativeToCwd } from "./path-utils";
@@ -423,6 +430,185 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		}
 	}
 
+	/**
+	 * Resolve a single `conflict://<N>` write by splicing the recorded
+	 * marker region in the registered file with `replacementContent`,
+	 * then routing the new file content through the normal writethrough
+	 * pipeline so LSP format/diagnostics still run.
+	 *
+	 * Entry ids are session-stable: they keep working even after later
+	 * writes resolve other blocks in the same file. The recorded range
+	 * is re-validated on disk before splicing so an out-of-band edit
+	 * surfaces as a clear error instead of corrupting the file.
+	 */
+	async #resolveConflict(
+		entry: ConflictEntry,
+		replacementContent: string,
+		stripped: boolean,
+		signal: AbortSignal | undefined,
+		context: AgentToolContext | undefined,
+	): Promise<AgentToolResult<WriteToolDetails>> {
+		const absolutePath = entry.absolutePath;
+		if (!(await fs.exists(absolutePath))) {
+			throw new ToolError(`Conflict #${entry.id} target '${entry.displayPath}' no longer exists.`);
+		}
+
+		const expanded = expandContentTokens(replacementContent, entry);
+		const originalText = await Bun.file(absolutePath).text();
+		const newContent = spliceConflict(originalText, entry, expanded);
+
+		const batchRequest = getLspBatchRequest(context?.toolCall);
+		const diagnostics = await this.#writethrough(absolutePath, newContent, signal, undefined, batchRequest);
+		invalidateFsScanAfterWrite(absolutePath);
+		this.session.fileReadCache?.invalidate(absolutePath);
+		this.session.conflictHistory?.invalidate(entry.id);
+
+		const range =
+			entry.startLine === entry.endLine
+				? `line ${entry.startLine}`
+				: `lines ${entry.startLine}\u2013${entry.endLine}`;
+		let resultText = `Resolved conflict #${entry.id} at ${range} in ${entry.displayPath}.`;
+		if (stripped) {
+			resultText += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
+		}
+
+		if (!diagnostics) {
+			return {
+				content: [{ type: "text", text: resultText }],
+				details: {},
+			};
+		}
+		return {
+			content: [{ type: "text", text: resultText }],
+			details: {
+				diagnostics,
+				meta: outputMeta()
+					.diagnostics(diagnostics.summary, diagnostics.messages ?? [])
+					.get(),
+			},
+		};
+	}
+
+	/**
+	 * Bulk-resolve every registered conflict via `conflict://*`.
+	 *
+	 * Entries are grouped by file and applied bottom-up by recorded start
+	 * line so each splice keeps later anchors valid. `content` tokens are
+	 * expanded *per entry*, so `content: "@ours"` keeps each block's own
+	 * ours side rather than collapsing every conflict to the first
+	 * block's ours.
+	 *
+	 * All-or-nothing semantics within a file: if any splice for a file
+	 * fails (stale anchors, missing base for `@base`, etc.), that file is
+	 * left untouched and the error is surfaced. Files that succeed are
+	 * still written. The result text reports per-file counts so the agent
+	 * can re-read the failed files and retry.
+	 */
+	async #resolveAllConflicts(
+		replacementContent: string,
+		stripped: boolean,
+		signal: AbortSignal | undefined,
+		context: AgentToolContext | undefined,
+	): Promise<AgentToolResult<WriteToolDetails>> {
+		const history = getConflictHistory(this.session);
+		const allEntries = history.entries();
+		if (allEntries.length === 0) {
+			throw new ToolError(
+				"`conflict://*` has nothing to resolve — no conflicts are currently registered. Re-read the file(s) with conflicts first.",
+			);
+		}
+
+		const byFile = new Map<string, ConflictEntry[]>();
+		for (const entry of allEntries) {
+			const bucket = byFile.get(entry.absolutePath) ?? [];
+			bucket.push(entry);
+			byFile.set(entry.absolutePath, bucket);
+		}
+
+		const batchRequest = getLspBatchRequest(context?.toolCall);
+		const allDiagnostics: FileDiagnosticsResult[] = [];
+		const succeededFiles: { displayPath: string; count: number }[] = [];
+		const failedFiles: { displayPath: string; count: number; error: string }[] = [];
+		let totalResolvedIds = 0;
+
+		for (const [absolutePath, fileEntries] of byFile) {
+			const sample = fileEntries[0]!;
+			if (!(await fs.exists(absolutePath))) {
+				failedFiles.push({
+					displayPath: sample.displayPath,
+					count: fileEntries.length,
+					error: "file no longer exists",
+				});
+				continue;
+			}
+
+			fileEntries.sort((a, b) => b.startLine - a.startLine);
+
+			let text: string;
+			try {
+				text = await Bun.file(absolutePath).text();
+				for (const entry of fileEntries) {
+					const expanded = expandContentTokens(replacementContent, entry);
+					text = spliceConflict(text, entry, expanded);
+				}
+			} catch (error) {
+				failedFiles.push({
+					displayPath: sample.displayPath,
+					count: fileEntries.length,
+					error: error instanceof Error ? error.message : String(error),
+				});
+				continue;
+			}
+
+			const diagnostics = await this.#writethrough(absolutePath, text, signal, undefined, batchRequest);
+			invalidateFsScanAfterWrite(absolutePath);
+			this.session.fileReadCache?.invalidate(absolutePath);
+			for (const entry of fileEntries) history.invalidate(entry.id);
+			succeededFiles.push({ displayPath: sample.displayPath, count: fileEntries.length });
+			totalResolvedIds += fileEntries.length;
+			if (diagnostics) allDiagnostics.push(diagnostics);
+		}
+
+		const summaryLines: string[] = [];
+		const fileWord = (n: number) => (n === 1 ? "file" : "files");
+		const conflictWord = (n: number) => (n === 1 ? "conflict" : "conflicts");
+		if (succeededFiles.length > 0) {
+			summaryLines.push(
+				`Resolved ${totalResolvedIds} ${conflictWord(totalResolvedIds)} across ${succeededFiles.length} ${fileWord(succeededFiles.length)}:`,
+			);
+			for (const file of succeededFiles) {
+				summaryLines.push(`  ${file.displayPath}: ${file.count} ${conflictWord(file.count)}`);
+			}
+		}
+		if (failedFiles.length > 0) {
+			summaryLines.push(
+				`Failed to resolve ${failedFiles.length} ${fileWord(failedFiles.length)} — registered entries left intact for retry:`,
+			);
+			for (const file of failedFiles) {
+				summaryLines.push(`  ${file.displayPath}: ${file.count} ${conflictWord(file.count)} (${file.error})`);
+			}
+		}
+		if (stripped) {
+			summaryLines.push("Note: auto-stripped hashline display prefixes from content before writing.");
+		}
+		const resultText = summaryLines.join("\n");
+
+		if (allDiagnostics.length === 0) {
+			if (failedFiles.length > 0 && succeededFiles.length === 0) {
+				throw new ToolError(resultText);
+			}
+			return { content: [{ type: "text", text: resultText }], details: {} };
+		}
+		const mergedSummary = allDiagnostics.map(d => d.summary).join("\n");
+		const mergedMessages = allDiagnostics.flatMap(d => d.messages ?? []);
+		return {
+			content: [{ type: "text", text: resultText }],
+			details: {
+				meta: outputMeta().diagnostics(mergedSummary, mergedMessages).get(),
+			},
+		};
+	}
+
 	async execute(
 		_toolCallId: string,
 		{ path, content }: WriteParams,
@@ -433,6 +619,24 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		return untilAborted(signal, async () => {
 			// Strip hashline display prefixes (LINE+ID|) if the model copied them from read output
 			const { text: cleanContent, stripped } = stripWriteContent(this.session, content);
+			const conflictUri = parseConflictUri(path);
+			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\`.`,
+					);
+				}
+				if (conflictUri.id === "*") {
+					return this.#resolveAllConflicts(cleanContent, stripped, signal, context);
+				}
+				const entry = getConflictHistory(this.session).get(conflictUri.id);
+				if (!entry) {
+					throw new ToolError(
+						`Conflict #${conflictUri.id} not found. Conflict ids are registered when \`read\` surfaces a marker block; re-read the file to get a current id.`,
+					);
+				}
+				return this.#resolveConflict(entry, cleanContent, stripped, signal, context);
+			}
 			const resolvedArchivePath = await this.#resolveArchiveWritePath(path);
 			if (resolvedArchivePath) {
 				enforcePlanModeWrite(this.session, resolvedArchivePath.archivePath, {