@oh-my-pi/pi-coding-agent 14.1.0 → 14.1.1

package/src/edit/modes/chunk.ts

@@ -8,6 +8,7 @@ import {
 	type ChunkInfo,
 	ChunkReadStatus,
 	type ChunkReadTarget,
+	ChunkRegion,
 	ChunkState,
 	type EditOperation as NativeEditOperation,
 } from "@oh-my-pi/pi-natives";
@@ -30,7 +31,9 @@ import type { EditToolDetails, LspBatchRequest } from "../renderer";
 export type { ChunkReadTarget };
 
 export type ChunkEditOperation =
-	| { op: "replace"; sel?: string; content: string }
+	| { op: "put"; sel?: string; content: string }
+	| { op: "replace"; sel?: string; content: string; find: string }
+	| { op: "delete"; sel?: string }
 	| { op: "before"; sel?: string; content: string }
 	| { op: "after"; sel?: string; content: string }
 	| { op: "prepend"; sel?: string; content: string }
@@ -158,6 +161,10 @@ async function resolveChunkSourceContext(session: ToolSession, path: string): Pr
 	};
 }
 
+function normalizeChunkRegionSyntax(text: string): string {
+	return text.replaceAll("@body", "~").replaceAll("@head", "^");
+}
+
 function buildChunkEditResult(result: {
 	diffBefore: string;
 	diffAfter: string;
@@ -174,7 +181,7 @@ function buildChunkEditResult(result: {
 		changed: result.changed,
 		parseValid: result.parseValid,
 		touchedPaths: result.touchedPaths,
-		warnings: result.warnings,
+		warnings: result.warnings.map(normalizeChunkRegionSyntax),
 	};
 }
 
@@ -192,6 +199,17 @@ export function parseChunkSelector(selector: string | undefined): { selector?: s
 	return { selector };
 }
 
+/** Split a combined `file:selector` path into file path and chunk selector. */
+export function parseChunkEditPath(editPath: string | undefined): { filePath: string; selector?: string } {
+	if (!editPath) return { filePath: "" };
+	const colonIndex = chunkReadPathSeparatorIndex(editPath);
+	if (colonIndex === -1) {
+		return { filePath: editPath };
+	}
+	const sel = editPath.slice(colonIndex + 1) || undefined;
+	return { filePath: editPath.slice(0, colonIndex), selector: sel };
+}
+
 export function parseChunkReadPath(readPath: string): ParsedChunkReadPath {
 	const colonIndex = chunkReadPathSeparatorIndex(readPath);
 	if (colonIndex === -1) {
@@ -252,34 +270,131 @@ export async function formatChunkedRead(params: {
 	return { text: result.text, resolvedPath: filePath, chunk: result.chunk };
 }
 
-export async function formatChunkedGrepLine(params: {
+export type ChunkedGrepMatch = {
+	displayPath: string;
+	fileLineCount: number;
+	chunkPath?: string;
+	chunkChecksum?: string;
+	lineNumber: number;
+	line: string;
+};
+
+export async function describeChunkedGrepMatch(params: {
 	filePath: string;
 	lineNumber: number;
 	line: string;
 	cwd: string;
 	language?: string;
-}): Promise<string> {
+}): Promise<ChunkedGrepMatch> {
 	const { filePath, lineNumber, line, cwd, language } = params;
 	const { state } = await loadChunkStateForFile(filePath, language);
-	return state.formatGrepLine(displayPathForFile(filePath, cwd), lineNumber, line);
+	const chunkPath = state.lineToContainingChunkPath(lineNumber) || undefined;
+	const chunkInfo = chunkPath ? state.chunk(chunkPath) : null;
+	return {
+		displayPath: displayPathForFile(filePath, cwd),
+		fileLineCount: state.lineCount,
+		chunkPath,
+		chunkChecksum: chunkInfo?.checksum,
+		lineNumber,
+		line,
+	};
+}
+
+const CHUNK_CHECKSUM_ALPHABET = "ZPMQVRWSNKTXJBYH";
+type NativeChunkRegion = "head" | "body";
+
+function isChunkChecksumToken(value: string): boolean {
+	return value.length === 4 && Array.from(value).every(ch => CHUNK_CHECKSUM_ALPHABET.includes(ch.toUpperCase()));
+}
+
+function parseChunkEditSelector(selector: string | undefined): {
+	selector?: string;
+	crc?: string;
+	region?: NativeChunkRegion;
+} {
+	if (!selector) {
+		return {};
+	}
+
+	let trimmed = selector.trim();
+	if (trimmed.length === 0) {
+		return {};
+	}
+
+	let region: NativeChunkRegion | undefined;
+	const suffix = trimmed.at(-1);
+	if (suffix === "~" || suffix === "^") {
+		region = suffix === "~" ? "body" : "head";
+		trimmed = trimmed.slice(0, -1).trimEnd();
+	}
+
+	let selectorPart = trimmed;
+	let crc: string | undefined;
+	const hashIndex = selectorPart.lastIndexOf("#");
+	if (hashIndex >= 0) {
+		const suffix = selectorPart.slice(hashIndex + 1).trim();
+		if (isChunkChecksumToken(suffix)) {
+			crc = suffix.toUpperCase();
+			selectorPart = selectorPart.slice(0, hashIndex).trimEnd();
+		}
+	} else if (isChunkChecksumToken(selectorPart)) {
+		crc = selectorPart.toUpperCase();
+		selectorPart = "";
+	}
+
+	return { selector: selectorPart || undefined, crc, region };
 }
 
-function toNativeEditOperation(operation: ChunkEditOperation): NativeEditOperation {
+type NativeChunkRegionEncoding = "named" | "symbolic";
+
+function toNativeEditRegion(
+	region: NativeChunkRegion | undefined,
+	encoding: NativeChunkRegionEncoding,
+): NativeEditOperation["region"] | undefined {
+	if (!region) {
+		return undefined;
+	}
+	if (encoding === "symbolic") {
+		return region === "body" ? ChunkRegion.Body : ChunkRegion.Head;
+	}
+	return region as unknown as NativeEditOperation["region"] | undefined;
+}
+
+function toNativeEditOperation(
+	operation: ChunkEditOperation,
+	defaultRegion: NativeChunkRegion | undefined,
+	encoding: NativeChunkRegionEncoding,
+): NativeEditOperation {
+	const { selector, crc, region } = parseChunkEditSelector(operation.sel);
+	const nativeRegion = toNativeEditRegion(operation.sel === undefined ? (region ?? defaultRegion) : region, encoding);
 	switch (operation.op) {
+		case "put":
+			return {
+				op: ChunkEditOp.Put,
+				sel: selector,
+				crc,
+				region: nativeRegion,
+				content: operation.content,
+			};
 		case "replace":
 			return {
 				op: ChunkEditOp.Replace,
-				sel: operation.sel,
+				sel: selector,
+				crc,
+				region: nativeRegion,
+				find: operation.find,
 				content: operation.content,
 			};
 		case "before":
-			return { op: ChunkEditOp.Before, sel: operation.sel, content: operation.content };
+			return { op: ChunkEditOp.Before, sel: selector, crc, region: nativeRegion, content: operation.content };
 		case "after":
-			return { op: ChunkEditOp.After, sel: operation.sel, content: operation.content };
+			return { op: ChunkEditOp.After, sel: selector, crc, region: nativeRegion, content: operation.content };
 		case "prepend":
-			return { op: ChunkEditOp.Prepend, sel: operation.sel, content: operation.content };
+			return { op: ChunkEditOp.Prepend, sel: selector, crc, region: nativeRegion, content: operation.content };
 		case "append":
-			return { op: ChunkEditOp.Append, sel: operation.sel, content: operation.content };
+			return { op: ChunkEditOp.Append, sel: selector, crc, region: nativeRegion, content: operation.content };
+		case "delete":
+			return { op: ChunkEditOp.Delete, sel: selector, crc, region: nativeRegion };
 		default: {
 			const exhaustive: never = operation;
 			return exhaustive;
@@ -287,6 +402,28 @@ function toNativeEditOperation(operation: ChunkEditOperation): NativeEditOperati
 	}
 }
 
+function buildNativeChunkEditRequest(
+	params: { defaultSelector?: string; defaultCrc?: string; operations: ChunkEditOperation[] },
+	encoding: NativeChunkRegionEncoding,
+): Pick<Parameters<ChunkState["applyEdits"]>[0], "operations" | "defaultSelector" | "defaultCrc"> {
+	const parsedDefaultSelector = parseChunkEditSelector(params.defaultSelector);
+	const operations = params.operations.map(operation =>
+		toNativeEditOperation(operation, parsedDefaultSelector.region, encoding),
+	);
+	return {
+		operations,
+		defaultSelector: parsedDefaultSelector.selector,
+		defaultCrc: params.defaultCrc ?? parsedDefaultSelector.crc,
+	};
+}
+
+function isChunkRegionEncodingError(error: unknown): error is Error {
+	return (
+		error instanceof Error &&
+		/value `"(body|head|~|\^)"` does not match any variant of enum `ChunkRegion`/.test(error.message)
+	);
+}
+
 export function applyChunkEdits(params: {
 	source: string;
 	language?: string;
@@ -298,19 +435,40 @@ export function applyChunkEdits(params: {
 	anchorStyle?: ChunkAnchorStyle;
 }): ChunkEditResult {
 	const normalizedSource = normalizeChunkSource(params.source);
-	const nativeOperations = params.operations.map(toNativeEditOperation);
-	const state = ChunkState.parse(normalizedSource, normalizeLanguage(params.language));
-	const result = state.applyEdits({
-		operations: nativeOperations,
-		normalizeIndent: resolveChunkAutoIndent(),
-		defaultSelector: params.defaultSelector,
-		defaultCrc: params.defaultCrc,
-		anchorStyle: params.anchorStyle,
-		cwd: params.cwd,
-		filePath: params.filePath,
-	});
+	const applyNativeEdits = (encoding: NativeChunkRegionEncoding): ChunkEditResult => {
+		const request = buildNativeChunkEditRequest(params, encoding);
+		const state = ChunkState.parse(normalizedSource, normalizeLanguage(params.language));
+		return buildChunkEditResult(
+			state.applyEdits({
+				operations: request.operations,
+				normalizeIndent: resolveChunkAutoIndent(),
+				defaultSelector: request.defaultSelector,
+				defaultCrc: request.defaultCrc,
+				anchorStyle: params.anchorStyle,
+				cwd: params.cwd,
+				filePath: params.filePath,
+			}),
+		);
+	};
 
-	return buildChunkEditResult(result);
+	try {
+		return applyNativeEdits("named");
+	} catch (error) {
+		if (isChunkRegionEncodingError(error)) {
+			try {
+				return applyNativeEdits("symbolic");
+			} catch (fallbackError) {
+				if (fallbackError instanceof Error) {
+					throw new Error(normalizeChunkRegionSyntax(fallbackError.message));
+				}
+				throw fallbackError;
+			}
+		}
+		if (error instanceof Error) {
+			throw new Error(normalizeChunkRegionSyntax(error.message));
+		}
+		throw error;
+	}
 }
 
 export async function getChunkInfoForFile(
@@ -326,22 +484,39 @@ export function missingChunkReadTarget(selector: string): ChunkReadTarget {
 	return { status: ChunkReadStatus.NotFound, selector };
 }
 
-const CHUNK_OP_VALUES = ["replace", "after", "before", "prepend", "append"] as const;
-
-export const chunkToolEditSchema = Type.Object({
-	op: StringEnum(CHUNK_OP_VALUES),
-	sel: Type.String({
-		description:
-			"Chunk selector. Use 'path~' or 'path^' for insertions, 'path#CRC~' or 'path#CRC^' for replace, or omit the suffix to target the full chunk.",
-	}),
-	content: Type.String({
-		description:
-			"New content. Write indentation relative to the targeted region as described in the tool prompt. Do NOT include the chunk's base padding.",
-	}),
-});
+export const chunkToolEditSchema = Type.Object(
+	{
+		path: Type.String({
+			description: "File path with chunk selector. Examples: 'src/app.ts:fn_foo#ABCD~', 'src/app.ts:class_Bar'.",
+		}),
+		write: Type.Optional(
+			Type.Union([Type.String(), Type.Null()], {
+				description: "Write complete new content to the targeted region. Use null to delete the chunk.",
+			}),
+		),
+		replace: Type.Optional(
+			Type.Object(
+				{
+					old: Type.String({ description: "Literal substring to find. Must match exactly once." }),
+					new: Type.String({ description: "Replacement text." }),
+				},
+				{ description: "Find and replace a substring within the chunk." },
+			),
+		),
+		insert: Type.Optional(
+			Type.Object(
+				{
+					loc: StringEnum(["append", "prepend"] as const),
+					body: Type.String({ description: "Content to insert." }),
+				},
+				{ description: "Insert content relative to the chunk." },
+			),
+		),
+	},
+	{ additionalProperties: false },
+);
 export const chunkEditParamsSchema = Type.Object(
 	{
-		path: Type.String({ description: "File path" }),
 		edits: Type.Array(chunkToolEditSchema, {
 			description: "Chunk edits",
 			minItems: 1,
@@ -353,9 +528,10 @@ export const chunkEditParamsSchema = Type.Object(
 export type ChunkToolEdit = Static<typeof chunkToolEditSchema>;
 export type ChunkParams = Static<typeof chunkEditParamsSchema>;
 
-interface ExecuteChunkModeOptions {
+export interface ExecuteChunkSingleOptions {
 	session: ToolSession;
-	params: ChunkParams;
+	path: string;
+	edits: ChunkToolEdit[];
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	writethrough: WritethroughCallback;
@@ -363,20 +539,122 @@ interface ExecuteChunkModeOptions {
 }
 
 export function isChunkParams(params: unknown): params is ChunkParams {
-	return (
-		typeof params === "object" &&
-		params !== null &&
-		"edits" in params &&
-		Array.isArray(params.edits) &&
-		params.edits.length > 0 &&
-		typeof params.edits[0] === "object" &&
-		params.edits[0] !== null &&
-		"sel" in params.edits[0]
-	);
+	if (
+		typeof params !== "object" ||
+		params === null ||
+		!("edits" in params) ||
+		!Array.isArray(params.edits) ||
+		params.edits.length === 0
+	) {
+		return false;
+	}
+	const first = params.edits[0];
+	if (typeof first !== "object" || first === null || !("path" in first)) return false;
+	return "write" in first || "replace" in first || "insert" in first;
+}
+
+/** Auto-correct indentation for content targeting a body region (`~`) when autoIndent is on.
+ *  Handles two patterns:
+ *  1. Tab-based over-indentation: models include the function's base \t indent.
+ *  2. Space-based indentation: models use literal spaces instead of \t.
+ *  Returns the corrected content and any warnings. */
+function autoCorrectBodyIndent(content: string, index: number): { content: string; warnings: string[] } {
+	const warnings: string[] = [];
+	if (!content || !resolveChunkAutoIndent()) return { content, warnings };
+	const lines = content.split("\n");
+	const nonEmpty = lines.filter(l => l.length > 0);
+	if (nonEmpty.length <= 1) return { content, warnings };
+
+	// 1. Tab-based over-indentation: strip common leading tabs.
+	const minTabs = Math.min(...nonEmpty.map(l => l.match(/^\t*/)?.[0].length ?? 0));
+	if (minTabs >= 1) {
+		const fixed = lines.map(l => (l.length === 0 ? l : l.slice(minTabs))).join("\n");
+		warnings.push(
+			`Edit ${index + 1}: auto-corrected body indentation \u2014 stripped ${minTabs} leading tab(s). When writing to \`~\`, write at column 0; the tool adds the function's base indent.`,
+		);
+		return { content: fixed, warnings };
+	}
+
+	// 2. Space-based indentation: strip common leading spaces and convert to tabs.
+	const spaceIndents = nonEmpty.map(l => l.match(/^ */)?.[0].length ?? 0);
+	const minSpaces = Math.min(...spaceIndents);
+	if (minSpaces >= 2) {
+		const indentDiffs = spaceIndents.map(s => s - minSpaces).filter(d => d > 0);
+		const indentUnit = indentDiffs.length > 0 ? Math.min(...indentDiffs) : 4;
+		const unit = indentUnit >= 2 && indentUnit <= 8 ? indentUnit : 4;
+		const fixed = lines
+			.map(line => {
+				if (line.length === 0) return line;
+				const stripped = line.slice(minSpaces);
+				const leadingSpaces = stripped.match(/^ */)?.[0].length ?? 0;
+				const tabs = Math.floor(leadingSpaces / unit);
+				const rem = leadingSpaces % unit;
+				return "\t".repeat(tabs) + " ".repeat(rem) + stripped.slice(leadingSpaces);
+			})
+			.join("\n");
+		warnings.push(
+			`Edit ${index + 1}: auto-converted space indentation to tabs \u2014 stripped ${minSpaces} common leading spaces and converted ${unit}-space indent to tabs. When auto-indent is on, use \\t for indentation.`,
+		);
+		return { content: fixed, warnings };
+	}
+
+	return { content, warnings };
 }
 
-function normalizeChunkEditOperations(edits: ChunkToolEdit[]): ChunkEditOperation[] {
-	return edits as ChunkEditOperation[];
+function normalizeChunkEditOperations(edits: ChunkToolEdit[]): {
+	operations: ChunkEditOperation[];
+	warnings: string[];
+} {
+	const warnings: string[] = [];
+	const operations = edits.map((edit, index): ChunkEditOperation => {
+		const { selector } = parseChunkEditPath(edit.path);
+		// When multiple ops are present (model confusion), prefer write (total replacement) as the
+		// safest default, then replace (surgical), then insert (additive), then delete.
+		const hasInsert = edit.insert != null && typeof edit.insert.body === "string" && edit.insert.body.length > 0;
+		const hasReplace =
+			edit.replace != null &&
+			((typeof edit.replace.old === "string" && edit.replace.old.length > 0) ||
+				(typeof edit.replace.new === "string" && edit.replace.new.length > 0));
+		const hasWrite = typeof edit.write === "string" && edit.write.length > 0;
+		const opCount = [hasInsert, hasReplace, hasWrite].filter(Boolean).length;
+		if (opCount > 1) {
+			const chosen = hasWrite ? "write" : hasReplace ? "replace" : "insert";
+			const present = [hasWrite && "write", hasReplace && "replace", hasInsert && "insert"]
+				.filter(Boolean)
+				.join(", ");
+			warnings.push(
+				`Edit ${index + 1}: multiple operation fields set (${present}). Each edit entry must have exactly ONE of write/replace/insert — not multiple. Used "${chosen}", ignored the rest.`,
+			);
+		}
+		if (hasWrite) {
+			let writeContent = edit.write!;
+			if (selector?.endsWith("~")) {
+				const corrected = autoCorrectBodyIndent(writeContent, index);
+				writeContent = corrected.content;
+				warnings.push(...corrected.warnings);
+			}
+			return { op: "put", sel: selector, content: writeContent };
+		}
+		if (typeof edit.write === "string" && !hasInsert && !hasReplace) {
+			return { op: "put", sel: selector, content: edit.write };
+		}
+		if (hasReplace) {
+			return { op: "replace", sel: selector, content: edit.replace!.new, find: edit.replace!.old };
+		}
+		if (hasInsert) {
+			const op = edit.insert!.loc === "prepend" ? "before" : "after";
+			let insertContent = edit.insert!.body;
+			if (selector?.endsWith("~")) {
+				const corrected = autoCorrectBodyIndent(insertContent, index);
+				insertContent = corrected.content;
+				warnings.push(...corrected.warnings);
+			}
+			return { op, sel: selector, content: insertContent };
+		}
+		// write: null or no op specified → delete
+		return { op: "delete", sel: selector };
+	});
+	return { operations, warnings };
 }
 
 async function writeChunkResult(params: {
@@ -428,11 +706,10 @@ async function writeChunkResult(params: {
 	};
 }
 
-export async function executeChunkMode(
-	options: ExecuteChunkModeOptions,
+export async function executeChunkSingle(
+	options: ExecuteChunkSingleOptions,
 ): Promise<AgentToolResult<EditToolDetails, typeof chunkEditParamsSchema>> {
-	const { session, params, signal, batchRequest, writethrough, beginDeferredDiagnosticsForPath } = options;
-	const { path, edits } = params;
+	const { session, path, edits, signal, batchRequest, writethrough, beginDeferredDiagnosticsForPath } = options;
 	const { resolvedPath, sourceFile, sourceExists, rawContent, chunkLanguage } = await resolveChunkSourceContext(
 		session,
 		path,
@@ -441,7 +718,7 @@ export async function executeChunkMode(
 	if (parentDir && parentDir !== ".") {
 		await fs.mkdir(parentDir, { recursive: true });
 	}
-	const normalizedOperations = normalizeChunkEditOperations(edits);
+	const { operations: normalizedOperations, warnings: normWarnings } = normalizeChunkEditOperations(edits);
 
 	if (!sourceExists && normalizedOperations.some(op => op.sel)) {
 		throw new Error(
@@ -457,10 +734,12 @@ export async function executeChunkMode(
 		operations: normalizedOperations,
 		anchorStyle: resolveAnchorStyle(session.settings),
 	});
+	chunkResult.warnings.push(...normWarnings);
 
 	if (!chunkResult.changed) {
+		const warningsBlock = chunkResult.warnings.length > 0 ? `\n\nWarnings:\n${chunkResult.warnings.join("\n")}` : "";
 		return {
-			content: [{ type: "text", text: "[No changes needed \u2014 content already matches.]" }],
+			content: [{ type: "text", text: `[No changes needed — content already matches.]${warningsBlock}` }],
 			details: {
 				diff: "",
 				op: sourceExists ? "update" : "create",

package/src/edit/modes/hashline.ts

@@ -128,18 +128,18 @@ const locSchema = Type.Union(
 
 export const hashlineEditSchema = Type.Object(
 	{
-		loc: locSchema,
-		content: linesSchema,
+		path: Type.String({ description: "File path" }),
+		loc: Type.Optional(locSchema),
+		content: Type.Optional(linesSchema),
+		delete: Type.Optional(Type.Boolean({ description: "Delete the file" })),
+		move: Type.Optional(Type.String({ description: "Move/rename the file to this path" })),
 	},
 	{ additionalProperties: false },
 );
 
 export const hashlineEditParamsSchema = Type.Object(
 	{
-		path: Type.String({ description: "path" }),
-		edits: Type.Array(hashlineEditSchema, { description: "edits over $path" }),
-		delete: Type.Optional(Type.Boolean({ description: "If true, delete $path" })),
-		move: Type.Optional(Type.String({ description: "If set, move $path to $move" })),
+		edits: Type.Array(hashlineEditSchema, { description: "edits" }),
 	},
 	{ additionalProperties: false },
 );
@@ -147,9 +147,10 @@ export const hashlineEditParamsSchema = Type.Object(
 export type HashlineToolEdit = Static<typeof hashlineEditSchema>;
 export type HashlineParams = Static<typeof hashlineEditParamsSchema>;
 
-interface ExecuteHashlineModeOptions {
+export interface ExecuteHashlineSingleOptions {
 	session: ToolSession;
-	params: HashlineParams;
+	path: string;
+	edits: HashlineToolEdit[];
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	writethrough: WritethroughCallback;
@@ -166,20 +167,38 @@ export function hashlineParseText(edit: string[] | string | null | undefined): s
 }
 
 export function isHashlineParams(params: unknown): params is HashlineParams {
-	return (
-		typeof params === "object" &&
-		params !== null &&
-		"edits" in params &&
-		Array.isArray(params.edits) &&
-		(params.edits.length === 0 ||
-			(typeof params.edits[0] === "object" && params.edits[0] !== null && "loc" in params.edits[0]))
-	);
+	if (typeof params !== "object" || params === null || !("edits" in params) || !Array.isArray(params.edits))
+		return false;
+	if (params.edits.length === 0) return true;
+	const first = params.edits[0];
+	if (typeof first !== "object" || first === null) return false;
+	return "loc" in first || "delete" in first || "move" in first;
 }
 
 function resolveEditAnchors(edits: HashlineToolEdit[]): HashlineEdit[] {
 	return edits.map(resolveEditAnchor);
 }
 
+type HashlineEditInput = HashlineToolEdit | HashlineEdit;
+
+function resolveHashlineEditsForDiff(edits: HashlineEditInput[]): HashlineEdit[] {
+	return edits.map((edit, editIndex) => {
+		if (!edit || typeof edit !== "object") {
+			throw new Error(`Invalid hashline edit at index ${editIndex}: expected object.`);
+		}
+
+		if ("op" in edit) {
+			return edit;
+		}
+
+		if ("loc" in edit) {
+			return resolveEditAnchor(edit);
+		}
+
+		throw new Error(`Invalid hashline edit at index ${editIndex}: expected op/loc payload.`);
+	});
+}
+
 function tryParseTag(raw: string): Anchor | undefined {
 	try {
 		return parseTag(raw);
@@ -1126,7 +1145,7 @@ export function buildCompactHashlineDiffPreview(
 }
 
 export async function computeHashlineDiff(
-	input: { path: string; edits: HashlineEdit[]; move?: string },
+	input: { path: string; edits: HashlineEditInput[]; move?: string },
 	cwd: string,
 ): Promise<
 	| {
@@ -1143,6 +1162,7 @@ export async function computeHashlineDiff(
 	const isMoveOnly = Boolean(movePath) && movePath !== absolutePath && edits.length === 0;
 
 	try {
+		const resolvedEdits = resolveHashlineEditsForDiff(edits);
 		const file = Bun.file(absolutePath);
 
 		if (movePath === absolutePath) {
@@ -1156,7 +1176,7 @@ export async function computeHashlineDiff(
 
 		const { text: content } = stripBom(rawContent);
 		const normalizedContent = normalizeToLF(content);
-		const result = applyHashlineEdits(normalizedContent, edits);
+		const result = applyHashlineEdits(normalizedContent, resolvedEdits);
 		if (normalizedContent === result.lines && !move) {
 			return { error: `No changes would be made to ${path}. The edits produce identical content.` };
 		}
@@ -1179,15 +1199,20 @@ async function readHashlineFileText(file: BunFile, path: string): Promise<string
 	}
 }
 
-export async function executeHashlineMode(
-	options: ExecuteHashlineModeOptions,
+export async function executeHashlineSingle(
+	options: ExecuteHashlineSingleOptions,
 ): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
-	const { session, params, signal, batchRequest, writethrough, beginDeferredDiagnosticsForPath } = options;
-	const { path, edits, delete: deleteFile, move } = params;
+	const { session, path, edits, signal, batchRequest, writethrough, beginDeferredDiagnosticsForPath } = options;
+
+	// Extract file-level ops from edits
+	const deleteFile = edits.some(e => e.delete);
+	const move = edits.find(e => e.move)?.move;
+	// Filter to content edits only (those with loc)
+	const contentEdits = edits.filter(e => e.loc != null);
 
 	enforcePlanModeWrite(session, path, { op: deleteFile ? "delete" : "update", move });
 
-	if (path.endsWith(".ipynb") && edits?.length > 0) {
+	if (path.endsWith(".ipynb") && contentEdits.length > 0) {
 		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
 	}
 
@@ -1199,7 +1224,7 @@ export async function executeHashlineMode(
 
 	const sourceFile = Bun.file(absolutePath);
 	const sourceExists = await sourceFile.exists();
-	const isMoveOnly = Boolean(resolvedMove) && edits.length === 0;
+	const isMoveOnly = Boolean(resolvedMove) && contentEdits.length === 0;
 
 	if (deleteFile) {
 		if (sourceExists) {
@@ -1239,7 +1264,7 @@ export async function executeHashlineMode(
 
 	if (!sourceExists) {
 		const lines: string[] = [];
-		for (const edit of edits) {
+		for (const edit of contentEdits) {
 			if (edit.loc === "append") {
 				lines.push(...hashlineParseText(edit.content));
 			} else if (edit.loc === "prepend") {
@@ -1261,7 +1286,7 @@ export async function executeHashlineMode(
 		};
 	}
 
-	const anchorEdits = resolveEditAnchors(edits);
+	const anchorEdits = resolveEditAnchors(contentEdits);
 	const rawContent = await sourceFile.text();
 	assertEditableFileContent(rawContent, path);