@oh-my-pi/hashline 17.2.14 → 17.3.0

package/src/format.ts

@@ -139,8 +139,20 @@ export function formatNumberedLine(lineNumber: number, line: string): string {
 	return `${lineNumber}${HL_LINE_BODY_SEP}${line}`;
 }
 
+/**
+ * Split LF-delimited file text into lines hashline anchors can address.
+ * A terminal newline terminates the preceding line; it is not content.
+ */
+export function splitAddressableFileLines(text: string): string[] {
+	const lines = text.split("\n");
+	if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+
 /** Format file text with hashline-mode line-number prefixes for display. */
 export function formatNumberedLines(text: string, startLine = 1): string {
-	const lines = text.split("\n");
-	return lines.map((line, i) => formatNumberedLine(startLine + i, line)).join("\n");
+	return text
+		.split("\n")
+		.map((line, i) => formatNumberedLine(startLine + i, line))
+		.join("\n");
 }

package/src/messages.ts

@@ -281,11 +281,10 @@ export function pasteAfterBlockUnresolvedLoweredWarning(line: number): string {
 	return unresolvedLoweredWarning(`PUT >${line}*`, line, `PUT >${line}`);
 }
 /**
- * A one-sided boundary echo whose payload is too short to be the widened
- * range's full content: dropping the echo deletes range line(s) the payload
- * never restates (the "widened range" reading), while the "range shifted by
- * the echo" reading keeps them. The readings produce different files, so the
- * edit is rejected instead of repaired.
+ * A one-sided exact boundary echo cannot cover the selected range after the
+ * duplicated body rows are removed. Applying or dropping it would lose
+ * distinct range content, so the edit is rejected unless a parse-restoring
+ * boundary combination proves another reading.
  */
 export function ambiguousBoundaryEchoMessage(
 	startLine: number,
@@ -299,70 +298,67 @@ export function ambiguousBoundaryEchoMessage(
 			: `ends by restating the ${count} line(s) just below the range`;
 	return (
 		`\`PUT ${startLine}${HL_RANGE_SEP}${endLine}:\` rejected: the body ${where}, ` +
-		`but is too short to be the full final content of the widened range — applying it as-is or ` +
-		`auto-repairing would delete range line(s) the body never restates. ` +
-		`Re-issue with the range covering exactly the lines that change and the body as their complete ` +
-		`final content: drop the restated keeper from the body, or widen the range to consume it.`
+		`but is too short to be the full final content of the selected range. ` +
+		`Re-issue with the range covering exactly the lines that change and the body as their complete final content.`
 	);
 }
 
 /**
- * A replacement range deletes trailing structural closer(s) the payload never
- * restates, and nothing anchors the payload inside the block those closers
- * terminate: the payload has no unmatched opener for them and its indentation
- * is not deeper than the closer. Sparing the closer would have to guess
- * whether the payload belongs before it (inside the block) or after it (a
- * sibling), so the edit is rejected instead of repaired.
+ * A syntax-essential selected edge can be retained on either side of the
+ * payload, but indentation does not establish which placement was intended.
  */
-export function ambiguousCloserSpareMessage(
-	startLine: number,
-	endLine: number,
-	closerLine: number,
-	count: number,
-): string {
-	const closers = count === 1 ? `line ${closerLine}` : `lines ${closerLine}-${closerLine + count - 1}`;
+export function ambiguousBoundaryPlacementMessage(startLine: number, endLine: number): string {
 	return (
-		`\`PUT ${startLine}${HL_RANGE_SEP}${endLine}:\` rejected: the range deletes the closing-delimiter ` +
-		`${closers} but the body never restates it, and the body claims no position inside that block ` +
-		`(no unmatched opener, indentation not deeper than the closer) — whether the new content belongs ` +
-		`before or after the closer is ambiguous. Restate the closer in the body at the intended position, ` +
-		`or use \`PUT <${closerLine}:\` / \`PUT >${closerLine}:\` instead.`
+		`\`PUT ${startLine}${HL_RANGE_SEP}${endLine}:\` rejected: a selected boundary row is required for the file to parse, ` +
+		`but the body indentation does not establish whether it belongs before or after that row. ` +
+		`Re-read the region and re-issue with a range that excludes every unchanged boundary row.`
 	);
 }
+
 /**
- * A replacement range starts by deleting structural closer(s) the payload
- * never restates — the "range started one line early, on the `}` that ends
- * the construct above" mistake — but the payload's indentation claims a depth
- * inside the block those closers terminate, so whether the new content
- * belongs before or after the spared closer is ambiguous. Rejected instead of
- * repaired; the at-or-above-depth reading is auto-repaired by sparing the
- * closer ahead of the payload.
+ * Exact-text boundary rows were removed because the remaining payload covers
+ * the selected range and the same rows already survive immediately outside it.
  */
-export function ambiguousLeadingCloserSpareMessage(startLine: number, endLine: number, count: number): string {
-	const closers = count === 1 ? `line ${startLine}` : `lines ${startLine}-${startLine + count - 1}`;
+export function textualBoundaryEchoWarning(startLine: number, leading: number, trailing: number): string {
+	const parts: string[] = [];
+	if (leading > 0) parts.push(`${leading} leading`);
+	if (trailing > 0) parts.push(`${trailing} trailing`);
 	return (
-		`\`PUT ${startLine}${HL_RANGE_SEP}${endLine}:\` rejected: the range starts by deleting the closing-delimiter ` +
-		`${closers} but the body never restates it, and the body's indentation claims a depth inside the block that ` +
-		`closer terminates — whether the new content belongs before or after the closer is ambiguous. ` +
-		`Start the range on the first line that actually changes, or restate the closer in the body at the intended position.`
+		`Auto-repaired a replacement boundary echo at line ${startLine}: dropped ${parts.join(" and ")} body line(s) ` +
+		`already present outside the range. Issue the body as final content for the selected range only.`
 	);
 }
 
 /**
- * A replacement range deletes more opening delimiter(s) than the payload
- * reopens while the matching closer(s) survive below the range — the
- * "payload is a complete construct but the range ends mid-block" mistake.
- * Surfaced as a warning, never a rejection: the applier is language-agnostic
- * and opener/closer text shape cannot prove a syntactic block (the braces may
- * be literal prose), so the edit applies as authored and the author decides.
+ * A replacement range's boundary disposition was corrected by the
+ * syntax-probe-judged search: syntax-essential source boundary rows were
+ * retained, or exact body echoes of surviving outside rows were removed. The
+ * authored result did not parse and the selected result does.
  */
-export function midBlockRangeWarning(startLine: number, endLine: number, orphaned: number): string {
+export function boundaryVariantRepairWarning(startLine: number, kept: number, dropped: number): string {
+	const keptPart = kept === 0 ? "" : `retained ${kept} syntax-essential source boundary row(s) selected by the range`;
+	const droppedPart = dropped === 0 ? "" : `dropped ${dropped} body row(s) duplicated just outside the range`;
+	const action = [keptPart, droppedPart].filter(Boolean).join(" and ");
 	return (
-		`\`PUT ${startLine}${HL_RANGE_SEP}${endLine}:\` deleted ${orphaned} opening delimiter(s) the body never ` +
-		`reopens. If this file is brace-structured code, the matching closing line(s) below the range are now ` +
-		`orphaned — the range likely ended mid-block. If the body was the construct's complete new content, ` +
-		`re-issue with a block op on the construct's opening line (\`PUT N*:\`) so the closing line resolves ` +
-		`automatically; if the delimiters are literal text, ignore this warning.`
+		`Auto-repaired replacement boundaries at line ${startLine}: ${action}. ` +
+		`The result was verified by the syntax probe — re-issue with the range covering exactly the changed ` +
+		`lines and the body as their complete final content.`
+	);
+}
+
+/**
+ * The applied result no longer parses while the pre-edit content did: the
+ * patch introduced a syntax error. Advisory, never a rejection — the applier
+ * honors the authored edit — but the breakage is machine-confirmed by
+ * tree-sitter and surfaced in the same response instead of waiting for a
+ * compiler pass.
+ */
+export function editBrokeParseWarning(firstChangedLine: number | undefined): string {
+	const at = firstChangedLine === undefined ? "" : ` near line ${firstChangedLine}`;
+	return (
+		`This edit introduced a syntax error${at}: the file parsed before the patch and no longer does. ` +
+		`It was applied exactly as written, so a line number or range endpoint is likely wrong — ` +
+		`re-read the touched region and re-issue a correcting edit.`
 	);
 }
 
@@ -373,6 +369,10 @@ export function midBlockRangeWarning(startLine: number, endLine: number, orphane
 export const UNRESOLVED_BLOCK_INTERNAL =
 	"internal error: unresolved block edit reached the applier (resolveBlockEdits was not run).";
 
+/** Internal invariant: clipboard edits must be concrete before application. */
+export const UNRESOLVED_CLIPBOARD_INTERNAL =
+	"internal error: unresolved clipboard edit reached the applier (resolveClipboardEdits was not run).";
+
 /** `REM` received a body row or coexists with line edits. */
 export const REM_TAKES_NO_BODY =
 	"`REM` deletes the whole file and takes no body rows or line ops. Issue it alone under the header.";

package/src/prompt.md

@@ -1,38 +1,40 @@
-Line-anchored patch language: name original lines/gaps to replace, insert, cut, or paste, then list new content. A header ending in `:` takes `+` body rows; colonless `PUT` (paste), `CUT`, `REM`, `MV` take none.
+Line-anchored patch language: name original lines/gaps to replace, insert, cut, or paste; then give new content. `:` headers take `+` body rows; colonless paste `PUT`, `CUT`, `REM`, `MV` take none.
 
 <headers>
-Every file section starts `[PATH#TAG]`. `TAG` = 4-hex snapshot tag from your latest `read`/`search` — REQUIRED on every section. Create new files with `write`; hashline only edits existing files.
+Section: `[PATH#TAG]`; `TAG`: 4-hex snapshot from latest `read`/`search`, REQUIRED each section. New files: `write`; hashline edits existing files only.
 </headers>
 
 <ops>
-`PUT N.=M:` — replace original lines N through M (INCLUSIVE) with body rows.
-`PUT N*:` — replace the syntactic block BEGINNING on line N; its closing line is resolved for you.
-`PUT <N:` / `PUT >N:` — insert body rows before / after line N (`PUT <1:` = file head, `PUT >$:` = file tail).
-`PUT >N*:` — insert body rows after the END of the block beginning at N (at sibling depth). Append inside a block → `PUT >M:`.
-`PUT <N` / `PUT >N` / `PUT N.=M @name` / `PUT N* @name` — paste a captured register at a gap, over a range, or over a resolved block (no `:` header, no body rows). Unlabeled gap `PUT` pastes the anonymous register; span/block paste requires `@name`.
-`CUT N.=M` / `CUT N*` — delete lines N through M / block N and capture them (anonymous, or `@name` when given).
-`REM` — delete the whole section file. `MV DEST` — move/rename to `DEST` (quote paths with spaces); edits above `MV` land on the source first, final content written at `DEST`.
-Single line: `PUT N.=N:` / `CUT N.=N`. Range = ORIGINAL lines touched (`N.=M`, inclusive); body length irrelevant.
+`PUT N.=M:`: replace original inclusive lines N–M with body.
+`PUT N*:`: replace syntactic block beginning N; closing line resolved.
+`PUT <N:` insert body rows before line N (`PUT <1:` = file head).
+`PUT >N:` insert body rows after line N (`PUT >$:` = file tail).
+`PUT >N*:`: insert after block N's end, at sibling depth. Append inside block: `PUT >M:`.
+`PUT <N @name` / `PUT >N @name` paste register `@name` at the gap before/after line N; omit `@name` for the anonymous register.
+`PUT N.=M @name` / `PUT N* @name` paste `@name` over the range / resolved block; `@name` required here.
+`CUT N.=M` / `CUT N*`: delete and capture inclusive lines N–M / block N; anonymous or given `@name`.
+`REM`: delete section file. `MV DEST`: move/rename (quote paths with spaces); prior edits apply to source, final content to `DEST`.
+Single line: `PUT N.=N:` / `CUT N.=N`. Ranges name original inclusive touched lines; body length irrelevant.
 </ops>
 
 <body-rows>
-Only under a `:` header. Every row is `+TEXT`, verbatim (leading whitespace kept); `+` alone = blank line. NEVER `-old` or bare/context rows — the range deletes; the body is only the final content. Keep a line: leave it out of every range. Literal leading `-`/`+` keeps the prefix: `- item` → `+- item`, `+ item` → `++ item`.
+Only below `:` headers. Row: verbatim `+TEXT` (leading whitespace preserved); `+`: blank. NEVER `-old`, bare, or context rows: range deletes; body is final content. Keep line: exclude it from every range. Literal initial `-`/`+`: `- item` → `+- item`; `+ item` → `++ item`.
 </body-rows>
 
 <rules>
-- Line numbers + `#TAG` come from your latest `read`/`search` (`LINE:TEXT` rows); numbers name ORIGINAL lines, never shifted by applied hunks.
-- Applied edits renumber the file and change the `#TAG` — take the next edit's numbers from the edit response or a fresh `read`.
-- Touch only displayed lines — hunks on undisplayed lines are REJECTED. Far from your read window? Re-`read`; confirm numbers map to the intended construct.
-- Elided regions are UNSEEN (`…`/`..` markers, collapsed `N-M:` summary rows) — NEVER place or span a hunk inside one; `read` the range first.
-- NEVER start or end a range mid-expression or mid-block.
-- Ranges cover ONLY changed lines — never widen over keepers. Non-adjacent changes = separate hunks.
-- Whole construct → `PUT N*:`; lines inside one → `PUT N.=M:`.
-- `PUT N*:` resolves EXACTLY the node at N: leading decorators/attributes/doc-comments are separate nodes — point N at the FIRST decorator to sweep both; standalone line-comments are never swept (use `PUT N.=M:`).
-- Block ops anchor the OPENING line of a MULTI-LINE construct — never the closer, last line, or a bare inner statement; one statement → plain op (`PUT N.=N:` / `CUT N.=N` / `PUT >N:`). Saw the closer? `PUT >M:`.
-- Markdown: a heading IS a block opener — block ops on `##`/`###` resolve the WHOLE section (through deeper nested headings, up to the next same-or-higher heading). `PUT >N*:` after a section: end the body with a blank line to keep the next heading separated.
-- Pure additions → `PUT <N:` / `PUT >N:`, never a widened `PUT N.=M:`.
-- Move code with `CUT`+`PUT`: `CUT 5.=9 @fn` captures into `@fn`; `PUT >40 @fn` pastes it. Unlabeled `CUT` + `PUT >40` works for a single call-local move. Named registers persist across edit calls.
-- NEVER format/restyle code with this tool; run the project formatter.
+- Numbers and `#TAG`: latest `read`/`search` `LINE:TEXT`; numbers are original, never shifted by hunks.
+- Each edit renumbers and changes `#TAG` → next numbers from edit response or fresh `read`.
+- Touch displayed lines only; undisplayed hunks REJECTED. Far from read window: re-`read`; confirm construct.
+- Elisions UNSEEN: `…`, `..`, collapsed `N-M:` rows. NEVER hunk in/across one; `read` first.
+- NEVER start/end range mid-expression or mid-block.
+- Ranges: changed lines only; NEVER widen over keepers. Non-adjacent changes: separate hunks.
+- Whole construct: `PUT N*:`; internal lines: `PUT N.=M:`.
+- `PUT N*:` resolves exactly node N. Leading decorators/attributes/doc-comments are separate nodes: point N at first decorator to include both. Standalone line-comments never swept: use `PUT N.=M:`.
+- Block ops: opening line of multi-line construct, NEVER closer, last line, bare inner statement. One statement: plain `PUT N.=N:` / `CUT N.=N` / `PUT >N:`. At closer: `PUT >M:`.
+- Markdown headings are block openers. Block op on `##`/`###`: whole section through deeper headings to next same/higher heading. After section `PUT >N*:`: end body with blank line to separate next heading.
+- Pure addition: `PUT <N:` / `PUT >N:`, NEVER widened `PUT N.=M:`.
+- Move: `CUT`+`PUT`; `CUT 5.=9 @fn` → `@fn`, `PUT >40 @fn` pastes. Single call-local move: unlabeled `CUT` + `PUT >40`. Named registers persist across edit calls.
+- NEVER format/restyle with this tool; run project formatter.
 </rules>
 
 <example>
@@ -54,7 +56,7 @@ PUT 1.=3:
 MV lib/greet.py
 ```
 
-Markdown bullets — the file receives `- task`:
+Markdown bullets — file receives `- task`:
 ```
 [PLAN.md#A1B2]
 PUT >2:
@@ -62,7 +64,7 @@ PUT >2:
 +  - nested task
 ```
 
-Move `greet` to a sibling file using a named register — flows across sections:
+Move `greet` to sibling file via named register; flows across sections:
 ```
 [greet.py#A1B2]
 CUT 1* @fn
@@ -70,7 +72,7 @@ CUT 1* @fn
 PUT <1 @fn
 ```
 
-`PUT 1*:` resolves lines 1–3 (`def` header through `print(msg)`); line 4 is a separate statement and stays:
+`PUT 1*:` resolves lines 1–3 (`def` through `print(msg)`); line 4 separate, remains:
 ```
 [greet.py#A1B2]
 PUT 1*:
@@ -78,7 +80,7 @@ PUT 1*:
 +    print(f"Hello, {name}")
 ```
 
-Decorator/doc-comment = SEPARATE block — point N at the decorator to take both; anchoring the `def` (line 2) would orphan `@cache`:
+Decorator/doc-comment separate block: point N at decorator to include both; anchoring `def` line 2 orphans `@cache`:
 ```
 [svc.py#C3D4]
 PUT 1*:
@@ -127,7 +129,7 @@ PUT >20 @fn:
 </anti-patterns>
 
 <critical>
-1. RE-GROUND AFTER EVERY EDIT — applied edits renumber the file and change the `#TAG`; take next numbers from the edit response or a fresh `read`. Stale tag or surprise? STOP, re-`read`.
-2. RANGES ARE TIGHT — cover only lines that change. Whole construct → `PUT N*:`.
-3. BODY = FINAL CONTENT — every body row starts with `+`; Markdown bullets use `+- item`, not `- item`.
+1. RE-GROUND AFTER EVERY EDIT: edits renumber and change `#TAG`; take next numbers from edit response or fresh `read`. Stale tag/surprise: STOP; re-`read`.
+2. RANGES TIGHT: changed lines only. Whole construct: `PUT N*:`.
+3. BODY FINAL CONTENT: every row starts `+`; Markdown bullet: `+- item`, not `- item`.
 </critical>

package/src/syntax.ts

@@ -1,13 +1,12 @@
 /**
  * Syntax probe for candidate edit results, via the native tree-sitter parser.
  *
- * Delimiter-balance arithmetic cannot tell a block closer from a `}` inside a
- * regex literal, a string, or Markdown prose. A parser can, so it holds veto
- * power over every repair whose justification is "this line closes a syntactic
- * block": when the edit the author actually wrote still parses, no such repair
- * may rewrite it. The probe never *forces* a repair — an unrecognized language
- * or an already-broken file simply yields no veto, leaving the delimiter
- * heuristics as the only available evidence.
+ * Replacement-boundary repair uses parsing as its semantic filter: exact
+ * outside-row equality may justify dropping a duplicated payload edge, while
+ * retaining a selected source boundary additionally requires source-range
+ * structure, indentation, or a narrow pure-closer shape. An unrecognized
+ * language yields no structural proof, so only evidence-complete textual
+ * normalization remains available.
  */
 
 import { enclosingBlockBoundaries } from "@oh-my-pi/pi-natives";
@@ -16,6 +15,33 @@ import { enclosingBlockBoundaries } from "@oh-my-pi/pi-natives";
 const parseCache = new Map<string, boolean>();
 const PARSE_CACHE_MAX = 256;
 
+const boundaryCache = new Map<string, readonly number[]>();
+
+/** Syntactic node boundaries outside a visible source range. */
+export function enclosingBoundaries(
+	lines: readonly string[],
+	path: string,
+	startLine: number,
+	endLine: number,
+): readonly number[] {
+	const text = lines.join("\n");
+	const key = `${Bun.hash(text).toString(36)}:${text.length}:${path}:${startLine}:${endLine}`;
+	const cached = boundaryCache.get(key);
+	if (cached !== undefined) return cached;
+	let boundaries: readonly number[];
+	try {
+		boundaries = enclosingBlockBoundaries({ code: text, path, ranges: [{ startLine, endLine }] }) ?? [];
+	} catch {
+		boundaries = [];
+	}
+	if (boundaryCache.size >= PARSE_CACHE_MAX) {
+		const oldest = boundaryCache.keys().next().value;
+		if (oldest !== undefined) boundaryCache.delete(oldest);
+	}
+	boundaryCache.set(key, boundaries);
+	return boundaries;
+}
+
 /**
  * `true` when `text` parses without a syntax error under the language inferred
  * from `path`. `false` covers "does not parse" and "cannot tell" alike — no