@gajae-code/coding-agent 0.18.7 → 0.18.9

package/src/hashline/parser.ts

@@ -2,6 +2,7 @@ import { ABORT_MARKER, ABORT_WARNING, BEGIN_PATCH_MARKER, END_PATCH_MARKER, RANG
 import {
 	computeLineHash,
 	describeAnchorExamples,
+	HL_BODY_SEP,
 	HL_BODY_SEP_RE_RAW,
 	HL_FILE_PREFIX,
 	HL_HASH_CAPTURE_RE_RAW,
@@ -206,11 +207,43 @@ export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 	return cursor;
 }
 
+/** Context for diagnosing an insert op that ended up with no payload lines. */
+interface EmptyInsertContext {
+	/** The op token as written, without any `|TEXT` body (e.g. `»300rk`). */
+	op: string;
+	/** True when the op line carried `|TEXT` that only echoed the anchored line. */
+	echoedAnchorText: boolean;
+}
+
+function formatEmptyInsertError(opLineNum: number, context: EmptyInsertContext): string {
+	const base = `line ${opLineNum}: ${HL_OP_INSERT_BEFORE} and ${HL_OP_INSERT_AFTER} operations require at least one verbatim payload line.`;
+	if (context.echoedAnchorText) {
+		return (
+			`${base} The text after "${HL_BODY_SEP}" on "${context.op}${HL_BODY_SEP}…" matches the supplied anchor hash, ` +
+			`so it was read as an anchor echo, not as new content. Put the lines to insert on the lines after "${context.op}".`
+		);
+	}
+	return (
+		`${base} To insert a single blank line, put one empty line after "${context.op}" ` +
+		`(when it is the last op, the edit input ends with two newlines).`
+	);
+}
+
+/** Payload is required only when the op line carried no usable inline `|TEXT` body. */
+function emptyInsertContext(
+	sigil: string,
+	match: RegExpExecArray,
+	inlineBody: string | undefined,
+): EmptyInsertContext | undefined {
+	if (inlineBody !== undefined) return undefined;
+	return { op: `${sigil}${match[1]}`, echoedAnchorText: match[2] !== undefined };
+}
+
 function collectPayload(
 	lines: string[],
 	startIndex: number,
 	opLineNum: number,
-	requirePayload: boolean,
+	emptyInsert: EmptyInsertContext | undefined,
 ): { payload: string[]; nextIndex: number } {
 	const payload: string[] = [];
 	let index = startIndex;
@@ -220,11 +253,7 @@ function collectPayload(
 		payload.push(line);
 		index++;
 	}
-	if (payload.length === 0 && requirePayload) {
-		throw new Error(
-			`line ${opLineNum}: ${HL_OP_INSERT_BEFORE} and ${HL_OP_INSERT_AFTER} operations require at least one verbatim payload line.`,
-		);
-	}
+	if (payload.length === 0 && emptyInsert) throw new Error(formatEmptyInsertError(opLineNum, emptyInsert));
 	return { payload, nextIndex: index };
 }
 
@@ -267,7 +296,12 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		if (insertBeforeMatch) {
 			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
 			const inlineBody = resolveInlineInsertBody(cursor, insertBeforeMatch[2]);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, inlineBody === undefined);
+			const { payload, nextIndex } = collectPayload(
+				lines,
+				i + 1,
+				lineNum,
+				emptyInsertContext(HL_OP_INSERT_BEFORE, insertBeforeMatch, inlineBody),
+			);
 			if (inlineBody !== undefined) pushInsert(cursor, inlineBody, lineNum);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
@@ -278,7 +312,12 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		if (insertAfterMatch) {
 			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
 			const inlineBody = resolveInlineInsertBody(cursor, insertAfterMatch[2]);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, inlineBody === undefined);
+			const { payload, nextIndex } = collectPayload(
+				lines,
+				i + 1,
+				lineNum,
+				emptyInsertContext(HL_OP_INSERT_AFTER, insertAfterMatch, inlineBody),
+			);
 			if (inlineBody !== undefined) pushInsert(cursor, inlineBody, lineNum);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
@@ -288,7 +327,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const replaceMatch = REPLACE_OP_RE.exec(line);
 		if (replaceMatch) {
 			const range = parseRange(replaceMatch[1], lineNum, HL_OP_REPLACE);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, undefined);
 			if (payload.length > 0) {
 				for (const text of payload) {
 					edits.push({

package/src/hashline/recovery.ts

@@ -4,6 +4,7 @@ import type { FileReadCache, FileReadSnapshot } from "../edit/file-read-cache";
 import { getNativeDiffBindings } from "../internal/native-diff";
 import { HashlineMismatchError } from "./anchors";
 import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
+import { RANGE_INTERIOR_HASH } from "./constants";
 import { computeLineHash } from "./hash";
 import type { Anchor, HashlineApplyOptions, HashlineEdit } from "./types";
 
@@ -72,15 +73,15 @@ function trimHunkToSnapshot(
  * matches, so a hunk whose old side (context + deleted lines) occurs more than
  * once in the live file could land on the wrong copy. Refuse such replays.
  */
-function everyHunkLandsUniquely(hunks: Diff.StructuredPatchHunk[], currentLines: string[]): boolean {
+function everyHunkLandsUniquely(hunks: Diff.StructuredPatchHunk[], lines: string[]): boolean {
 	for (const hunk of hunks) {
 		const oldSide = hunk.lines.filter(line => line[0] === " " || line[0] === "-").map(line => line.slice(1));
 		if (oldSide.length === 0) return false;
 		let occurrences = 0;
-		for (let start = 0; start + oldSide.length <= currentLines.length; start++) {
+		for (let start = 0; start + oldSide.length <= lines.length; start++) {
 			let matches = true;
 			for (let offset = 0; offset < oldSide.length; offset++) {
-				if (currentLines[start + offset] !== oldSide[offset]) {
+				if (lines[start + offset] !== oldSide[offset]) {
 					matches = false;
 					break;
 				}
@@ -146,10 +147,13 @@ function tryRecoverFromSnapshot(
 	// Precondition: the model's anchors must be vouched-for by the snapshot. If
 	// even one anchored line is missing from it, or its content hashes to a
 	// different value than the model supplied, refuse — any merge from here is
-	// a guess.
+	// a guess. Range interiors carry no model-supplied hash (the endpoints vouch
+	// for the range), so they only need to be present; the replayed hunk still
+	// has to match those snapshot lines exactly in the live file.
 	for (const anchor of anchors) {
 		const cachedLine = snapshot.lines.get(anchor.line);
 		if (cachedLine === undefined) return null;
+		if (anchor.hash === RANGE_INTERIOR_HASH) continue;
 		if (computeLineHash(anchor.line, cachedLine) !== anchor.hash) return null;
 	}
 
@@ -191,6 +195,11 @@ function tryRecoverFromSnapshot(
 		hunks.push(trimmed);
 	}
 	patch.hunks = hunks;
+	// Content is the only location evidence a replayed hunk carries, so it must
+	// identify one site in the authored version too. If the snapshot itself holds
+	// the hunk at more than one place, a single live match may be an unrelated
+	// identical copy left standing after the anchored copy changed out-of-band.
+	if (!everyHunkLandsUniquely(hunks, previousText.split("\n"))) return null;
 	if (!everyHunkLandsUniquely(hunks, currentText.split("\n"))) return null;
 	const merged = Diff.applyPatch(currentText, patch, { fuzzFactor: HASHLINE_RECOVERY_FUZZ_FACTOR });
 	if (typeof merged !== "string" || merged === currentText) return null;