@oh-my-pi/pi-coding-agent 15.2.2 → 15.2.4

package/src/hashline/hash.ts

@@ -75,7 +75,13 @@ export function describeAnchorExamples(linePrefix = ""): string {
  * pass through unchanged.
  */
 export function resolveHashlineGrammarPlaceholders(grammar: string): string {
-	return grammar.replaceAll("$HFMT$", "[a-z]{2}").replaceAll("$HSEP$", JSON.stringify(HL_EDIT_SEP));
+	return grammar
+		.replaceAll("$HFMT$", "[a-z]{2}")
+		.replaceAll("$HOP_INSERT_BEFORE$", HL_OP_INSERT_BEFORE)
+		.replaceAll("$HOP_INSERT_AFTER$", HL_OP_INSERT_AFTER)
+		.replaceAll("$HOP_REPLACE$", HL_OP_REPLACE)
+		.replaceAll("$HOP_CHARS$", HL_OP_CHARS)
+		.replaceAll("$HFILE$", HL_FILE_PREFIX);
 }
 
 /** @deprecated Use {@link resolveHashlineGrammarPlaceholders}. */
@@ -84,51 +90,23 @@ export const resolveLarkLidPlaceholders = resolveHashlineGrammarPlaceholders;
 const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 /**
- * Single source of truth for the hashline edit payload separator. This is the
- * configured separator that starts inserted/replacement payload lines in
- * hashline edit input (`<separator>TEXT`) and separates inline modify ops from
- * their appended/prepended text.
+ * Hashline edit input markers. File section headers start with {@link HL_FILE_PREFIX};
+ * op lines start with a direction/action sigil: {@link HL_OP_INSERT_BEFORE},
+ * {@link HL_OP_INSERT_AFTER}, or {@link HL_OP_REPLACE}. Payload lines are
+ * verbatim file content and have no per-line marker.
  *
- * Override at runtime with the `PI_HL_SEP` env var (e.g.
- * `PI_HL_SEP=">"`, `PI_HL_SEP="\\"`). The value is read once at module load;
- * the edit grammar, prompt helper, and edit parser derive from it.
- *
- * Default is `~`, chosen empirically. Benchmark across 8 candidate separators
- * x 3 models (glm-4.7:nitro, gpt-5.4-nano, claude-sonnet-4-6), 24-48 runs per
- * cell, hashline variant, 12 sampled tasks per run:
- *
- *   sep | task ✓ | edit ✓ | patch fail      | tok/run
- *   ----|--------|--------|-----------------|--------
- *    +  | 70.8%  | 78.0%  | 27/125 (21.6%)  | 32,127
- *    ÷  | 70.7%  | 90.6%  | 22/211 (10.4%)  | 31,666
- *    ~  | 69.4%  | 94.9%  |  6/107 ( 5.6%)  | 30,529   <-- default
- *    >  | 69.2%  | 91.5%  | 21/219 ( 9.6%)  | 30,777
- *    :  | 66.7%  | 86.4%  | 20/126 (15.9%)  | 33,900
- *    |  | 65.9%  | 86.9%  | 20/127 (15.7%)  | 34,589
- *    \  | 65.5%  | 89.8%  | 16/124 (12.9%)  | 36,010
- *    %  | 63.9%  | 92.8%  | 11/125 ( 8.8%)  | 36,530
- *
- * `~` wins because:
- *   - highest edit-tool success rate (94.9%) of any tested separator
- *   - lowest patch-failure rate (5.6%) — model rarely emits a malformed payload
- *   - cheapest in tokens alongside `>` (no retry overhead from format collisions)
- *   - no line-leading role in any mainstream language, markdown, diff, regex,
- *     or shell, so payload lines are unambiguous to both the parser and models
- *   - task-success is statistically tied with `>` and `÷` (within run-to-run
- *     noise), so the edit-reliability win is free
- *
- * `+` and `÷` lead on raw task-success but at the cost of ~2-4x more patch
- * failures (the model retries until it lands a valid edit). `:`, `|`, `\`
- * collide with line-leading syntax (label/object-key, body separator, escape)
- * and degrade both edit reliability and intent-match.
+ * These constants are the single source of truth for the edit parser, grammar,
+ * renderer, and prompt.
  */
-export const HL_EDIT_SEP = (() => {
-	const sep = process.env.PI_HL_SEP?.trim();
-	return sep?.length === 1 ? sep : "~";
-})();
+export const HL_OP_INSERT_BEFORE = "«";
+export const HL_OP_INSERT_AFTER = "»";
+export const HL_OP_REPLACE = "≔";
+
+/** 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}`;
 
-/** Regex-escaped form of {@link HL_EDIT_SEP}, safe for regexes. */
-export const HL_EDIT_SEP_RE_RAW = regexEscape(HL_EDIT_SEP);
+/** Hashline edit file section header marker. */
+export const HL_FILE_PREFIX = "§";
 
 /** Stable separator for read/search/hashline display output. Intentionally not configurable. */
 export const HL_BODY_SEP = "|";

package/src/hashline/input.ts

@@ -1,8 +1,11 @@
 import * as path from "node:path";
-import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER, FILE_HEADER_PREFIX } from "./constants";
-import { HL_EDIT_SEP } from "./hash";
+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";
 
