@gajae-code/coding-agent 0.18.0 → 0.18.5

package/src/hashline/execute.ts

@@ -11,12 +11,12 @@ import { assertEditableFileContent } from "../tools/auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "../tools/fs-cache-invalidation";
 import { outputMeta } from "../tools/output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "../tools/plan-mode-guard";
-import { HashlineMismatchError } from "./anchors";
+import { formatFullAnchorRequirement, HashlineMismatchError } from "./anchors";
 import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
 import { buildCompactHashlineDiffPreview } from "./diff-preview";
 import { computeLineHash, HL_BODY_SEP } from "./hash";
 import { type HashlineInputSection, splitHashlineInputs } from "./input";
-import { HashlineMissingHashError, parseHashlineWithWarnings } from "./parser";
+import { HashlineMissingHashError, HashlineMissingLineError, parseHashlineWithWarnings } from "./parser";
 import { tryRecoverHashlineWithCache } from "./recovery";
 import type {
 	ExecuteHashlineSingleOptions,
@@ -88,6 +88,17 @@ function formatMissingHashAnchors(fileLines: string[], start: number, end: numbe
 	return [...head, "...", format(end)];
 }
 
+function formatMissingHashRetryHeader(
+	fileLines: string[],
+	start: number,
+	end: number,
+	opSigil: HashlineMissingHashError["opSigil"],
+): string {
+	const format = (line: number): string => `${line}${computeLineHash(line, fileLines[line - 1] ?? "")}`;
+	const anchorRange = start === end ? format(start) : `${format(start)}..${format(end)}`;
+	return `${opSigil}${anchorRange}`;
+}
+
 /**
  * Parse an edit section. When an op names lines by number only, answer with
  * the current full anchors for those lines so the model can retry without
@@ -101,7 +112,43 @@ async function parseHashlineSection(
 	try {
 		return parseHashlineWithWarnings(diff);
 	} catch (err) {
+		if (err instanceof HashlineMissingLineError) {
+			// When part of a range has a missing hash, suppress the "Did you mean" suggestion
+			// and require the full range to be re-supplied.
+			if (err.rangeRaw) {
+				throw new Error(
+					`Anchor "${err.hash}" lacks its line number. The range ${err.rangeRaw.start}..${err.rangeRaw.end} is incomplete. ` +
+						`Expected ${formatFullAnchorRequirement(err.hash)} Re-read the target to get the full range. ` +
+						`The edit was NOT applied.`,
+				);
+			}
+			const source = await readHashlineFile(absolutePath, pathText);
+			const fileLines = source.exists ? normalizeToLF(stripBom(source.rawContent).text).split("\n") : [];
+			let matchCount = 0;
+			let matchLine: number | undefined;
+			for (let index = 0; index < fileLines.length; index++) {
+				if (computeLineHash(index + 1, fileLines[index] ?? "") !== err.hash) continue;
+				matchCount++;
+				matchLine = index + 1;
+			}
+			if (matchCount === 1 && matchLine !== undefined) {
+				const suggestion = new HashlineMissingLineError(err.hash, matchLine, err.opSigil);
+				throw new Error(`${suggestion.message} The edit was NOT applied.`);
+			}
+			throw new Error(
+				`${err.message} Expected ${formatFullAnchorRequirement(err.hash)} ` +
+					`The hash matches ${matchCount} lines; re-read the target. The edit was NOT applied.`,
+			);
+		}
 		if (!(err instanceof HashlineMissingHashError)) throw err;
+		// When part of a range has a missing hash, suppress the copy-ready suggestion
+		// and require re-reading to get the full range.
+		if (err.rangeRaw) {
+			throw new Error(
+				`${err.message} The anchors are missing from the range ${err.rangeRaw.start}..${err.rangeRaw.end}. ` +
+					`Re-read the target to get the full range with hashes. The edit was NOT applied.`,
+			);
+		}
 		const source = await readHashlineFile(absolutePath, pathText);
 		if (!source.exists) throw err;
 		const fileLines = normalizeToLF(stripBom(source.rawContent).text).split("\n");
@@ -112,8 +159,9 @@ async function parseHashlineSection(
 			);
 		}
 		const anchors = formatMissingHashAnchors(fileLines, start, end);
+		const retryHeader = formatMissingHashRetryHeader(fileLines, start, end, err.opSigil);
 		throw new Error(
-			`${err.message}\nThe edit was NOT applied. Current anchors for ${pathText}:\n${anchors.join("\n")}`,
+			`${err.message}\nUse ${retryHeader}\nThe edit was NOT applied. Current anchors for ${pathText}:\n${anchors.join("\n")}`,
 		);
 	}
 }

package/src/hashline/parser.ts

@@ -20,35 +20,59 @@ import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
 const LID_CAPTURE_RE = new RegExp(`^\\s*[>+\\-*]*\\s*${HL_HASH_CAPTURE_RE_RAW}(?:\\|.*)?\\s*$`);
 const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
-const BARE_LINE_REF_RE = /^\s*[>+\-*]*\s*([1-9]\d*)(?:\s*(?:-|\.\.)\s*([1-9]\d*))?\s*$/;
+// Dots in copied text are literal unless followed by a possible range endpoint.
+// Ambiguous copied ranges still require a re-read instead of a one-line retry.
+const BARE_LINE_REF_RE =
+	/^\s*[>+\-*]*\s*([1-9]\d*)(?:\s*(?:-|\.\.)\s*([1-9]\d*))?(?:\|(?:(?!\.\.\s*[>+\-*]*\s*(?:[1-9]\d*|[a-z]{2}(?:\||\s*$))).)*)?\s*$/;
+const HASH_ONLY_REF_RE = /^\s*[>+\-*]*\s*([a-z]{2})(?:\|.*)?\s*$/;
+type HashlineOpSigil = typeof HL_OP_INSERT_BEFORE | typeof HL_OP_INSERT_AFTER | typeof HL_OP_REPLACE;
 
 /**
- * An op referenced lines by number alone, without the content hash. The edit
- * is never applied on a line number alone; the executor answers with the
- * current full anchors for {@link lines} so the model can retry without an
- * extra read.
+ * An op referenced lines by number alone. The edit is never applied on a line
+ * number alone; the executor answers with the current full anchors so the model
+ * can retry without another read.
  */
 export class HashlineMissingHashError extends Error {
 	constructor(
 		message: string,
 		readonly lines: { start: number; end: number },
+		readonly opSigil: HashlineOpSigil,
+		readonly rangeRaw?: { start: string; end: string },
 	) {
 		super(message);
 		this.name = "HashlineMissingHashError";
 	}
 }
 
-function parseLid(raw: string, lineNum: number): Anchor {
+export class HashlineMissingLineError extends Error {
+	constructor(
+		readonly hash: string,
+		readonly lineNum: number | undefined,
+		readonly opSigil: HashlineOpSigil,
+		readonly rangeRaw?: { start: string; end: string },
+	) {
+		super(
+			lineNum === undefined
+				? `Anchor "${hash}" lacks its line number.`
+				: `Anchor "${hash}" lacks its line number. Did you mean ${opSigil}${lineNum}${hash}?`,
+		);
+		this.name = "HashlineMissingLineError";
+	}
+}
+
+function parseLid(raw: string, lineNum: number, opSigil: HashlineOpSigil): Anchor {
 	const match = LID_CAPTURE_RE.exec(raw);
 	if (!match) {
+		const hashOnly = HASH_ONLY_REF_RE.exec(raw);
+		if (hashOnly) throw new HashlineMissingLineError(hashOnly[1], undefined, opSigil);
 		const bare = BARE_LINE_REF_RE.exec(raw);
 		if (bare) {
 			const start = Number.parseInt(bare[1], 10);
 			const end = bare[2] === undefined ? start : Number.parseInt(bare[2], 10);
 			throw new HashlineMissingHashError(
-				`line ${lineNum}: anchor ${JSON.stringify(raw.trim())} is missing its hash; ` +
-					`use the full anchor such as ${describeAnchorExamples(String(start))}.`,
+				`line ${lineNum}: anchor ${JSON.stringify(raw.trim())} is missing its hash.`,
 				{ start: Math.min(start, end), end: Math.max(start, end) },
+				opSigil,
 			);
 		}
 		throw new Error(
@@ -64,12 +88,12 @@ interface ParsedRange {
 	end: Anchor;
 }
 
-function parseRange(raw: string, lineNum: number): ParsedRange {
+function parseRange(raw: string, lineNum: number, opSigil: HashlineOpSigil): ParsedRange {
 	// Reject an all-numeric range (`16..18`, `16-18`) as a whole so the error
 	// carries the full span rather than just its first endpoint.
-	if (BARE_LINE_REF_RE.test(raw)) parseLid(raw, lineNum);
+	if (BARE_LINE_REF_RE.test(raw)) parseLid(raw, lineNum, opSigil);
 	if (!raw.includes("..")) {
-		const start = parseLid(raw, lineNum);
+		const start = parseLid(raw, lineNum, opSigil);
 		return { start, end: { ...start } };
 	}
 	const [startRaw, endRaw, extra] = raw.split("..");
@@ -79,8 +103,30 @@ function parseRange(raw: string, lineNum: number): ParsedRange {
 				`For a one-line edit, repeat the same anchor on both sides.`,
 		);
 	}
-	const start = parseLid(startRaw, lineNum);
-	const end = parseLid(endRaw, lineNum);
+	let start: Anchor;
+	try {
+		start = parseLid(startRaw, lineNum, opSigil);
+	} catch (err) {
+		if (err instanceof HashlineMissingHashError) {
+			throw new HashlineMissingHashError(err.message, err.lines, err.opSigil, { start: startRaw, end: endRaw });
+		}
+		if (err instanceof HashlineMissingLineError) {
+			throw new HashlineMissingLineError(err.hash, err.lineNum, err.opSigil, { start: startRaw, end: endRaw });
+		}
+		throw err;
+	}
+	let end: Anchor;
+	try {
+		end = parseLid(endRaw, lineNum, opSigil);
+	} catch (err) {
+		if (err instanceof HashlineMissingHashError) {
+			throw new HashlineMissingHashError(err.message, err.lines, err.opSigil, { start: startRaw, end: endRaw });
+		}
+		if (err instanceof HashlineMissingLineError) {
+			throw new HashlineMissingLineError(err.hash, err.lineNum, err.opSigil, { start: startRaw, end: endRaw });
+		}
+		throw err;
+	}
 	if (end.line < start.line) {
 		throw new Error(`line ${lineNum}: range ${startRaw}..${endRaw} ends before it starts.`);
 	}
@@ -104,7 +150,8 @@ function parseInsertTarget(raw: string, lineNum: number, kind: "before" | "after
 	if (raw === "BOF") return { kind: "bof" };
 	if (raw === "EOF") return { kind: "eof" };
 	const cursorKind = kind === "before" ? "before_anchor" : "after_anchor";
-	return { kind: cursorKind, anchor: parseLid(raw, lineNum) };
+	const opSigil = kind === "before" ? HL_OP_INSERT_BEFORE : HL_OP_INSERT_AFTER;
+	return { kind: cursorKind, anchor: parseLid(raw, lineNum, opSigil) };
 }
 
 /**
@@ -137,7 +184,7 @@ const INSERT_BEFORE_OP_RE = new RegExp(
 const INSERT_AFTER_OP_RE = new RegExp(
 	`^${regexEscape(HL_OP_INSERT_AFTER)}\\s*([^|\\s]+)(?:${HL_BODY_SEP_RE_RAW}(.*))?\\s*$`,
 );
-const REPLACE_OP_RE = new RegExp(`^${regexEscape(HL_OP_REPLACE)}\\s*([^\\s+<\\-=]\\S*)\\s*$`);
+const REPLACE_OP_RE = new RegExp(`^${regexEscape(HL_OP_REPLACE)}\\s*([^\\s+<\\-=]\\S*(?:\\|.*)?)\\s*$`);
 
 function isEnvelopeOrAbortMarkerLine(line: string): boolean {
 	const trimmed = line.trimEnd();
@@ -240,7 +287,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 
 		const replaceMatch = REPLACE_OP_RE.exec(line);
 		if (replaceMatch) {
-			const range = parseRange(replaceMatch[1], lineNum);
+			const range = parseRange(replaceMatch[1], lineNum, HL_OP_REPLACE);
 			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
 			if (payload.length > 0) {
 				for (const text of payload) {