@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.2

package/src/hashline/input.ts

@@ -1,15 +1,10 @@
 import * as path from "node:path";
-import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER } from "./constants";
-import { HL_FILE_PREFIX, HL_OP_CHARS } from "./hash";
-import type { SplitHashlineOptions } from "./types";
+import { HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./hash";
+import { HashlineTokenizer } from "./tokenizer";
+import type { HashlineInputSection, SplitHashlineOptions } from "./types";
 
-const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const HASHLINE_OP_LINE_RE = new RegExp(`^[${regexEscape(HL_OP_CHARS)}]`);
-
-export interface HashlineInputSection {
-	path: string;
-	diff: string;
-}
+// Pure classification — single shared tokenizer is safe.
+const TOKENIZER = new HashlineTokenizer();
 
 function unquoteHashlinePath(pathText: string): string {
 	if (pathText.length < 2) return pathText;
@@ -27,27 +22,30 @@ function normalizeHashlinePath(rawPath: string, cwd?: string): string {
 	return isWithinCwd ? relative || "." : unquoted;
 }
 
+/**
+ * Parse a `¶PATH[#hash]` header line. Returns `null` for lines that do not
+ * begin with the `¶` prefix; throws the existing "Input header must be …"
+ * error when a `¶`-prefixed line fails the strict shape (so malformed paths
+ * surface immediately instead of being silently re-classified as payload).
+ */
 function parseHashlineHeaderLine(line: string, cwd?: string): HashlineInputSection | null {
 	const trimmed = line.trimEnd();
 	if (!trimmed.startsWith(HL_FILE_PREFIX)) return null;
-	// Strip a run of leading header markers so canonical `§PATH` and
-	// runaway-prefix forms like `§§PATH` / `§§§PATH` route to the same file.
-	let prefixEnd = 0;
-	while (prefixEnd < trimmed.length && trimmed[prefixEnd] === HL_FILE_PREFIX) prefixEnd++;
-	const rest = trimmed.slice(prefixEnd);
-	if (rest.trim().length === 0) {
-		throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
+
+	const token = TOKENIZER.tokenize(trimmed);
+	if (token.kind !== "header") {
+		throw new Error(
+			`Input header must be ${HL_FILE_PREFIX}PATH or ${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}HASH with a 4-hex file hash; got ${JSON.stringify(trimmed)}.`,
+		);
 	}
-	const parsedPath = normalizeHashlinePath(rest, cwd);
+
+	const parsedPath = normalizeHashlinePath(token.path, cwd);
 	if (parsedPath.length === 0) {
 		throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
 	}
-	return { path: parsedPath, diff: "" };
-}
-
-function isPatchEnvelopeMarker(line: string): boolean {
-	const trimmed = line.trimEnd();
-	return trimmed === BEGIN_PATCH_MARKER || trimmed === END_PATCH_MARKER;
+	return token.fileHash !== undefined
+		? { path: parsedPath, fileHash: token.fileHash, diff: "" }
+		: { path: parsedPath, diff: "" };
 }
 
 function stripLeadingBlankLines(input: string): string {
@@ -55,7 +53,7 @@ function stripLeadingBlankLines(input: string): string {
 	const lines = stripped.split("\n");
 	while (lines.length > 0) {
 		const head = lines[0].replace(/\r$/, "");
-		if (head.trim().length === 0 || head.trimEnd() === BEGIN_PATCH_MARKER) {
+		if (head.trim().length === 0 || TOKENIZER.tokenize(head).kind === "envelope-begin") {
 			lines.shift();
 			continue;
 		}
@@ -66,7 +64,7 @@ function stripLeadingBlankLines(input: string): string {
 
 export function containsRecognizableHashlineOperations(input: string): boolean {
 	for (const line of input.split(/\r?\n/)) {
-		if (HASHLINE_OP_LINE_RE.test(line)) return true;
+		if (TOKENIZER.isOp(line)) return true;
 	}
 	return false;
 }
@@ -84,7 +82,7 @@ function normalizeFallbackInput(input: string, options: SplitHashlineOptions): s
 	return `${HL_FILE_PREFIX}${fallbackPath}\n${input}`;
 }
 
-export function splitHashlineInput(input: string, options: SplitHashlineOptions = {}): { path: string; diff: string } {
+export function splitHashlineInput(input: string, options: SplitHashlineOptions = {}): HashlineInputSection {
 	const [section] = splitHashlineInputs(input, options);
 	return section;
 }
@@ -97,33 +95,42 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 	if (parseHashlineHeaderLine(firstLine, options.cwd) === null) {
 		const preview = JSON.stringify(firstLine.slice(0, 120));
 		throw new Error(
-			`input must begin with "${HL_FILE_PREFIX}PATH" on the first non-blank line; got: ${preview}. ` +
-				`Example: "${HL_FILE_PREFIX}src/foo.ts" then edit ops.`,
+			`input must begin with "${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}HASH" on the first non-blank line for anchored edits; got: ${preview}. ` +
+				`Example: "${HL_FILE_PREFIX}src/foo.ts${HL_FILE_HASH_SEP}1a2b" then edit ops.`,
 		);
 	}
 
 	const sections: HashlineInputSection[] = [];
-	let currentPath = "";
+	let current: HashlineInputSection | undefined;
 	let currentLines: string[] = [];
 
 	const flush = () => {
-		if (currentPath.length === 0) return;
+		if (!current) return;
 		const hasOps = currentLines.some(line => line.trim().length > 0);
-		if (hasOps) sections.push({ path: currentPath, diff: currentLines.join("\n") });
+		if (hasOps) sections.push({ ...current, diff: currentLines.join("\n") });
 		currentLines = [];
 	};
 
 	for (const line of lines) {
-		if (line.trimEnd() === END_PATCH_MARKER || line.trimEnd() === ABORT_MARKER) break;
-		if (isPatchEnvelopeMarker(line)) continue;
-		const header = parseHashlineHeaderLine(line, options.cwd);
-		if (header !== null) {
-			flush();
-			currentPath = header.path;
-			currentLines = [];
-		} else {
-			currentLines.push(line);
+		const trimmed = line.trimEnd();
+		const token = TOKENIZER.tokenize(line);
+		if (token.kind === "envelope-end" || token.kind === "abort") break;
+		if (token.kind === "envelope-begin") continue;
+
+		// Route every `¶`-prefixed line through parseHashlineHeaderLine so
+		// malformed headers still raise the strict "Input header must be …"
+		// diagnostic (the tokenizer alone would silently classify them as
+		// payload).
+		if (trimmed.startsWith(HL_FILE_PREFIX)) {
+			const header = parseHashlineHeaderLine(line, options.cwd);
+			if (header !== null) {
+				flush();
+				current = header;
+				currentLines = [];
+				continue;
+			}
 		}
+		currentLines.push(line);
 	}
 	flush();
 	return sections;

package/src/hashline/prefixes.ts

@@ -1,8 +1,6 @@
-import { HL_BODY_SEP_RE_RAW } from "./hash";
-
-const HL_OUTPUT_PREFIX_SEPARATOR_RE = `[:${HL_BODY_SEP_RE_RAW}]`;
-const HL_PREFIX_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*(?:[+*]\\s*)?\\d+[a-z]{2}${HL_OUTPUT_PREFIX_SEPARATOR_RE}`);
-const HL_PREFIX_PLUS_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*\\+\\s*\\d+[a-z]{2}${HL_OUTPUT_PREFIX_SEPARATOR_RE}`);
+const HL_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:[+*-]\s*)?\d+:/;
+const HL_PREFIX_PLUS_RE = /^\s*(?:>>>|>>)?\s*\+\s*\d+:/;
+const HL_HEADER_RE = /^\s*¶\S+#[0-9a-f]{4}\s*$/;
 const DIFF_PLUS_RE = /^[+](?![+])/;
 const READ_TRUNCATION_NOTICE_RE = /^\[(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bUse :L?\d+/;
 
@@ -20,12 +18,14 @@ function stripLeadingHashlinePrefixes(line: string): string {
 // 5. Read-output prefix stripping
 //
 // When a model echoes back content from a `read` or `search` response, every
-// line is prefixed with either a hashline tag (`123ab|`) or, for diff-style
-// echoes, a leading `+`. These helpers detect that and recover the raw text.
+// line is prefixed with either a hashline-mode line number (`123:`) or, for
+// diff-style echoes, a leading `+`. These helpers detect that and recover the
+// raw text.
 // ───────────────────────────────────────────────────────────────────────────
 
 type LinePrefixStats = {
 	nonEmpty: number;
+	headerCount: number;
 	hashPrefixCount: number;
 	diffPlusHashPrefixCount: number;
 	diffPlusCount: number;
@@ -35,6 +35,7 @@ type LinePrefixStats = {
 function collectLinePrefixStats(lines: string[]): LinePrefixStats {
 	const stats: LinePrefixStats = {
 		nonEmpty: 0,
+		headerCount: 0,
 		hashPrefixCount: 0,
 		diffPlusHashPrefixCount: 0,
 		diffPlusCount: 0,
@@ -47,6 +48,11 @@ function collectLinePrefixStats(lines: string[]): LinePrefixStats {
 			stats.truncationNoticeCount++;
 			continue;
 		}
+		if (HL_HEADER_RE.test(line)) {
+			stats.nonEmpty++;
+			stats.headerCount++;
+			continue;
+		}
 		stats.nonEmpty++;
 		if (HL_PREFIX_RE.test(line)) stats.hashPrefixCount++;
 		if (HL_PREFIX_PLUS_RE.test(line)) stats.diffPlusHashPrefixCount++;
@@ -59,7 +65,8 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
 	const stats = collectLinePrefixStats(lines);
 	if (stats.nonEmpty === 0) return lines;
 
-	const stripHash = stats.hashPrefixCount > 0 && stats.hashPrefixCount === stats.nonEmpty;
+	const contentLineCount = stats.nonEmpty - stats.headerCount;
+	const stripHash = contentLineCount > 0 && stats.hashPrefixCount === contentLineCount;
 	const stripPlus =
 		!stripHash &&
 		stats.diffPlusHashPrefixCount === 0 &&
@@ -69,7 +76,7 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
 	if (!stripHash && !stripPlus && stats.diffPlusHashPrefixCount === 0) return lines;
 
 	return lines
-		.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line))
+		.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line) && !(stripHash && HL_HEADER_RE.test(line)))
 		.map(line => {
 			if (stripHash) return stripLeadingHashlinePrefixes(line);
 			if (stripPlus) return line.replace(DIFF_PLUS_RE, "");
@@ -83,8 +90,11 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
 export function stripHashlinePrefixes(lines: string[]): string[] {
 	const stats = collectLinePrefixStats(lines);
 	if (stats.nonEmpty === 0) return lines;
-	if (stats.hashPrefixCount !== stats.nonEmpty) return lines;
-	return lines.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line)).map(line => stripLeadingHashlinePrefixes(line));
+	const contentLineCount = stats.nonEmpty - stats.headerCount;
+	if (contentLineCount === 0 || stats.hashPrefixCount !== contentLineCount) return lines;
+	return lines
+		.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line) && !HL_HEADER_RE.test(line))
+		.map(line => stripLeadingHashlinePrefixes(line));
 }
 
 /**

package/src/hashline/recovery.ts

@@ -1,15 +1,15 @@
 import * as Diff from "diff";
 import { generateDiffString } from "../edit/diff";
-import type { FileReadCache } from "../edit/file-read-cache";
-import { HashlineMismatchError } from "./anchors";
+import type { FileReadCache, FileReadSnapshot } from "../edit/file-read-cache";
 import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
-import { computeLineHash } from "./hash";
-import type { Anchor, HashlineApplyOptions, HashlineEdit } from "./types";
+import { computeFileHash } from "./hash";
+import type { HashlineApplyOptions, HashlineEdit } from "./types";
 
 export interface HashlineRecoveryArgs {
 	cache: FileReadCache;
 	absolutePath: string;
 	currentText: string;
+	fileHash: string;
 	edits: HashlineEdit[];
 	options: HashlineApplyOptions;
 }
@@ -20,76 +20,28 @@ export interface HashlineRecoveryResult {
 	warnings: string[];
 }
 
-// Anchors are line-precise; never let Diff.applyPatch slide a hunk onto a
-// duplicate closer 100+ lines away. If the snapshot-based replay does not
-// align by exact line number, refuse and let the model re-read.
+// Section hashes are line-precise; never let Diff.applyPatch slide a hunk onto a
+// duplicate closer 100+ lines away. If snapshot replay does not align exactly,
+// refuse and let the model re-read.
 const HASHLINE_RECOVERY_FUZZ_FACTOR = 0;
 
-const HASHLINE_RECOVERY_WARNING =
-	"Recovered from stale anchors using a previous read snapshot (file changed externally between read and edit).";
-
-/** Collect every line anchor an edit batch depends on. */
-function collectEditAnchors(edits: HashlineEdit[]): Anchor[] {
-	const anchors: Anchor[] = [];
-	for (const edit of edits) {
-		if (edit.kind === "delete") {
-			anchors.push(edit.anchor);
-			continue;
-		}
-		const cursor = edit.cursor;
-		if (cursor.kind === "before_anchor" || cursor.kind === "after_anchor") {
-			anchors.push(cursor.anchor);
-		}
-	}
-	return anchors;
-}
-
-/**
- * Attempt to recover from a `HashlineMismatchError` by replaying the edits
- * against a cached pre-edit snapshot of the file and 3-way-merging the result
- * onto the current on-disk content. Returns `null` when no recovery is
- * possible — callers should propagate the original mismatch error in that
- * case.
- *
- * Recovery is gated on a strict precondition: every line the model anchored
- * MUST be present in the cached snapshot AND its content MUST hash to the
- * model-supplied hash. This prevents 3-way merges from silently sliding onto
- * the wrong site when only tangential parts of the file went stale.
- */
-export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null {
-	const { cache, absolutePath, currentText, edits, options } = args;
-	const snapshot = cache.get(absolutePath);
-	if (!snapshot || snapshot.lines.size === 0) return null;
-
-	// Precondition: the model's anchors must be vouched-for by the cache. If
-	// even one anchored line is missing from the snapshot, or its cached
-	// content hashes to a different value than the model supplied, refuse —
-	// any merge from here is a guess.
-	const anchors = collectEditAnchors(edits);
-	for (const anchor of anchors) {
-		const cachedLine = snapshot.lines.get(anchor.line);
-		if (cachedLine === undefined) return null;
-		if (computeLineHash(anchor.line, cachedLine) !== anchor.hash) return null;
-	}
-
-	const overlaid = currentText.split("\n");
-	let maxCachedLine = 0;
-	for (const lineNum of snapshot.lines.keys()) {
-		if (lineNum > maxCachedLine) maxCachedLine = lineNum;
-	}
-	while (overlaid.length < maxCachedLine) overlaid.push("");
-	for (const [lineNum, content] of snapshot.lines) {
-		overlaid[lineNum - 1] = content;
-	}
-	const previousText = overlaid.join("\n");
-	if (previousText === currentText) return null;
+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).";
 
+function applyEditsToSnapshot(
+	previousText: string,
+	currentText: string,
+	edits: HashlineEdit[],
+	options: HashlineApplyOptions,
+	recoveryWarning: string,
+): HashlineRecoveryResult | null {
 	let applied: HashlineApplyResult;
 	try {
 		applied = applyHashlineEdits(previousText, edits, options);
-	} catch (err) {
-		if (err instanceof HashlineMismatchError) return null;
-		throw err;
+	} catch {
+		return null;
 	}
 	if (applied.lines === previousText) return null;
 
@@ -98,11 +50,9 @@ export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): Hashlin
 	if (typeof merged !== "string" || merged === currentText) return null;
 
 	const mergedDiff = generateDiffString(currentText, merged);
-	// Only surface the recovery warning when the merge actually changed
-	// something visible. A no-op merge (e.g. trailing-newline only) is noise.
 	const hasNetChange = mergedDiff.firstChangedLine !== undefined;
 	const recoveryWarnings = hasNetChange
-		? [HASHLINE_RECOVERY_WARNING, ...(applied.warnings ?? [])]
+		? [recoveryWarning, ...(applied.warnings ?? [])]
 		: [...(applied.warnings ?? [])];
 
 	return {
@@ -111,3 +61,45 @@ export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): Hashlin
 		warnings: recoveryWarnings,
 	};
 }
+
+function buildSparseOverlayText(currentText: string, snapshotLines: ReadonlyMap<number, string>): string {
+	const overlaid = currentText.split("\n");
+	let maxCachedLine = 0;
+	for (const lineNum of snapshotLines.keys()) {
+		if (lineNum > maxCachedLine) maxCachedLine = lineNum;
+	}
+	while (overlaid.length < maxCachedLine) overlaid.push("");
+	for (const [lineNum, content] of snapshotLines) {
+		overlaid[lineNum - 1] = content;
+	}
+	return overlaid.join("\n");
+}
+
+function isHeadSnapshot(head: FileReadSnapshot | null, snapshot: FileReadSnapshot): boolean {
+	return head === snapshot;
+}
+
+function resolveRecoveryWarning(head: FileReadSnapshot | null, snapshot: FileReadSnapshot): string {
+	return isHeadSnapshot(head, snapshot) ? HASHLINE_RECOVERY_EXTERNAL_WARNING : HASHLINE_RECOVERY_SESSION_CHAIN_WARNING;
+}
+
+/**
+ * Attempt to recover from a section file-hash mismatch by replaying the edits
+ * against a cached pre-edit snapshot of the file and 3-way-merging the result
+ * onto the current on-disk content. Returns `null` when no recovery is possible.
+ */
+export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null {
+	const { cache, absolutePath, currentText, fileHash, edits, options } = args;
+	const head = cache.get(absolutePath);
+	const snapshot = cache.getByHash(absolutePath, fileHash);
+	if (!snapshot || snapshot.lines.size === 0) return null;
+
+	const recoveryWarning = resolveRecoveryWarning(head, snapshot);
+	if (snapshot.fullText !== undefined) {
+		return applyEditsToSnapshot(snapshot.fullText, currentText, edits, options, recoveryWarning);
+	}
+
+	const overlayText = buildSparseOverlayText(currentText, snapshot.lines);
+	if (computeFileHash(overlayText) !== fileHash) return null;
+	return applyEditsToSnapshot(overlayText, currentText, edits, options, recoveryWarning);
+}

package/src/hashline/stream.ts

@@ -1,4 +1,4 @@
-import { formatHashLine } from "./hash";
+import { formatNumberedLine } from "./hash";
 import type { HashlineStreamOptions } from "./types";
 
 interface ResolvedHashlineStreamOptions {
@@ -34,7 +34,7 @@ function createHashlineChunkEmitter(options: ResolvedHashlineStreamOptions): Has
 	};
 
 	const pushLine = (line: string): string[] => {
-		const formatted = formatHashLine(lineNumber, line);
+		const formatted = formatNumberedLine(lineNumber, line);
 		lineNumber++;
 
 		const chunks: string[] = [];