+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;
@@ -26,19 +29,18 @@ function normalizeHashlinePath(rawPath: string, cwd?: string): string {
 
 function parseHashlineHeaderLine(line: string, cwd?: string): HashlineInputSection | null {
 	const trimmed = line.trimEnd();
-	if (!trimmed.startsWith(FILE_HEADER_PREFIX)) return null;
-	// Some models occasionally emit unified-diff-style "@@ path" (or even longer
-	// runs of "@"). Strip every leading "@" before resolving the path so those
-	// stray headers still route to the right file.
+	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] === FILE_HEADER_PREFIX) prefixEnd++;
+	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 "${FILE_HEADER_PREFIX}" is empty; provide a file path.`);
+		throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
 	}
 	const parsedPath = normalizeHashlinePath(rest, cwd);
 	if (parsedPath.length === 0) {
-		throw new Error(`Input header "${FILE_HEADER_PREFIX}" is empty; provide a file path.`);
+		throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
 	}
 	return { path: parsedPath, diff: "" };
 }
@@ -64,7 +66,7 @@ function stripLeadingBlankLines(input: string): string {
 
 export function containsRecognizableHashlineOperations(input: string): boolean {
 	for (const line of input.split(/\r?\n/)) {
-		if (/^[+<=-]\s+/.test(line) || line.startsWith(HL_EDIT_SEP)) return true;
+		if (HASHLINE_OP_LINE_RE.test(line)) return true;
 	}
 	return false;
 }
@@ -79,7 +81,7 @@ function normalizeFallbackInput(input: string, options: SplitHashlineOptions): s
 	if (!options.path || !containsRecognizableHashlineOperations(input)) return input;
 	const fallbackPath = normalizeHashlinePath(options.path, options.cwd);
 	if (fallbackPath.length === 0) return input;
-	return `${FILE_HEADER_PREFIX} ${fallbackPath}\n${input}`;
+	return `${HL_FILE_PREFIX}${fallbackPath}\n${input}`;
 }
 
 export function splitHashlineInput(input: string, options: SplitHashlineOptions = {}): { path: string; diff: string } {
@@ -95,8 +97,8 @@ 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 "@@ PATH" on the first non-blank line; got: ${preview}. ` +
-				`Example: "@@ src/foo.ts" then edit ops.`,
+			`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.`,
 		);
 	}
 

package/src/hashline/parser.ts

@@ -1,8 +1,17 @@
 import { ABORT_MARKER, ABORT_WARNING, BEGIN_PATCH_MARKER, END_PATCH_MARKER, RANGE_INTERIOR_HASH } from "./constants";
