@oh-my-pi/pi-coding-agent 15.3.1 → 15.4.1

package/src/edit/file-read-cache.ts

@@ -11,68 +11,101 @@
  * Scoped per `ToolSession`: the cache lives on the session object itself, so
  * different sessions never share snapshots and entries get reclaimed when
  * the session goes out of scope. Each session keeps a small LRU window of
- * paths; the cache always reflects what *this* session most recently saw,
- * so it stays correct by construction even when this session writes the
- * file itself — the next read after the write refreshes the entry.
+ * paths; each path keeps a short ring of recent snapshots so follow-up edits
+ * can recover from the agent's own prior writes as well as stale reads.
  */
 import { LRUCache } from "lru-cache/raw";
 import type { ToolSession } from "../tools";
 
 const MAX_PATHS_PER_SESSION = 30;
+const MAX_SNAPSHOTS_PER_PATH = 4;
 
 export interface FileReadSnapshot {
 	/** 1-indexed line number → exact line content as observed by `read`/`search`. */
 	lines: Map<number, string>;
+	/** Full normalized text when the read path observed the whole file. */
+	fullText?: string;
+	/** 4-hex hash of `fullText`, or a sparse snapshot hash supplied by search. */
+	fileHash?: string;
 	recordedAt: number;
 }
 
+interface FileReadSnapshotMetadata {
+	fullText?: string;
+	fileHash?: string;
+}
+
 export class FileReadCache {
-	#snapshots = new LRUCache<string, FileReadSnapshot>({ max: MAX_PATHS_PER_SESSION });
+	#snapshots = new LRUCache<string, FileReadSnapshot[]>({ max: MAX_PATHS_PER_SESSION });
 
 	/** Look up the most recent snapshot for `absPath`, or `null` if absent. */
 	get(absPath: string): FileReadSnapshot | null {
-		return this.#snapshots.get(absPath) ?? null;
+		return this.#snapshots.get(absPath)?.[0] ?? null;
+	}
+
+	/** Look up the most recent snapshot for `absPath` whose file hash matches. */
+	getByHash(absPath: string, fileHash: string): FileReadSnapshot | null {
+		const history = this.#snapshots.get(absPath);
+		return history?.find(snapshot => snapshot.fileHash === fileHash) ?? null;
 	}
 
 	/** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
-	recordContiguous(absPath: string, startLine: number, lines: readonly string[]): void {
-		if (lines.length === 0) return;
+	recordContiguous(
+		absPath: string,
+		startLine: number,
+		lines: readonly string[],
+		metadata: FileReadSnapshotMetadata = {},
+	): void {
+		if (lines.length === 0 && metadata.fullText === undefined) return;
 		const entries: Array<readonly [number, string]> = lines.map((line, idx) => [startLine + idx, line] as const);
-		this.#record(absPath, entries);
+		this.#record(absPath, entries, metadata);
 	}
 
 	/** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
-	recordSparse(absPath: string, entries: Iterable<readonly [number, string]>): void {
+	recordSparse(
+		absPath: string,
+		entries: Iterable<readonly [number, string]>,
+		metadata: FileReadSnapshotMetadata = {},
+	): void {
 		const arr = Array.from(entries);
-		if (arr.length === 0) return;
-		this.#record(absPath, arr);
+		if (arr.length === 0 && metadata.fullText === undefined) return;
+		this.#record(absPath, arr, metadata);
 	}
 
-	/** Drop the snapshot for a single path. */
+	/** Drop the snapshot history for a single path. */
 	invalidate(absPath: string): void {
 		this.#snapshots.delete(absPath);
 	}
 
-	/** Drop every snapshot. */
+	/** Drop every snapshot history. */
 	clear(): void {
 		this.#snapshots.clear();
 	}
 
-	#record(absPath: string, entries: ReadonlyArray<readonly [number, string]>): void {
-		const existing = this.#snapshots.get(absPath);
-		if (existing && hasConflict(existing.lines, entries)) {
-			// File content has changed since we last recorded. Drop the stale
-			// snapshot and start fresh with whatever we just observed.
-			this.#snapshots.set(absPath, { lines: new Map(entries), recordedAt: Date.now() });
-			return;
-		}
-		if (existing) {
-			for (const [lineNum, content] of entries) existing.lines.set(lineNum, content);
-			existing.recordedAt = Date.now();
+	#record(
+		absPath: string,
+		entries: ReadonlyArray<readonly [number, string]>,
+		metadata: FileReadSnapshotMetadata,
+	): void {
+		const history = this.#snapshots.get(absPath) ?? [];
+		const head = history[0];
+		const now = Date.now();
+		if (head && !hasConflict(head.lines, entries) && !hasHashConflict(head, metadata)) {
+			for (const [lineNum, content] of entries) head.lines.set(lineNum, content);
+			if (metadata.fullText !== undefined) head.fullText = metadata.fullText;
+			if (metadata.fileHash !== undefined) head.fileHash = metadata.fileHash;
+			head.recordedAt = now;
 			// `get` above already touched LRU recency for this key.
 			return;
 		}
-		this.#snapshots.set(absPath, { lines: new Map(entries), recordedAt: Date.now() });
+
+		const nextSnapshot: FileReadSnapshot = {
+			lines: new Map(entries),
+			...metadata,
+			recordedAt: now,
+		};
+		const dedupedHistory = history.filter(snapshot => !isSameSnapshotIdentity(snapshot, nextSnapshot));
+		this.#snapshots.set(absPath, [nextSnapshot, ...dedupedHistory].slice(0, MAX_SNAPSHOTS_PER_PATH));
 	}
 }
 
