@oh-my-pi/pi-coding-agent 11.10.2 → 11.10.4

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [11.10.4] - 2026-02-10
+
+### Added
+
+- Hashline diff computation with `computeHashlineDiff` function for preview rendering of hashline-mode edits
+- Streaming preview display for hashline edits in tool execution UI showing edit sources and destinations
+- Streaming hash line computation with progress updates via `onUpdate` callback in read tool
+- Optional `onCollectedLine` callback parameter to `streamLinesFromFile` for line collection tracking
+
+### Changed
+
+- Edit tool renderer now displays computed preview diffs for hashline operations before execution
+- Read tool now streams hash lines incrementally instead of computing them all at once, improving responsiveness for large files
+- Refactored hash line formatting to use async `streamHashLinesFromLines` for better performance
+
+## [11.10.3] - 2026-02-10
+### Added
+
+- Exported `./patch/*` subpath for direct access to patch utilities
+
 ## [11.10.2] - 2026-02-10
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "11.10.2",
+	"version": "11.10.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -58,6 +58,10 @@
 			"types": "./src/internal-urls/*.ts",
 			"import": "./src/internal-urls/*.ts"
 		},
+		"./patch/*": {
+			"types": "./src/patch/*.ts",
+			"import": "./src/patch/*.ts"
+		},
 		"./*": {
 			"types": "./src/*.ts",
 			"import": "./src/*.ts"
@@ -80,12 +84,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "11.10.2",
-		"@oh-my-pi/pi-agent-core": "11.10.2",
-		"@oh-my-pi/pi-ai": "11.10.2",
-		"@oh-my-pi/pi-natives": "11.10.2",
-		"@oh-my-pi/pi-tui": "11.10.2",
-		"@oh-my-pi/pi-utils": "11.10.2",
+		"@oh-my-pi/omp-stats": "11.10.4",
+		"@oh-my-pi/pi-agent-core": "11.10.4",
+		"@oh-my-pi/pi-ai": "11.10.4",
+		"@oh-my-pi/pi-natives": "11.10.4",
+		"@oh-my-pi/pi-tui": "11.10.4",
+		"@oh-my-pi/pi-utils": "11.10.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
 		"chalk": "^5.6.2",

package/src/config/model-registry.ts

@@ -6,9 +6,9 @@ import {
 	type Model,
 	normalizeDomain,
 } from "@oh-my-pi/pi-ai";
-import { type ConfigError, ConfigFile } from "@oh-my-pi/pi-coding-agent/config";
 import { type Static, Type } from "@sinclair/typebox";
 import AjvModule from "ajv";
+import { type ConfigError, ConfigFile } from "../config";
 import type { ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage } from "../session/auth-storage";
 

package/src/config/settings.ts

@@ -13,14 +13,14 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ModelRole } from "@oh-my-pi/pi-coding-agent/config/model-registry";
-import { type EditMode, normalizeEditMode } from "@oh-my-pi/pi-coding-agent/patch";
 import { isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { type Settings as SettingsCapabilityItem, settingsCapability } from "../capability/settings";
 import { getAgentDbPath, getAgentDir } from "../config";
+import type { ModelRole } from "../config/model-registry";
 import { loadCapability } from "../discovery";
 import { setColorBlindMode, setSymbolPreset, setTheme } from "../modes/theme/theme";
+import { type EditMode, normalizeEditMode } from "../patch";
 import { AgentStorage } from "../session/agent-storage";
 import { withFileLock } from "./file-lock";
 import {

package/src/modes/components/tool-execution.ts

@@ -15,7 +15,13 @@ import {
 import { logger, sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
-import { computeEditDiff, computePatchDiff, type EditDiffError, type EditDiffResult } from "../../patch";
+import {
+	computeEditDiff,
+	computeHashlineDiff,
+	computePatchDiff,
+	type EditDiffError,
+	type EditDiffResult,
+} from "../../patch";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
 import {
 	formatArgsInline,
@@ -192,6 +198,24 @@ export class ToolExecutionComponent extends Container {
 			});
 			return;
 		}
+		const edits = this.#args?.edits;
+		if (path && Array.isArray(edits)) {
+			const argsKey = JSON.stringify({ path, edits });
+			if (this.#editDiffArgsKey === argsKey) return;
+			this.#editDiffArgsKey = argsKey;
+
+			computeHashlineDiff({ path, edits }, this.#cwd).then(result => {
+				if (this.#editDiffArgsKey === argsKey) {
+					this.#editDiffPreview = result;
+					if ("diff" in result && result.diff) {
+						(this.#args as Record<string, unknown>).previewDiff = result.diff;
+					}
+					this.#updateDisplay();
+					this.#ui.requestRender();
+				}
+			});
+			return;
+		}
 
 		const oldText = this.#args?.old_text;
 		const newText = this.#args?.new_text;

package/src/patch/diff.ts

@@ -8,8 +8,9 @@ import * as Diff from "diff";
 import { resolveToCwd } from "../tools/path-utils";
 import { previewPatch } from "./applicator";
 import { DEFAULT_FUZZY_THRESHOLD, findMatch } from "./fuzzy";
+import { applyHashlineEdits } from "./hashline";
 import { adjustIndentation, normalizeToLF, stripBom } from "./normalize";
-import type { DiffError, DiffResult, PatchInput } from "./types";
+import type { DiffError, DiffResult, HashlineEdit, PatchInput } from "./types";
 import { EditMatchError } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -363,3 +364,45 @@ export async function computePatchDiff(
 		return { error: err instanceof Error ? err.message : String(err) };
 	}
 }
+/**
+ * Compute the diff for a hashline operation without applying it.
+ * Used for preview rendering in the TUI before hashline-mode edits execute.
+ */
+export async function computeHashlineDiff(
+	input: { path: string; edits: HashlineEdit[] },
+	cwd: string,
+): Promise<DiffResult | DiffError> {
+	const { path, edits } = input;
+	const absolutePath = resolveToCwd(path, cwd);
+
+	try {
+		const file = Bun.file(absolutePath);
+		try {
+			if (!(await file.exists())) {
+				return { error: `File not found: ${path}` };
+			}
+		} catch {
+			return { error: `File not found: ${path}` };
+		}
+
+		let rawContent: string;
+		try {
+			rawContent = await file.text();
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return { error: message || `Unable to read ${path}` };
+		}
+
+		const { text: content } = stripBom(rawContent);
+		const normalizedContent = normalizeToLF(content);
+
+		const result = applyHashlineEdits(normalizedContent, edits);
+		if (normalizedContent === result.content) {
+			return { error: `No changes would be made to ${path}. The edits produce identical content.` };
+		}
+
+		return generateDiffString(normalizedContent, result.content);
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}

package/src/patch/index.ts

@@ -44,7 +44,14 @@ import { EditMatchError } from "./types";
 // Application
 export { applyPatch, defaultFileSystem, previewPatch } from "./applicator";
 // Diff generation
-export { computeEditDiff, computePatchDiff, generateDiffString, generateUnifiedDiffString, replaceText } from "./diff";
+export {
+	computeEditDiff,
+	computeHashlineDiff,
+	computePatchDiff,
+	generateDiffString,
+	generateUnifiedDiffString,
+	replaceText,
+} from "./diff";
 
 // Fuzzy matching
 export { DEFAULT_FUZZY_THRESHOLD, findContextLine, findMatch as findEditMatch, findMatch, seekSequence } from "./fuzzy";

package/src/patch/shared.ts

@@ -21,7 +21,7 @@ import {
 } from "../tools/render-utils";
 import type { RenderCallOptions } from "../tools/renderers";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
-import type { DiffError, DiffResult, Operation } from "./types";
+import type { DiffError, DiffResult, HashlineEdit, Operation } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // LSP Batching
@@ -77,6 +77,12 @@ interface EditRenderArgs {
 	op?: Operation;
 	rename?: string;
 	diff?: string;
+	/**
+	 * Computed preview diff (used when tool args don't include a diff, e.g. hashline mode).
+	 */
+	previewDiff?: string;
+	// Hashline mode fields
+	edits?: HashlineEdit[];
 }
 
 /** Extended context for edit tool rendering */
@@ -94,22 +100,80 @@ function countLines(text: string): number {
 	return text.split("\n").length;
 }
 
-function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme): string {
+function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
 	const lines = diff.split("\n");
 	const total = lines.length;
 	const displayLines = lines.slice(-EDIT_STREAMING_PREVIEW_LINES);
 	const hidden = total - displayLines.length;
-
 	let text = "\n\n";
 	if (hidden > 0) {
 		text += uiTheme.fg("dim", `… (${hidden} earlier lines)\n`);
 	}
 	text += renderDiffColored(displayLines.join("\n"), { filePath: rawPath });
-	text += uiTheme.fg("dim", `\n… (streaming)`);
+	text += uiTheme.fg("dim", `\n… (${label})`);
 	return text;
 }
 
+function formatStreamingHashlineEdits(edits: HashlineEdit[], uiTheme: Theme, ui: ToolUIKit): string {
+	const MAX_EDITS = 4;
+	const MAX_DST_LINES = 8;
+
+	let text = "\n\n";
+	text += uiTheme.fg("dim", `[${edits.length} hashline edit${edits.length === 1 ? "" : "s"}]`);
+	text += "\n";
+
+	let shownEdits = 0;
+	let shownDstLines = 0;
+
+	for (const edit of edits) {
+		shownEdits++;
+		if (shownEdits > MAX_EDITS) break;
+
+		text += uiTheme.fg("toolOutput", ui.truncate(replaceTabs(formatHashlineSrc(edit.src)), 120));
+		text += "\n";
+
+		if (edit.dst === "") {
+			text += uiTheme.fg("dim", ui.truncate("  (delete)", 120));
+			text += "\n";
+			continue;
+		}
+
+		const dstLines = edit.dst.split("\n");
+		for (const dstLine of dstLines) {
+			shownDstLines++;
+			if (shownDstLines > MAX_DST_LINES) break;
+			text += uiTheme.fg("toolOutput", ui.truncate(replaceTabs(`+ ${dstLine}`), 120));
+			text += "\n";
+		}
+		if (shownDstLines > MAX_DST_LINES) break;
+	}
+
+	if (edits.length > MAX_EDITS) {
+		text += uiTheme.fg("dim", `… (${edits.length - MAX_EDITS} more edits)`);
+	}
+	if (shownDstLines > MAX_DST_LINES) {
+		text += uiTheme.fg("dim", `\n… (${shownDstLines - MAX_DST_LINES} more dst lines)`);
+	}
+
+	return text.trimEnd();
+
+	function formatHashlineSrc(src: HashlineEdit["src"]): string {
+		switch (src.kind) {
+			case "single":
+				return `• single ${src.ref}`;
+			case "range":
+				return `• range ${src.start}..${src.end}`;
+			case "insertAfter":
+				return `• insertAfter ${src.after}..`;
+			case "insertBefore":
+				return `• insertBefore ..${src.before}`;
+			case "substring":
+				return `• substring ${JSON.stringify(src.needle)}`;
+		}
+	}
+}
+
 function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
 	const icon = uiTheme.getLangIcon(language);
 	if (lineCount !== null) {
@@ -175,8 +239,12 @@ export const editToolRenderer = {
 		let text = `${ui.title(opTitle)} ${spinner ? `${spinner} ` : ""}${editIcon} ${pathDisplay}`;
 
 		// Show streaming preview of diff/content
-		if (args.diff && args.op) {
+		if (args.previewDiff) {
+			text += formatStreamingDiff(args.previewDiff, rawPath, uiTheme, "preview");
+		} else if (args.diff && args.op) {
 			text += formatStreamingDiff(args.diff, rawPath, uiTheme);
+		} else if (args.edits && args.edits.length > 0) {
+			text += formatStreamingHashlineEdits(args.edits, uiTheme, ui);
 		} else if (args.diff) {
 			const previewLines = args.diff.split("\n");
 			const maxLines = 6;

package/src/web/search/render.ts

@@ -4,7 +4,6 @@
  * Tree-based rendering with collapsed/expanded states for web search results.
  */
 
-import { getSearchProvider } from "@oh-my-pi/pi-coding-agent/web/search/provider";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
@@ -23,6 +22,7 @@ import {
 } from "../../tools/render-utils";
 import { renderStatusLine, renderTreeList } from "../../tui";
 import { CachedOutputBlock } from "../../tui/output-block";
+import { getSearchProvider } from "./provider";
 import type { SearchResponse } from "./types";
 
 const MAX_COLLAPSED_ANSWER_LINES = PREVIEW_LIMITS.COLLAPSED_LINES;