@oh-my-pi/pi-coding-agent 15.5.1 → 15.5.2

package/src/hashline/executor.ts

@@ -1,5 +1,17 @@
-import { ABORT_WARNING } from "./constants";
-import { HL_OP_CHARS, HL_OP_DELETE, HL_OP_INSERT_AFTER, HL_OP_INSERT_BEFORE, HL_OP_REPLACE } from "./hash";
+import {
+	ABORT_WARNING,
+	IMPLICIT_CONTINUATION_WARNING,
+	PAYLOAD_LINE_PREFIX_DEMOTED_WARNING,
+	REPLACE_PAIR_COALESCED_WARNING,
+} from "./constants";
+import {
+	HL_OP_CHARS,
+	HL_OP_DELETE,
+	HL_OP_INSERT_AFTER,
+	HL_OP_INSERT_BEFORE,
+	HL_OP_REPLACE,
+	HL_PAYLOAD_PREFIX,
+} from "./hash";
 import {
 	cloneCursor,
 	type HashlineToken,
@@ -15,6 +27,14 @@ function validateRangeOrder(range: ParsedRange, lineNum: number): void {
 	}
 }
 
+function rangesEqual(a: ParsedRange, b: ParsedRange): boolean {
+	return a.start.line === b.start.line && a.end.line === b.end.line;
+}
+
+function rangeContains(outer: ParsedRange, inner: ParsedRange): boolean {
+	return outer.start.line <= inner.start.line && inner.end.line <= outer.end.line;
+}
+
 function expandRange(range: ParsedRange): Anchor[] {
 	const anchors: Anchor[] = [];
 	for (let line = range.start.line; line <= range.end.line; line++) {
@@ -83,11 +103,13 @@ export class HashlineExecutor {
 				this.#flushPending();
 				return;
 			case "blank":
-				if (this.#pending) this.#pending.payload.push("");
 				return;
 			case "payload":
 				this.#handlePayload(token.text, token.lineNum);
 				return;
+			case "raw":
+				this.#handleRaw(token.text, token.lineNum);
+				return;
 			case "op-delete":
 				this.#flushPending();
 				if (token.trailingPayload) {
@@ -104,27 +126,55 @@ export class HashlineExecutor {
 				this.#flushPending();
 				this.#pending = {
 					op: { kind: "insert", cursor: token.cursor, lineNum: token.lineNum },
-					payload: [token.inlineBody ?? ""],
+					payload: token.inlineBody === undefined ? [] : [token.inlineBody],
 				};
 				return;
 			case "op-replace":
-				this.#flushPending();
 				validateRangeOrder(token.range, token.lineNum);
+				if (this.#pending !== undefined && this.#pending.op.kind === "replace") {
+					const outer = this.#pending.op.range;
+					const inner = token.range;
+					if (rangesEqual(outer, inner)) {
+						// Identical-range before/after pair. Drop the "before" payload
+						// silently; the second op proceeds as the lone winner. Other
+						// overlap shapes (different ranges, replace+delete, delete+delete)
+						// still hit the post-hoc validator.
+						this.#pending = undefined;
+						if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_WARNING)) {
+							this.#warnings.push(REPLACE_PAIR_COALESCED_WARNING);
+						}
+					} else if (rangeContains(outer, inner)) {
+						// Model wrote a payload line in read-output `LINE:TEXT` format
+						// (or `A-B:TEXT` for a sub-range) inside an outer `A-B:` block.
+						// The tokenizer can't tell payload from op when the anchor and
+						// sigil shape are identical, so demote: append the op's inline
+						// body to the pending payload, strip the `LINE:` prefix, and
+						// keep accumulating. Without this the inner anchors would each
+						// register as their own delete and clash with the outer range.
+						this.#pending.payload.push(token.inlineBody ?? "");
+						if (!this.#warnings.includes(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING)) {
+							this.#warnings.push(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING);
+						}
+						return;
+					}
+				}
+				this.#flushPending();
 				this.#pending = {
 					op: { kind: "replace", range: token.range, lineNum: token.lineNum },
-					payload: [token.inlineBody ?? ""],
+					payload: token.inlineBody === undefined ? [] : [token.inlineBody],
 				};
 				return;
 		}
 	}
 
 	/**
-	 * Flush any open pending op (with its full accumulated payload, blanks
-	 * included) and return the accumulated edits and warnings. The executor
-	 * is single-use; reset() is required for reuse.
-	 * Throws if two replace/delete ops target the same line — that pattern
-	 * means the diff is painting a before/after picture instead of stating
-	 * the final state, and applying both would silently duplicate content.
+	 * Flush any open pending op (with its full accumulated payload, including
+	 * explicit `+` blank lines) and return the accumulated edits and warnings.
+	 * The executor is single-use; reset() is required for reuse.
+	 * Throws if two replace/delete ops target the same line with non-identical
+	 * shapes (different ranges, replace+delete, delete+delete). Identical-range
+	 * `A-B:` pairs in the same hunk are coalesced last-wins by `feed()` with a
+	 * warning, so they never reach the validator.
 	 */
 	end(): { edits: HashlineEdit[]; warnings: string[] } {
 		this.#flushPending();
@@ -145,10 +195,11 @@ export class HashlineExecutor {
 	 * Each `:` / `!` op contributes a delete edit per line in its range; if
 	 * any line ends up targeted by deletes originating from two different
 	 * source ops (distinguished by their `lineNum`), the patch is internally
-	 * inconsistent. Common shape: a "before" `A-B:` followed by an "after"
-	 * `A-B:` over the same range, or an `A-B:` that overlaps a later `N!` /
-	 * `N:`. The applier would run both literally and the file would end up
-	 * with two copies of the line, not a chosen winner.
+	 * inconsistent. Identical-range `A-B:` pairs are already collapsed by
+	 * `feed()`; remaining shapes here are an `A-B:` that overlaps a later
+	 * `N!`/`N:` with a different range, or two `!` deletes on the same line.
+	 * The applier would run both literally and the file would end up with two
+	 * copies of the line, not a chosen winner.
 	 */
 	#validateNoOverlappingDeletes(): void {
 		const sourceLinesByAnchor = new Map<number, number[]>();
@@ -177,10 +228,32 @@ export class HashlineExecutor {
 			return;
 		}
 
-		// Whitespace-only payload outside any pending op is silently dropped;
+		throw new Error(
+			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, ${HL_OP_REPLACE}, or ${HL_OP_DELETE} operation. ` +
+				`Got ${JSON.stringify(`${HL_PAYLOAD_PREFIX}${text}`)}.`,
+		);
+	}
+
+	#handleRaw(text: string, lineNum: number): void {
+		if (this.#pending) {
+			if (text.trim().length === 0) return;
+			// Lenient legacy fallback: the tokenizer routes a line to `raw` only
+			// when it does not parse as an op, header, payload, or envelope
+			// marker. A `raw` token while a pending op exists is therefore an
+			// unambiguous continuation row that the model authored without the
+			// `+` prefix. Accept it as payload and warn so the canonical
+			// `+`-prefixed form remains preferred.
+			this.#pending.payload.push(text);
+			if (!this.#warnings.includes(IMPLICIT_CONTINUATION_WARNING)) {
+				this.#warnings.push(IMPLICIT_CONTINUATION_WARNING);
+			}
+			return;
+		}
+
+		// Whitespace-only raw lines outside any pending op are silently dropped;
 		// fully empty lines arrive as `blank` tokens.
 		if (text.trim().length === 0) return;
-		// Orphan payload outside any pending op: pick the most specific
+		// Orphan raw text outside any pending op: pick the most specific
 		// diagnostic so the model sees the actionable hint.
 		if (isDeleteOpWithPayload(text)) {
 			throw new Error(
@@ -208,7 +281,7 @@ export class HashlineExecutor {
 		if (!pending) return;
 
 		const { op, payload } = pending;
-		const linesToInsert = payload;
+		const linesToInsert = payload.length === 0 ? [""] : payload;
 
 		if (op.kind === "insert") {
 			for (const text of linesToInsert) {

package/src/hashline/grammar.lark

@@ -14,7 +14,7 @@ insert_after: anchor "$HOP_INSERT_AFTER$" inline_body? LF payload*
 replace: range "$HOP_REPLACE$" inline_body? LF payload*
 delete: range "$HOP_DELETE$" LF
 inline_body: /[^\n]+/
-payload: /(.*)/ LF
+payload: "+" /[^\n]*/ LF
 
 anchor: LID | "EOF" | "BOF"
 range: LID ("-" LID)?

package/src/hashline/hash.ts

@@ -7,12 +7,12 @@ const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g,
 
 /**
  * Decoration prefix that may precede a line number in tool output:
- * `>` (context line in grep), `+` (added line in diff), `-` (removed line),
- * `*` (match line). Any combination, in any order, surrounded by optional
+ * `>` (context line in grep), `-` (removed line), `*` (match line).
+ * Any combination, in any order, surrounded by optional
  * whitespace. Output formatters emit at most one decoration per line; the
  * parser stays liberal because it accepts whatever the model echoes back.
  */
-export const HL_ANCHOR_DECORATION_RE_RAW = `\\s*[>+\\-*]*\\s*`;
+export const HL_ANCHOR_DECORATION_RE_RAW = `\\s*[>\\-*]*\\s*`;
 
 /** Capture-group regex source for a decorated bare line-number anchor. */
 export const HL_ANCHOR_RE_RAW = `${HL_ANCHOR_DECORATION_RE_RAW}(\\d+)`;
@@ -74,9 +74,9 @@ export function resolveHashlineGrammarPlaceholders(grammar: string): string {
 /**
  * op lines have an `ANCHOR<SIGIL>[INLINE_PAYLOAD]` shape, where SIGIL is one of
  * {@link HL_OP_INSERT_BEFORE}, {@link HL_OP_INSERT_AFTER}, {@link HL_OP_REPLACE},
- * or {@link HL_OP_DELETE}.
- * Multi-line payloads follow on subsequent lines as verbatim file content with no
- * per-line marker.
+ * or {@link HL_OP_DELETE}. Multi-line payloads follow on subsequent lines
+ * prefixed with {@link HL_PAYLOAD_PREFIX}; that prefix is stripped before the
+ * payload is written.
  *
  * These constants are the single source of truth for the edit parser, grammar,
  * renderer, and prompt.
@@ -86,6 +86,9 @@ export const HL_OP_INSERT_AFTER = "↓";
 export const HL_OP_REPLACE = ":";
 export const HL_OP_DELETE = "!";
 
+/** Prefix for payload continuation lines. The prefix itself is not written. */
+export const HL_PAYLOAD_PREFIX = "+";
+
 /** All hashline edit op sigils, concatenated for fast membership tests. */
 export const HL_OP_CHARS = `${HL_OP_INSERT_BEFORE}${HL_OP_INSERT_AFTER}${HL_OP_REPLACE}${HL_OP_DELETE}`;
 

package/src/hashline/recovery.ts

@@ -29,6 +29,8 @@ const HASHLINE_RECOVERY_EXTERNAL_WARNING =
 	"Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
 const HASHLINE_RECOVERY_SESSION_CHAIN_WARNING =
 	"Recovered from a stale file hash using an earlier in-session snapshot (the file hash advanced after a prior edit in this session).";
+const HASHLINE_RECOVERY_SESSION_REPLAY_WARNING =
+	"Recovered by replaying your edits onto the current file content — your previous edit in this session changed line(s) you re-targeted with a stale hash. Verify the diff matches your intent before continuing.";
 
 function applyEditsToSnapshot(
 	previousText: string,
@@ -62,6 +64,30 @@ function applyEditsToSnapshot(
 	};
 }
 
+function replaySessionChainOnCurrent(
+	previousText: string,
+	currentText: string,
+	edits: HashlineEdit[],
+	options: HashlineApplyOptions,
+): HashlineRecoveryResult | null {
+	// Only safe when no insert/delete shifted line counts in the prior edit
+	// chain: if total line counts match, every line number in `edits` still
+	// resolves to the same logical row.
+	if (previousText.split("\n").length !== currentText.split("\n").length) return null;
+	let applied: HashlineApplyResult;
+	try {
+		applied = applyHashlineEdits(currentText, edits, options);
+	} catch {
+		return null;
+	}
+	if (applied.lines === currentText) return null;
+	return {
+		lines: applied.lines,
+		firstChangedLine: applied.firstChangedLine,
+		warnings: [HASHLINE_RECOVERY_SESSION_REPLAY_WARNING, ...(applied.warnings ?? [])],
+	};
+}
+
 function buildSparseOverlayText(currentText: string, snapshotLines: ReadonlyMap<number, string>): string {
 	const overlaid = currentText.split("\n");
 	let maxCachedLine = 0;
@@ -95,8 +121,16 @@ export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): Hashlin
 	if (!snapshot || snapshot.lines.size === 0) return null;
 
 	const recoveryWarning = resolveRecoveryWarning(head, snapshot);
+	const isSessionChain = !isHeadSnapshot(head, snapshot);
 	if (snapshot.fullText !== undefined) {
-		return applyEditsToSnapshot(snapshot.fullText, currentText, edits, options, recoveryWarning);
+		const merged = applyEditsToSnapshot(snapshot.fullText, currentText, edits, options, recoveryWarning);
+		if (merged !== null) return merged;
+		// Session-chain fast-path: prior in-session edit changed the same line(s)
+		// the model is now re-targeting with the stale hash. When line counts
+		// match, the edits' line numbers still resolve to the right rows — replay
+		// onto the current text directly.
+		if (isSessionChain) return replaySessionChainOnCurrent(snapshot.fullText, currentText, edits, options);
+		return null;
 	}
 
 	const overlayText = buildSparseOverlayText(currentText, snapshot.lines);

package/src/hashline/tokenizer.ts

@@ -7,6 +7,7 @@ import {
 	HL_OP_INSERT_AFTER,
 	HL_OP_INSERT_BEFORE,
 	HL_OP_REPLACE,
+	HL_PAYLOAD_PREFIX,
 } from "./hash";
 import type { Anchor, HashlineCursor } from "./types";
 
@@ -20,6 +21,7 @@ const CHAR_SPACE = 32;
 const CHAR_LOWER_A = 97;
 const CHAR_LOWER_F = 102;
 const CHAR_PILCROW = HL_FILE_PREFIX.charCodeAt(0);
+const CHAR_PAYLOAD_PREFIX = HL_PAYLOAD_PREFIX.charCodeAt(0);
 const FILE_HASH_LENGTH = 4;
 
 function isDigitCode(code: number): boolean {
@@ -31,7 +33,7 @@ function isNonZeroDigitCode(code: number): boolean {
 }
 
 function isDecorationCode(code: number): boolean {
-	return code === 42 || code === 43 || code === 45 || code === 62;
+	return code === 42 || code === 45 || code === 62;
 }
 
 function isHexDigitCode(code: number): boolean {
@@ -91,7 +93,7 @@ export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 }
 
 // Leniently accept anchors copied from read/search output:
-//   - optional leading line-marker decoration (`*`, `>`, `+`, `-`)
+//   - optional leading line-marker decoration (`*`, `>`, `-`)
 //   - the required bare line number
 function skipDecoratedAnchorPrefix(line: string, end = trimEndIndex(line)): number {
 	let index = skipWhitespace(line, 0, end);
@@ -339,7 +341,8 @@ export type HashlineToken =
 	| (TokenBase & { kind: "op-insert"; cursor: HashlineCursor; inlineBody: string | undefined })
 	| (TokenBase & { kind: "op-replace"; range: ParsedRange; inlineBody: string | undefined })
 	| (TokenBase & { kind: "op-delete"; range: ParsedRange; trailingPayload: boolean })
-	| (TokenBase & { kind: "payload"; text: string });
+	| (TokenBase & { kind: "payload"; text: string })
+	| (TokenBase & { kind: "raw"; text: string });
 
 function classifyLine(line: string, lineNum: number): HashlineToken {
 	if (isEmptyLine(line)) return { kind: "blank", lineNum };
@@ -356,6 +359,9 @@ function classifyLine(line: string, lineNum: number): HashlineToken {
 		}
 	}
 
+	if (line.charCodeAt(0) === CHAR_PAYLOAD_PREFIX) {
+		return { kind: "payload", lineNum, text: line.slice(HL_PAYLOAD_PREFIX.length) };
+	}
 	const op = tryParseOp(line);
 	if (op !== null) {
 		if (op.kind === "insert") {
@@ -367,7 +373,7 @@ function classifyLine(line: string, lineNum: number): HashlineToken {
 		return { kind: "op-delete", lineNum, range: op.range, trailingPayload: op.trailingPayload };
 	}
 
-	return { kind: "payload", lineNum, text: line };
+	return { kind: "raw", lineNum, text: line };
 }
 
 /**