@oh-my-pi/hashline 17.2.15 → 17.3.0

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,82 +298,60 @@ 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 (the
- * tree-sitter probe parsed the original and rejects the result), so it is
- * surfaced in the same response instead of waiting for a compiler pass. The
- * classic trigger is a balance-neutral misplacement: a statement landed on
- * the wrong line number with no delimiter anomaly for the repair heuristics
- * to notice.
+ * 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}`;
@@ -392,6 +369,10 @@ export function editBrokeParseWarning(firstChangedLine: number | undefined): str
 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

@@ -7,9 +7,11 @@ Section: `[PATH#TAG]`; `TAG`: 4-hex snapshot from latest `read`/`search`, REQUIR
 <ops>
 `PUT N.=M:`: replace original inclusive lines N–M with body.
 `PUT N*:`: replace syntactic block beginning N; closing line resolved.
-`PUT <N:` / `PUT >N:`: insert before/after N; `<1` head, `>$` tail.
+`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` / `PUT >N` / `PUT N.=M @name` / `PUT N* @name`: paste captured register at gap/range/resolved block; no `:` or body. Unlabeled gap paste: anonymous register; range/block paste: `@name` required.
+`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.

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