-import { describeAnchorExamples, HL_EDIT_SEP, HL_HASH_CAPTURE_RE_RAW } from "./hash";
+import {
+	describeAnchorExamples,
+	HL_FILE_PREFIX,
+	HL_HASH_CAPTURE_RE_RAW,
+	HL_OP_CHARS,
+	HL_OP_INSERT_AFTER,
+	HL_OP_INSERT_BEFORE,
+	HL_OP_REPLACE,
+} from "./hash";
 import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
 
 const LID_CAPTURE_RE = new RegExp(`^${HL_HASH_CAPTURE_RE_RAW}$`);
+const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 function parseLid(raw: string, lineNum: number): Anchor {
 	const match = LID_CAPTURE_RE.exec(raw);
@@ -22,12 +31,8 @@ interface ParsedRange {
 
 function parseRange(raw: string, lineNum: number): ParsedRange {
 	if (!raw.includes("..")) {
-		throw new Error(
-			`line ${lineNum}: explicit ranges are required for delete/replace. ` +
-				`Repeat the same anchor on both sides for a one-line edit (for example, ` +
-				`${describeAnchorExamples("119")}..${describeAnchorExamples("119")}); ` +
-				`got ${JSON.stringify(raw)}.`,
-		);
+		const start = parseLid(raw, lineNum);
+		return { start, end: { ...start } };
 	}
 	const [startRaw, endRaw, extra] = raw.split("..");
 	if (extra !== undefined || !startRaw || !endRaw) {
@@ -64,157 +69,61 @@ function parseInsertTarget(raw: string, lineNum: number, kind: "before" | "after
 	return { kind: cursorKind, anchor: parseLid(raw, lineNum) };
 }
 
-const INSERT_BEFORE_OP_RE = /^<\s*(\S+)$/;
-const INSERT_AFTER_OP_RE = /^\+\s*(\S+)$/;
-const DELETE_OP_RE = /^-\s*(\S+)$/;
-const REPLACE_OP_RE = /^=\s*(\S+)$/;
+const INSERT_BEFORE_OP_RE = new RegExp(`^${regexEscape(HL_OP_INSERT_BEFORE)}\\s*(\\S+)\\s*$`);
+const INSERT_AFTER_OP_RE = new RegExp(`^${regexEscape(HL_OP_INSERT_AFTER)}\\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();
+	return trimmed === BEGIN_PATCH_MARKER || trimmed === END_PATCH_MARKER || trimmed === ABORT_MARKER;
+}
+
+function isPayloadTerminatorLine(line: string): boolean {
+	const first = line[0];
+	return (
+		first === HL_FILE_PREFIX ||
+		(first !== undefined && HL_OP_CHARS.includes(first)) ||
+		isEnvelopeOrAbortMarkerLine(line)
+	);
+}
 
 export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 	if (cursor.kind === "before_anchor") return { kind: "before_anchor", anchor: { ...cursor.anchor } };
 	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
 	return cursor;
 }
-/**
- * Returns true when every non-empty payload line looks like the `~ TEXT` readability-padding
- * typo: exactly one leading space followed by a non-space character (or a bare single space).
- *
- * Indented file content (Python 4-space, YAML/JSON/Markdown 2-space, etc.) starts with two or
- * more leading spaces, so this heuristic ignores legitimate indentation while still flagging
- * the common `~ beta` mistake that silently corrupts file content with a stray space.
- */
-function hasUniformSeparatorPadding(payload: string[]): boolean {
-	let any = false;
-	for (const text of payload) {
-		if (text.length === 0) continue;
-		if (text.charCodeAt(0) !== 0x20) return false;
-		// Two or more leading spaces is real indentation, not separator padding.
-		if (text.length > 1 && text.charCodeAt(1) === 0x20) return false;
-		any = true;
-	}
-	return any;
-}
-
-/**
- * File extensions where leading single-space indentation is plausible legitimate file content
- * (off-side-rule languages, structured-indent data formats, prose with continuation indent).
- * For these we suppress the separator-padding warning entirely — the heuristic's false-positive
- * cost on a real edit outweighs the rare chance it catches a `~ TEXT` typo.
- */
-const INDENT_SENSITIVE_EXTS: Record<string, true> = {
-	".py": true,
-	".pyi": true,
-	".pyx": true,
-	".pyw": true,
-	".yml": true,
-	".yaml": true,
-	".md": true,
-	".mdx": true,
-	".markdown": true,
-	".rst": true,
-	".adoc": true,
-	".asciidoc": true,
-	".toml": true,
-	".json": true,
-	".jsonc": true,
-	".json5": true,
-	".ndjson": true,
-	".jsonl": true,
-	".tf": true,
-	".tfvars": true,
-	".hcl": true,
-	".nix": true,
-	".coffee": true,
-	".litcoffee": true,
-	".haml": true,
-	".slim": true,
-	".pug": true,
-	".jade": true,
-	".sass": true,
-	".styl": true,
-	".nim": true,
-	".cr": true,
-	".elm": true,
-	".fs": true,
-	".fsi": true,
-	".fsx": true,
-};
-
-function isIndentationSensitivePath(path: string | undefined): boolean {
-	if (!path) return false;
-	const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
-	const dot = path.lastIndexOf(".");
-	if (dot <= slash) return false;
-	const ext = path.slice(dot).toLowerCase();
-	return INDENT_SENSITIVE_EXTS[ext] === true;
-}
 
 function collectPayload(
 	lines: string[],
 	startIndex: number,
 	opLineNum: number,
 	requirePayload: boolean,
-	checkPadding: boolean,
-): { payload: string[]; nextIndex: number; paddingWarning?: string } {
+): { payload: string[]; nextIndex: number } {
 	const payload: string[] = [];
 	let index = startIndex;
 	while (index < lines.length) {
 		const line = lines[index];
-		if (line.startsWith(HL_EDIT_SEP)) {
-			payload.push(line.slice(HL_EDIT_SEP.length).trimEnd());
-			index++;
-			continue;
-		}
-		// Silently recover from a missing payload prefix on an otherwise blank
-		// line: if more payload follows (possibly past further blanks), treat
-		// each intervening blank as an empty `${HL_EDIT_SEP}` payload line.
-		// Additionally, when the op explicitly requires payload (`+`/`<`) and
-		// we have not collected any yet, accept the blank(s) themselves as the
-		// empty payload — common typo of forgetting the `${HL_EDIT_SEP}` prefix
-		// when inserting a blank line.
-		if (line.length === 0) {
-			let lookahead = index + 1;
-			while (lookahead < lines.length && lines[lookahead].length === 0) {
-				lookahead++;
-			}
-			const followedByPayload = lookahead < lines.length && lines[lookahead].startsWith(HL_EDIT_SEP);
-			const acceptBareBlank = requirePayload && payload.length === 0;
-			if (followedByPayload || acceptBareBlank) {
-				for (let j = index; j < lookahead; j++) payload.push("");
-				index = lookahead;
-				continue;
-			}
-		}
-		break;
+		if (isPayloadTerminatorLine(line)) break;
+		payload.push(line);
+		index++;
 	}
 	if (payload.length === 0 && requirePayload) {
-		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);
+		throw new Error(
+			`line ${opLineNum}: ${HL_OP_INSERT_BEFORE} and ${HL_OP_INSERT_AFTER} operations require at least one verbatim payload line.`,
+		);
 	}
-	const paddingWarning =
-		checkPadding && hasUniformSeparatorPadding(payload)
-			? `line ${opLineNum}: every payload line begins with exactly one space before non-space content, ` +
-				`which looks like a readability gap after "${HL_EDIT_SEP}". The space becomes file content. ` +
-				`Drop it unless the file genuinely uses a one-space indent.`
-			: undefined;
-	return { payload, nextIndex: index, paddingWarning };
+	return { payload, nextIndex: index };
 }
 
-export function parseHashline(diff: string, opts: ParseHashlineOptions = {}): HashlineEdit[] {
-	return parseHashlineWithWarnings(diff, opts).edits;
+export function parseHashline(diff: string): HashlineEdit[] {
+	return parseHashlineWithWarnings(diff).edits;
 }
 
-export interface ParseHashlineOptions {
-	/** File path the diff targets. Used to suppress indent-sensitive false-positive warnings. */
-	path?: string;
-}
-
-export function parseHashlineWithWarnings(
-	diff: string,
-	opts: ParseHashlineOptions = {},
-): { edits: HashlineEdit[]; warnings: string[] } {
+export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
 	const edits: HashlineEdit[] = [];
 	const warnings: string[] = [];
 	const lines = diff.split(/\r?\n/);
-	const checkPadding = !isIndentationSensitivePath(opts.path);
+	if (diff.endsWith("\n") && lines.at(-1) === "") lines.pop();
 	let editIndex = 0;
 
 	const pushInsert = (cursor: HashlineCursor, text: string, lineNum: number) => {
@@ -240,15 +149,11 @@ export function parseHashlineWithWarnings(
 			i++;
 			continue;
 		}
-		if (line.startsWith(HL_EDIT_SEP)) {
-			throw new Error(`line ${lineNum}: payload line has no preceding +, <, or = operation.`);
-		}
 
 		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
 		if (insertBeforeMatch) {
 			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true, checkPadding);
-			if (paddingWarning) warnings.push(paddingWarning);
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
 			continue;
@@ -257,37 +162,26 @@ export function parseHashlineWithWarnings(
 		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
 		if (insertAfterMatch) {
 			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true, checkPadding);
-			if (paddingWarning) warnings.push(paddingWarning);
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
 			continue;
 		}
 
-		const deleteMatch = DELETE_OP_RE.exec(line);
-		if (deleteMatch) {
-			for (const anchor of expandRange(parseRange(deleteMatch[1], lineNum))) {
-				edits.push({ kind: "delete", anchor, lineNum, index: editIndex++ });
-			}
-			i++;
-			continue;
-		}
-
 		const replaceMatch = REPLACE_OP_RE.exec(line);
 		if (replaceMatch) {
 			const range = parseRange(replaceMatch[1], lineNum);
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, false, checkPadding);
-			if (paddingWarning) warnings.push(paddingWarning);
-			// `= A..B` with no payload blanks the range to a single empty line.
-			const replacement = payload.length === 0 ? [""] : payload;
-			for (const text of replacement) {
-				edits.push({
-					kind: "insert",
-					cursor: { kind: "before_anchor", anchor: { ...range.start } },
-					text,
-					lineNum,
-					index: editIndex++,
-				});
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			if (payload.length > 0) {
+				for (const text of payload) {
+					edits.push({
+						kind: "insert",
+						cursor: { kind: "before_anchor", anchor: { ...range.start } },
+						text,
+						lineNum,
+						index: editIndex++,
+					});
+				}
 			}
 			for (const anchor of expandRange(range)) {
 				edits.push({ kind: "delete", anchor, lineNum, index: editIndex++ });
@@ -296,8 +190,15 @@ export function parseHashlineWithWarnings(
 			continue;
 		}
 
+		if (isPayloadTerminatorLine(line) || /^[-@\u00B6]/u.test(line)) {
+			throw new Error(
+				`line ${lineNum}: unrecognized op. Use ${HL_OP_INSERT_BEFORE}ANCHOR (insert before), ${HL_OP_INSERT_AFTER}ANCHOR (insert after), or ${HL_OP_REPLACE}A..B (replace/delete). ` +
+					`Got ${JSON.stringify(line)}.`,
+			);
+		}
+
 		throw new Error(
-			`line ${lineNum}: unrecognized op. Use < ANCHOR (insert before), + ANCHOR (insert after), - A..B (delete), = A..B (replace), or "${HL_EDIT_SEP}TEXT" payload lines. ` +
+			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, or ${HL_OP_REPLACE} operation. ` +
 				`Got ${JSON.stringify(line)}.`,
 		);
 	}