@oh-my-pi/pi-coding-agent 6.1.0 → 6.7.0

package/src/core/tools/patch/shared.ts

@@ -0,0 +1,228 @@
+/**
+ * Shared utilities for edit tool TUI rendering.
+ */
+
+import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { getLanguageFromPath, type Theme } from "../../../modes/interactive/theme/theme";
+import type { RenderResultOptions } from "../../custom-tools/types";
+import type { FileDiagnosticsResult } from "../lsp/index";
+import {
+	createToolUIKit,
+	formatExpandHint,
+	getDiffStats,
+	shortenPath,
+	type ToolUIKit,
+	truncateDiffByHunk,
+} from "../render-utils";
+import type { DiffError, DiffResult, Operation } from "./types";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// LSP Batching
+// ═══════════════════════════════════════════════════════════════════════════
+
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+export function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string; flush: boolean } | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some((call) => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tool Details Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface EditToolDetails {
+	/** Unified diff of the changes made */
+	diff: string;
+	/** Line number of the first change in the new file (for editor navigation) */
+	firstChangedLine?: number;
+	/** Diagnostic result (if available) */
+	diagnostics?: FileDiagnosticsResult;
+	/** Operation type (patch mode only) */
+	op?: Operation;
+	/** New path after move/rename (patch mode only) */
+	rename?: string;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TUI Renderer
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface EditRenderArgs {
+	path?: string;
+	file_path?: string;
+	oldText?: string;
+	newText?: string;
+	patch?: string;
+	all?: boolean;
+	// Patch mode fields
+	op?: Operation;
+	rename?: string;
+	diff?: string;
+}
+
+/** Extended context for edit tool rendering */
+export interface EditRenderContext {
+	/** Pre-computed diff preview (computed before tool executes) */
+	editDiffPreview?: DiffResult | DiffError;
+	/** Function to render diff text with syntax highlighting */
+	renderDiff?: (diffText: string, options?: { filePath?: string }) => string;
+}
+
+const EDIT_DIFF_PREVIEW_HUNKS = 2;
+const EDIT_DIFF_PREVIEW_LINES = 24;
+
+function countLines(text: string): number {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+
+function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
+	const icon = uiTheme.getLangIcon(language);
+	if (lineCount !== null) {
+		return uiTheme.fg("dim", `${icon} ${lineCount} lines`);
+	}
+	return uiTheme.fg("dim", `${icon}`);
+}
+
+function renderDiffSection(
+	diff: string,
+	rawPath: string,
+	expanded: boolean,
+	uiTheme: Theme,
+	ui: ToolUIKit,
+	renderDiffFn: (t: string, o?: { filePath?: string }) => string,
+): string {
+	let text = "";
+	const diffStats = getDiffStats(diff);
+	text += `\n${uiTheme.fg("dim", uiTheme.format.bracketLeft)}${ui.formatDiffStats(
+		diffStats.added,
+		diffStats.removed,
+		diffStats.hunks,
+	)}${uiTheme.fg("dim", uiTheme.format.bracketRight)}`;
+
+	const {
+		text: truncatedDiff,
+		hiddenHunks,
+		hiddenLines,
+	} = expanded
+		? { text: diff, hiddenHunks: 0, hiddenLines: 0 }
+		: truncateDiffByHunk(diff, EDIT_DIFF_PREVIEW_HUNKS, EDIT_DIFF_PREVIEW_LINES);
+
+	text += `\n\n${renderDiffFn(truncatedDiff, { filePath: rawPath })}`;
+	if (!expanded && (hiddenHunks > 0 || hiddenLines > 0)) {
+		const remainder: string[] = [];
+		if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
+		if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
+		text += uiTheme.fg(
+			"toolOutput",
+			`\n${uiTheme.format.ellipsis} (${remainder.join(", ")}) ${formatExpandHint(uiTheme)}`,
+		);
+	}
+	return text;
+}
+
+export const editToolRenderer = {
+	mergeCallAndResult: true,
+
+	renderCall(args: EditRenderArgs, uiTheme: Theme): Component {
+		const ui = createToolUIKit(uiTheme);
+		const rawPath = args.file_path || args.path || "";
+		const filePath = shortenPath(rawPath);
+		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
+		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
+		let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", uiTheme.format.ellipsis);
+
+		// Add arrow for move/rename operations
+		if (args.rename) {
+			pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(args.rename))}`;
+		}
+
+		// Show operation type for patch mode
+		const opTitle = args.op === "create" ? "Create" : args.op === "delete" ? "Delete" : "Edit";
+		const text = `${ui.title(opTitle)} ${editIcon} ${pathDisplay}`;
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: EditToolDetails; isError?: boolean },
+		options: RenderResultOptions & { renderContext?: EditRenderContext },
+		uiTheme: Theme,
+		args?: EditRenderArgs,
+	): Component {
+		const ui = createToolUIKit(uiTheme);
+		const { expanded, renderContext } = options;
+		const rawPath = args?.file_path || args?.path || "";
+		const filePath = shortenPath(rawPath);
+		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
+		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
+		const editDiffPreview = renderContext?.editDiffPreview;
+		const renderDiffFn = renderContext?.renderDiff ?? ((t: string) => t);
+
+		// Get op and rename from args or details
+		const op = args?.op || result.details?.op;
+		const rename = args?.rename || result.details?.rename;
+
+		// Build path display with line number if available
+		let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", uiTheme.format.ellipsis);
+		const firstChangedLine =
+			(editDiffPreview && "firstChangedLine" in editDiffPreview ? editDiffPreview.firstChangedLine : undefined) ||
+			(result.details && !result.isError ? result.details.firstChangedLine : undefined);
+		if (firstChangedLine) {
+			pathDisplay += uiTheme.fg("warning", `:${firstChangedLine}`);
+		}
+
+		// Add arrow for rename operations
+		if (rename) {
+			pathDisplay += ` ${uiTheme.fg("dim", "→")} ${uiTheme.fg("accent", shortenPath(rename))}`;
+		}
+
+		// Show operation type for patch mode
+		const opTitle = op === "create" ? "Create" : op === "delete" ? "Delete" : "Edit";
+		let text = `${uiTheme.fg("toolTitle", uiTheme.bold(opTitle))} ${editIcon} ${pathDisplay}`;
+
+		// Skip metadata line for delete operations
+		if (op !== "delete") {
+			const editLineCount = countLines(args?.newText ?? args?.oldText ?? args?.diff ?? args?.patch ?? "");
+			text += `\n${formatMetadataLine(editLineCount, editLanguage, uiTheme)}`;
+		}
+
+		if (result.isError) {
+			// Show error from result
+			const errorText = result.content?.find((c) => c.type === "text")?.text ?? "";
+			if (errorText) {
+				text += `\n\n${uiTheme.fg("error", errorText)}`;
+			}
+		} else if (result.details?.diff) {
+			// Prefer actual diff after execution
+			text += renderDiffSection(result.details.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
+		} else if (editDiffPreview) {
+			// Use cached diff preview when no actual diff is available
+			if ("error" in editDiffPreview) {
+				text += `\n\n${uiTheme.fg("error", editDiffPreview.error)}`;
+			} else if (editDiffPreview.diff) {
+				text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, ui, renderDiffFn);
+			}
+		}
+
+		// Show LSP diagnostics if available
+		if (result.details?.diagnostics) {
+			text += ui.formatDiagnostics(result.details.diagnostics, expanded, (fp: string) =>
+				uiTheme.getLangIcon(getLanguageFromPath(fp)),
+			);
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

package/src/core/tools/patch/types.ts

@@ -0,0 +1,244 @@
+/**
+ * Shared types for the edit tool module.
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// File System Abstraction
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Abstraction for file system operations to support LSP writethrough */
+export interface FileSystem {
+	exists(path: string): Promise<boolean>;
+	read(path: string): Promise<string>;
+	readBinary?: (path: string) => Promise<Uint8Array>;
+	write(path: string, content: string): Promise<void>;
+	delete(path: string): Promise<void>;
+	mkdir(path: string): Promise<void>;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Fuzzy Matching Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Result of a fuzzy match operation */
+export interface FuzzyMatch {
+	/** The actual text that was matched */
+	actualText: string;
+	/** Character index where the match starts */
+	startIndex: number;
+	/** Line number where the match starts (1-indexed) */
+	startLine: number;
+	/** Confidence score (0-1, where 1 is exact match) */
+	confidence: number;
+}
+
+/** Outcome of attempting to find a match */
+export interface MatchOutcome {
+	/** The match if found with sufficient confidence */
+	match?: FuzzyMatch;
+	/** The closest match found (may be below threshold) */
+	closest?: FuzzyMatch;
+	/** Number of occurrences if multiple exact matches found */
+	occurrences?: number;
+	/** Number of fuzzy matches above threshold */
+	fuzzyMatches?: number;
+}
+
+/** Result of a sequence search */
+export interface SequenceSearchResult {
+	/** Starting line index of the match (0-indexed) */
+	index: number | undefined;
+	/** Confidence score (1.0 for exact match, lower for fuzzy) */
+	confidence: number;
+	/** Number of matches at the same confidence level (for ambiguity detection) */
+	matchCount?: number;
+}
+
+/** Result of a context line search */
+export interface ContextLineResult {
+	/** Index of the matching line (0-indexed) */
+	index: number | undefined;
+	/** Confidence score (1.0 for exact match, lower for fuzzy) */
+	confidence: number;
+	/** Number of matches at the same confidence level (for ambiguity detection) */
+	matchCount?: number;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Patch Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type Operation = "create" | "delete" | "update";
+
+/** Input for a patch operation */
+export interface PatchInput {
+	/** File path (relative or absolute) */
+	path: string;
+	/** Operation type */
+	op: Operation;
+	/** New path for rename (update only) */
+	rename?: string;
+	/** File content (create) or diff hunks (update) */
+	diff?: string;
+}
+
+/** Normalized patch input used internally by the applicator. */
+export interface NormalizedPatchInput {
+	path: string;
+	op: Operation;
+	rename?: string;
+	diff?: string;
+}
+
+export function normalizePatchInput(input: PatchInput): NormalizedPatchInput {
+	return {
+		path: input.path,
+		op: input.op ?? "update",
+		rename: input.rename,
+		diff: input.diff,
+	};
+}
+
+/** A single hunk/chunk in a diff */
+export interface DiffHunk {
+	/** Context line to narrow down position (e.g., class/method definition) */
+	changeContext?: string;
+	/** 1-based line hint from unified diff headers (old file) */
+	oldStartLine?: number;
+	/** 1-based line hint from unified diff headers (new file) */
+	newStartLine?: number;
+	/** True if the hunk contains context lines (space-prefixed) */
+	hasContextLines: boolean;
+	/** Lines to be replaced (old content) */
+	oldLines: string[];
+	/** Lines to replace with (new content) */
+	newLines: string[];
+	/** If true, oldLines must occur at end of file */
+	isEndOfFile: boolean;
+}
+
+/** Describes a change made to a file */
+export interface FileChange {
+	type: Operation;
+	path: string;
+	newPath?: string;
+	oldContent?: string;
+	newContent?: string;
+}
+
+/** Result of applying a patch */
+export interface ApplyPatchResult {
+	change: FileChange;
+}
+
+/** Options for applying a patch */
+export interface ApplyPatchOptions {
+	/** Working directory for resolving relative paths */
+	cwd: string;
+	/** Dry run - compute changes without writing */
+	dryRun?: boolean;
+	/** Similarity threshold for fuzzy matching */
+	fuzzyThreshold?: number;
+	/** Allow fuzzy/partial matching when applying hunks */
+	allowFuzzy?: boolean;
+	/** File system abstraction (defaults to Bun-based implementation) */
+	fs?: FileSystem;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Diff Generation Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Result of generating a diff */
+export interface DiffResult {
+	/** The unified diff string */
+	diff: string;
+	/** Line number of the first change in the new file */
+	firstChangedLine: number | undefined;
+}
+
+/** Error from diff computation */
+export interface DiffError {
+	error: string;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Error Classes
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class ParseError extends Error {
+	constructor(
+		message: string,
+		public readonly lineNumber?: number,
+	) {
+		super(lineNumber !== undefined ? `Line ${lineNumber}: ${message}` : message);
+		this.name = "ParseError";
+	}
+}
+
+export class ApplyPatchError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "ApplyPatchError";
+	}
+}
+
+export class EditMatchError extends Error {
+	constructor(
+		public readonly path: string,
+		public readonly searchText: string,
+		public readonly closest: FuzzyMatch | undefined,
+		public readonly options: { allowFuzzy: boolean; threshold: number; fuzzyMatches?: number },
+	) {
+		super(EditMatchError.formatMessage(path, searchText, closest, options));
+		this.name = "EditMatchError";
+	}
+
+	static formatMessage(
+		path: string,
+		searchText: string,
+		closest: FuzzyMatch | undefined,
+		options: { allowFuzzy: boolean; threshold: number; fuzzyMatches?: number },
+	): string {
+		if (!closest) {
+			return options.allowFuzzy
+				? `Could not find a close enough match in ${path}.`
+				: `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`;
+		}
+
+		const similarity = Math.round(closest.confidence * 100);
+		const searchLines = searchText.split("\n");
+		const actualLines = closest.actualText.split("\n");
+		const { oldLine, newLine } = findFirstDifferentLine(searchLines, actualLines);
+		const thresholdPercent = Math.round(options.threshold * 100);
+
+		const hint = options.allowFuzzy
+			? options.fuzzyMatches && options.fuzzyMatches > 1
+				? `Found ${options.fuzzyMatches} high-confidence matches. Provide more context to make it unique.`
+				: `Closest match was below the ${thresholdPercent}% similarity threshold.`
+			: "Fuzzy matching is disabled. Enable 'Edit fuzzy match' in settings to accept high-confidence matches.";
+
+		return [
+			options.allowFuzzy
+				? `Could not find a close enough match in ${path}.`
+				: `Could not find the exact text in ${path}.`,
+			``,
+			`Closest match (${similarity}% similar) at line ${closest.startLine}:`,
+			`  - ${oldLine}`,
+			`  + ${newLine}`,
+			hint,
+		].join("\n");
+	}
+}
+
+function findFirstDifferentLine(oldLines: string[], newLines: string[]): { oldLine: string; newLine: string } {
+	const max = Math.max(oldLines.length, newLines.length);
+	for (let i = 0; i < max; i++) {
+		const oldLine = oldLines[i] ?? "";
+		const newLine = newLines[i] ?? "";
+		if (oldLine !== newLine) {
+			return { oldLine, newLine };
+		}
+	}
+	return { oldLine: oldLines[0] ?? "", newLine: newLines[0] ?? "" };
+}