@@ -84,6 +117,16 @@ function hasConflict(existing: Map<number, string>, incoming: ReadonlyArray<read
 	return false;
 }
 
+function hasHashConflict(existing: FileReadSnapshot, metadata: FileReadSnapshotMetadata): boolean {
+	return metadata.fileHash !== undefined && existing.fileHash !== undefined && metadata.fileHash !== existing.fileHash;
+}
+
+function isSameSnapshotIdentity(left: FileReadSnapshot, right: FileReadSnapshot): boolean {
+	if (left.fileHash !== undefined && right.fileHash !== undefined) return left.fileHash === right.fileHash;
+	if (left.fullText !== undefined && right.fullText !== undefined) return left.fullText === right.fullText;
+	return false;
+}
+
 /**
  * Look up (or lazily create) the file-read cache attached to a session. The
  * cache is stored as `session.fileReadCache` so it lives exactly as long as

package/src/edit/index.ts

@@ -1,6 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
-import type * as z from "zod/v4";
 import {
 	executeHashlineSingle,
 	HashlineMismatchError,
@@ -21,9 +20,7 @@ import hashlineDescription from "../prompts/tools/hashline.md" with { type: "tex
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
 import type { ToolSession } from "../tools";
-import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
-import type { VimToolDetails } from "../vim/types";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
@@ -35,7 +32,7 @@ export * from "./apply-patch";
 export * from "./diff";
 export * from "./file-read-cache";
 
-// Resolve the `$HFMT$`, `$HOP_*$`, `$HOP_CHARS$`, and `$HFILE$` placeholders in the hashline Lark grammar.
+// Resolve hashline grammar placeholders from the TypeScript constants.
 const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
 
 export * from "../hashline";
@@ -50,12 +47,9 @@ type TInput =
 	| typeof replaceEditSchema
 	| typeof patchEditSchema
 	| typeof hashlineEditParamsSchema
-	| typeof vimSchema
 	| typeof applyPatchSchema;
 
-type VimParams = z.infer<typeof vimSchema>;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
-type EditToolResultDetails = EditToolDetails | VimToolDetails;
+type EditParams = ReplaceParams | PatchParams | HashlineParams | ApplyPatchParams;
 
 type EditModeDefinition = {
 	description: (session: ToolSession) => string;
@@ -65,8 +59,8 @@ type EditModeDefinition = {
 		params: EditParams,
 		signal: AbortSignal | undefined,
 		batchRequest: LspBatchRequest | undefined,
-		onUpdate?: (partialResult: AgentToolResult<EditToolResultDetails, TInput>) => void,
-	) => Promise<AgentToolResult<EditToolResultDetails, TInput>>;
+		onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+	) => Promise<AgentToolResult<EditToolDetails, TInput>>;
 };
 
 function resolveConfiguredEditMode(rawEditMode: string): EditMode | undefined {
@@ -284,7 +278,6 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #fuzzyThreshold: number;
 	readonly #writethrough: WritethroughCallback;
 	readonly #editMode?: EditMode;
-	readonly #vimTool: VimTool;
 	readonly #pendingDeferredFetches = new Map<string, AbortController>();
 
 	constructor(private readonly session: ToolSession) {
@@ -298,7 +291,6 @@ export class EditTool implements AgentTool<TInput> {
 		this.#allowFuzzy = resolveAllowFuzzy(session, editFuzzy);
 		this.#fuzzyThreshold = resolveFuzzyThreshold(session, editFuzzyThreshold);
 		this.#writethrough = createEditWritethrough(session);
-		this.#vimTool = new VimTool(session);
 	}
 
 	get mode(): EditMode {
@@ -341,9 +333,9 @@ export class EditTool implements AgentTool<TInput> {
 		_toolCallId: string,
 		params: EditParams,
 		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<EditToolResultDetails, TInput>,
+		onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>,
 		context?: AgentToolContext,
-	): Promise<AgentToolResult<EditToolResultDetails, TInput>> {
+	): Promise<AgentToolResult<EditToolDetails, TInput>> {
 		const modeDefinition = this.#getModeDefinition();
 		return modeDefinition.execute(this, params, signal, getLspBatchRequest(context?.toolCall), onUpdate);
 	}
@@ -460,29 +452,6 @@ export class EditTool implements AgentTool<TInput> {
 					return executeSinglePathEntries(path, runs, batchRequest, onUpdate);
 				},
 			},
-			vim: {
-				description: () => this.#vimTool.description,
-				parameters: vimSchema,
-				execute: async (
-					tool: EditTool,
-					params: EditParams,
-					signal: AbortSignal | undefined,
-					_batchRequest: LspBatchRequest | undefined,
-					onUpdate?: (partialResult: AgentToolResult<EditToolResultDetails, TInput>) => void,
-				) => {
-					const handleUpdate = onUpdate
-						? (partialResult: AgentToolResult<VimToolDetails>) => {
-								onUpdate(partialResult as AgentToolResult<EditToolResultDetails, TInput>);
-							}
-						: undefined;
-					return (await tool.#vimTool.execute(
-						"edit",
-						params as VimParams,
-						signal,
-						handleUpdate,
-					)) as AgentToolResult<EditToolResultDetails, TInput>;
-				},
-			},
 		}[this.mode];
 	}
 

package/src/edit/renderer.ts

@@ -25,10 +25,8 @@ import {
 	shortenPath,
 	truncateDiffByHunk,
 } from "../tools/render-utils";
-import { type VimRenderArgs, vimToolRenderer } from "../tools/vim";
 import { fileHyperlink, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
 import type { EditMode } from "../utils/edit-mode";
-import type { VimToolDetails } from "../vim/types";
 import type { DiffError, DiffResult } from "./diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import type { Operation } from "./modes/patch";
@@ -127,31 +125,6 @@ interface ApplyPatchRenderSummary {
 	error?: string;
 }
 
-function isVimRenderArgs(args: EditRenderArgs | VimRenderArgs): args is VimRenderArgs {
-	return (
-		typeof args === "object" &&
-		args !== null &&
-		typeof (args as { file?: unknown }).file === "string" &&
-		!("path" in args) &&
-		!("file_path" in args) &&
-		!("edits" in args)
-	);
-}
-
-function isVimToolDetails(details: unknown): details is VimToolDetails {
-	if (!details || typeof details !== "object" || Array.isArray(details)) {
-		return false;
-	}
-	const cursor = (details as { cursor?: unknown }).cursor;
-	const viewportLines = (details as { viewportLines?: unknown }).viewportLines;
-	return (
-		typeof (details as { file?: unknown }).file === "string" &&
-		typeof cursor === "object" &&
-		cursor !== null &&
-		Array.isArray(viewportLines)
-	);
-}
-
 /** Extended context for edit tool rendering */
 export interface EditRenderContext {
 	/** Edit mode resolved by the caller; lets the renderer dispatch without shape-sniffing */
@@ -332,19 +305,21 @@ const MISSING_APPLY_PATCH_END_ERROR = "The last line of the patch must be '*** E
 
 function normalizeHashlineInputPreviewPath(rawPath: string): string {
 	const trimmed = rawPath.trim();
-	if (trimmed.length < 2) return trimmed;
-	const first = trimmed[0];
-	const last = trimmed[trimmed.length - 1];
+	const hashStart = /#[0-9a-f]{4}$/u.exec(trimmed)?.index;
+	const withoutHash = hashStart === undefined ? trimmed : trimmed.slice(0, hashStart);
+	if (withoutHash.length < 2) return withoutHash;
+	const first = withoutHash[0];
+	const last = withoutHash[withoutHash.length - 1];
 	if ((first === '"' || first === "'") && first === last) {
-		return trimmed.slice(1, -1);
+		return withoutHash.slice(1, -1);
 	}
-	return trimmed;
+	return withoutHash;
 }
 
 function parseHashlineInputPreviewHeader(line: string): string | null {
 	if (!line.startsWith(HL_FILE_PREFIX)) return null;
 	// Mirror hashline/input.ts: strip every leading file marker so canonical
-	// `§ PATH` headers and stray `§§ PATH` / `§§§PATH` runs render clean paths.
+	// `¶ PATH` headers and stray `¶¶ PATH` / `¶¶¶PATH` runs render clean paths.
 	let prefixEnd = 0;
 	while (prefixEnd < line.length && line[prefixEnd] === HL_FILE_PREFIX) prefixEnd++;
 	const body = line.slice(prefixEnd).trim();
@@ -460,16 +435,11 @@ export const editToolRenderer = {
 	mergeCallAndResult: true,
 
 	renderCall(
-		args: EditRenderArgs | VimRenderArgs,
+		args: EditRenderArgs,
 		options: RenderResultOptions & { renderContext?: EditRenderContext },
 		uiTheme: Theme,
 	): Component {
 		const renderContext = options.renderContext;
-		// Dispatch on the explicit editMode when available; fall back to the
-		// shape probe for legacy call sites that don't thread renderContext.
-		if (renderContext?.editMode === "vim" || isVimRenderArgs(args)) {
-			return vimToolRenderer.renderCall(args as VimRenderArgs, options, uiTheme);
-		}
 
 		const editArgs = args as EditRenderArgs;
 		const hashlineInputSummary = getHashlineInputRenderSummary(editArgs, renderContext?.editMode);
@@ -514,14 +484,6 @@ export const editToolRenderer = {
 		uiTheme: Theme,
 		args?: EditRenderArgs,
 	): Component {
-		if (options.renderContext?.editMode === "vim" || isVimToolDetails(result.details)) {
-			return vimToolRenderer.renderResult(
-				result as { content: Array<{ type: string; text?: string }>; details?: VimToolDetails; isError?: boolean },
-				options,
-				uiTheme,
-			);
-		}
-
 		const perFileResults = result.details?.perFileResults;
 		const totalFiles = args?.edits ? countEditFiles(args.edits) : 0;
 		if (perFileResults && (perFileResults.length > 1 || totalFiles > 1)) {

package/src/edit/streaming.ts

@@ -22,8 +22,7 @@ import {
 	containsRecognizableHashlineOperations,
 	END_PATCH_MARKER,
 	type HashlineInputSection,
-	HL_FILE_PREFIX,
-	HL_OP_CHARS,
+	HashlineTokenizer,
 	splitHashlineInputs,
 } from "../hashline";
 import type { Theme } from "../modes/theme/theme";
@@ -78,40 +77,25 @@ export interface EditStreamingStrategy<Args = unknown> {
 const STREAMING_FALLBACK_LINES = 12;
 const STREAMING_FALLBACK_WIDTH = 80;
 
-function isHashlineHeaderLine(line: string): boolean {
-	return line.trimEnd().startsWith(HL_FILE_PREFIX);
-}
-
-function parseHashlineHeaderPath(line: string): string {
-	const trimmed = line.trimEnd();
-	let prefixEnd = 0;
-	while (prefixEnd < trimmed.length && trimmed[prefixEnd] === HL_FILE_PREFIX) prefixEnd++;
-	return trimmed.slice(prefixEnd).trim();
-}
-
-function isHashlineOpLine(line: string): boolean {
-	const first = line[0];
-	return first !== undefined && HL_OP_CHARS.includes(first);
-}
-
-function isHashlineEnvelopeMarkerLine(line: string): boolean {
-	const trimmed = line.trimEnd();
-	return trimmed === BEGIN_PATCH_MARKER || trimmed === END_PATCH_MARKER || trimmed === ABORT_MARKER;
-}
+// Streaming-preview classification reuses one tokenizer instance for the
+// stateless predicates and `tokenize`/`tokenizeAll` helpers; instances are
+// cheap, but keeping a single module-level reference matches the rest of
+// the hashline package.
+const HASHLINE_TOKENIZER = new HashlineTokenizer();
 
 function trimHashlineStreamingSyntax(lines: string[]): string[] {
 	let index = lines.findIndex(line => line.trim().length > 0);
 	if (index === -1) return [];
 
-	if (lines[index].trimEnd() === BEGIN_PATCH_MARKER) {
+	if (HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "envelope-begin") {
 		index++;
 		while (index < lines.length && lines[index].trim().length === 0) index++;
 	}
-	if (index < lines.length && isHashlineHeaderLine(lines[index])) {
+	if (index < lines.length && HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "header") {
 		index++;
 	}
 
-	return lines.slice(index).filter(line => !isHashlineEnvelopeMarkerLine(line));
+	return lines.slice(index).filter(line => !HASHLINE_TOKENIZER.isEnvelopeMarker(line));
 }
 
 function renderHashlineInputFallback(input: string, uiTheme: Theme): string {
@@ -381,32 +365,51 @@ function buildHashlineNaturalOrderPreviews(
 	input: string,
 	defaultPath: string | undefined,
 ): PerFileDiffPreview[] | null {
-	const lines = input.split("\n");
 	const groups = new Map<string, string[]>();
 	let currentPath = defaultPath ?? "";
-	const ensure = (path: string): string[] => {
-		let bucket = groups.get(path);
+	const ensure = (sectionPath: string): string[] => {
+		let bucket = groups.get(sectionPath);
 		if (!bucket) {
 			bucket = [];
-			groups.set(path, bucket);
+			groups.set(sectionPath, bucket);
 		}
 		return bucket;
 	};
-	for (const raw of lines) {
-		if (isHashlineEnvelopeMarkerLine(raw)) continue;
-		if (isHashlineHeaderLine(raw)) {
-			currentPath = parseHashlineHeaderPath(raw);
-			if (currentPath) ensure(currentPath);
-			continue;
+
+	// Per-call instance: the streaming preview re-runs each tick with the
+	// cumulative input, and we need the line counter to start at 1. A
+	// dedicated tokenizer keeps the shared HASHLINE_TOKENIZER above free
+	// for stateless predicate use elsewhere in this module.
+	const streamer = new HashlineTokenizer();
+	for (const token of streamer.tokenizeAll(input)) {
+		switch (token.kind) {
+			case "envelope-begin":
+			case "envelope-end":
+			case "abort":
+			case "op-insert":
+			case "op-replace":
+			case "op-delete":
+				continue;
+			case "header":
+				currentPath = token.path;
+				if (currentPath) ensure(currentPath);
+				continue;
+			case "blank":
+				if (!currentPath) continue;
+				ensure(currentPath).push("+");
+				continue;
+			case "payload":
+				if (!currentPath) continue;
+				ensure(currentPath).push(`+${token.text}`);
+				continue;
 		}
-		if (isHashlineOpLine(raw) || !currentPath) continue;
-		ensure(currentPath).push(`+${raw}`);
 	}
+
 	if (groups.size === 0) return null;
 	const previews: PerFileDiffPreview[] = [];
-	for (const [path, body] of groups) {
+	for (const [sectionPath, body] of groups) {
 		if (body.length === 0) continue;
-		previews.push({ path, diff: body.join("\n") });
+		previews.push({ path: sectionPath, diff: body.join("\n") });
 	}
 	return previews.length > 0 ? previews : null;
 }
@@ -431,7 +434,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			sections = splitHashlineInputs(input, { cwd: ctx.cwd, path: args.path });
 		} catch {
 			// Single-section fallback keeps the original error rendering for the
-			// "haven't typed `§ PATH` yet" case.
+			// "haven't typed `¶ PATH` yet" case.
 			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
 			});
@@ -524,27 +527,11 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 		return "";
 	},
 };
-
-// Vim streaming preview is handled by the existing vimToolRenderer inside
-// edit/renderer.ts. The strategy here is a no-op so the registry is total.
-const vimStrategy: EditStreamingStrategy<unknown> = {
-	extractCompleteEdits(args) {
-		return args;
-	},
-	async computeDiffPreview() {
-		return null;
-	},
-	renderStreamingFallback() {
-		return "";
-	},
-};
-
 export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>> = {
 	replace: replaceStrategy as EditStreamingStrategy<unknown>,
 	patch: patchStrategy as EditStreamingStrategy<unknown>,
 	hashline: hashlineStrategy as EditStreamingStrategy<unknown>,
 	apply_patch: applyPatchStrategy as EditStreamingStrategy<unknown>,
-	vim: vimStrategy,
 };
 
 export { resolveEditMode };