@oh-my-pi/hashline 17.2.0 → 17.2.2

package/src/patcher.ts

@@ -25,7 +25,7 @@
 import * as path from "node:path";
 import { applyEdits } from "./apply";
 import { hasBlockEdit, resolveBlockEdits } from "./block";
-import { commitClipboard, forkClipboard, validateClipboardSequence } from "./clipboard";
+import { commitClipboard, forkClipboard, startClipboardBatch, validateClipboardSequence } from "./clipboard";
 import { computeFileHash, formatHashlineHeader } from "./format";
 import type { Filesystem, WriteResult } from "./fs";
 import { isNotFound } from "./fs";
@@ -161,11 +161,11 @@ export class PreparedSection {
 
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
-		if (edit.kind === "delete") return true;
-		// A `replace_block N:` edit anchors to concrete content on line N.
-		if (edit.kind === "block") return true;
-		// A `CUT` range reads concrete content.
-		if (edit.kind === "cut") return true;
+		if (edit.kind === "delete" || edit.kind === "block" || edit.kind === "cut") return true;
+		if (edit.kind === "paste") {
+			if (edit.at.kind === "span") return true;
+			return edit.at.cursor.kind === "before_anchor" || edit.at.cursor.kind === "after_anchor";
+		}
 		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
 }
@@ -247,7 +247,7 @@ export class Patcher {
 		// work on a fork and publish it per landed section, so a failed batch
 		// never poisons the persistent register and a mid-batch failure still
 		// preserves content already cut from disk.
-		const clipboard = forkClipboard(this.clipboard);
+		const clipboard = startClipboardBatch(this.clipboard);
 
 		// Single-section fast path.
 		if (patch.sections.length === 1) {
@@ -305,7 +305,7 @@ export class Patcher {
 	 */
 	async preflight(patch: Patch): Promise<void> {
 		// Dry run: fork the register and never publish it back.
-		const clipboard = forkClipboard(this.clipboard);
+		const clipboard = startClipboardBatch(this.clipboard);
 		const prepared: PreparedSection[] = [];
 		for (const section of patch.sections) prepared.push(await this.prepare(section, clipboard));
 		assertUniqueCanonicalPaths(prepared);

package/src/prefixes.ts

@@ -20,7 +20,15 @@ const HL_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:[+*-]\s*)?\d+:/;
 const HL_PREFIX_PLUS_RE = /^\s*(?:>>>|>>)?\s*\+\s*\d+:/;
 const HL_HEADER_RE = new RegExp(`^\\s*\\[[^#\\r\\n]+#[0-9a-fA-F]{${HL_FILE_HASH_LENGTH}}\\]\\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+/;
+const READ_TRUNCATION_NOTICE_RE =
+	/^\s*\[(?:(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bUse :L?\d+|(?:…|\.\.\.)?\d+\s*ln elided;\s*re-read needed ranges with .+)\]\s*$/;
+const READ_RANGE_ELISION_RE = /^\s*[1-9]\d*\s*-\s*[1-9]\d*:.*(?:…|\.\.\.).*$/;
+const READ_SINGLE_ELISION_RE = /^\s*(?:…|\.\.\.)\s*$/;
+
+/** Whether a row is display-only metadata emitted by `read`, never source. */
+export function isReadMetadataLine(line: string): boolean {
+	return READ_TRUNCATION_NOTICE_RE.test(line) || READ_RANGE_ELISION_RE.test(line) || READ_SINGLE_ELISION_RE.test(line);
+}
 
 function stripLeadingHashlinePrefixes(line: string): string {
 	let result = line;
@@ -63,7 +71,7 @@ function collectLinePrefixStats(lines: string[]): LinePrefixStats {
 
 	for (const line of lines) {
 		if (line.length === 0) continue;
-		if (READ_TRUNCATION_NOTICE_RE.test(line)) {
+		if (isReadMetadataLine(line)) {
 			stats.truncationNoticeCount++;
 			continue;
 		}
@@ -103,7 +111,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) && !(stripHash && HL_HEADER_RE.test(line)))
+		.filter(line => !isReadMetadataLine(line) && !(stripHash && HL_HEADER_RE.test(line)))
 		.map(line => {
 			if (stripHash) return stripLeadingHashlinePrefixes(line);
 			if (stripPlus) return line.replace(DIFF_PLUS_RE, "");
@@ -124,7 +132,7 @@ export function stripHashlinePrefixes(lines: string[]): string[] {
 	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))
+		.filter(line => !isReadMetadataLine(line) && !HL_HEADER_RE.test(line))
 		.map(line => stripLeadingHashlinePrefixes(line));
 }
 

package/src/prompt.md

@@ -1,19 +1,18 @@
-Line-anchored patch language: name original lines to replace, cut, or insert at, then list new content. A header ending in `:` takes `+` body rows; `CUT`, `PASTE`, `REM`, `MV` take none.
+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.
 
 <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.
 </headers>
 
 <ops>
-`SWAP N.=M:` — replace original lines N.=M (INCLUSIVE).
-`SWAP.BLK N:` — replace the whole syntactic block BEGINNING on line N; its closing line is resolved for you.
-`CUT N.=M` / `CUT.BLK N` — delete lines N.=M / the block beginning at N, and capture them for `PASTE`.
-`INS.PRE N:` / `INS.POST N:` — insert immediately before / after line N.
-`INS.BLK.POST N:` — insert after the END of the block beginning at N, outside it at sibling depth. Append inside a block → `INS.POST`.
-`INS.HEAD:` / `INS.TAIL:` — insert at the very start / end of the file.
-`PASTE.PRE N` / `PASTE.POST N` / `PASTE.HEAD` / `PASTE.TAIL` / `PASTE.BLK.POST N` — insert the clipboard at the position (the clipboard IS the body).
+`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: `SWAP N.=N:` / `CUT N`. Range = ORIGINAL lines touched; body length irrelevant (1 line → 10 is still `SWAP N.=N:`).
+Single line: `PUT N.=N:` / `CUT N.=N`. Range = ORIGINAL lines touched (`N.=M`, inclusive); body length irrelevant.
 </ops>
 
 <body-rows>
@@ -27,12 +26,12 @@ Only under a `:` header. Every row is `+TEXT`, verbatim (leading whitespace kept
 - 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 → `SWAP.BLK N`; lines inside one → `SWAP N.=M`.
-- `SWAP.BLK` 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 `SWAP 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 (`SWAP N.=N:` / `CUT N` / `INS.POST N:`). Saw the closer? `INS.POST 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). `INS.BLK.POST` after a section: end the body with a blank line to keep the next heading separated.
-- Pure additions → `INS.PRE`/`INS.POST`/`INS.HEAD`/`INS.TAIL`, never a widened `SWAP`.
-- Move code with `CUT`+`PASTE`, never retype. Clipboard: top-to-bottom across the whole patch (cross-file moves), persists across edit calls, latest `CUT` wins, and `PASTE` repeats freely. Pasted indentation is verbatim; re-indent via `SWAP`.
+- 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.
 </rules>
 
@@ -49,7 +48,7 @@ Only under a `:` header. Every row is `+TEXT`, verbatim (leading whitespace kept
 Edit, then move:
 ```
 [greet.py#A1B2]
-SWAP 1.=3:
+PUT 1.=3:
 +def greet(name):
 +    print(f"Hi, {name}")
 MV lib/greet.py
@@ -58,23 +57,23 @@ MV lib/greet.py
 Markdown bullets — the file receives `- task`:
 ```
 [PLAN.md#A1B2]
-INS.POST 2:
+PUT >2:
 +- task
 +  - nested task
 ```
 
-Move `greet` to a sibling file — clipboard flows across sections:
+Move `greet` to a sibling file using a named register — flows across sections:
 ```
 [greet.py#A1B2]
-CUT.BLK 1
+CUT 1* @fn
 [other.py#3C4D]
-PASTE.HEAD
+PUT <1 @fn
 ```
 
-`SWAP.BLK 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` header through `print(msg)`); line 4 is a separate statement and stays:
 ```
 [greet.py#A1B2]
-SWAP.BLK 1:
+PUT 1*:
 +def greet(name):
 +    print(f"Hello, {name}")
 ```
@@ -82,7 +81,7 @@ SWAP.BLK 1:
 Decorator/doc-comment = SEPARATE block — point N at the decorator to take both; anchoring the `def` (line 2) would orphan `@cache`:
 ```
 [svc.py#C3D4]
-SWAP.BLK 1:
+PUT 1*:
 +@cache
 +def load(key):
 +    return store[key]
@@ -90,45 +89,45 @@ SWAP.BLK 1:
 </example>
 
 <anti-patterns>
-# WRONG — empty `SWAP` to delete. RIGHT: CUT 4
-SWAP 4.=4:
+# WRONG — empty `PUT` to delete. RIGHT: `CUT 4.=4`
+PUT 4.=4:
 
-# WRONG — range sized to the post-edit content. RIGHT: SWAP 1.=1: (body length irrelevant)
-SWAP 1.=2:
+# WRONG — range sized to the post-edit content. RIGHT: `PUT 1.=1:` (body length irrelevant)
+PUT 1.=2:
 +def greet(name):
 
 # WRONG — `-` rows / bare context lines do not exist; the range deletes, the body is only new content.
-SWAP 3.=3:
+PUT 3.=3:
     msg = "Hello, " + name
 -   print(msg)
 +   return msg
 # RIGHT
-SWAP 3.=3:
+PUT 3.=3:
 +   return msg
 
-# WRONG — pure insertion as a widened `SWAP`: retyped keepers get dropped (here line 4).
-SWAP 2.=4:
+# WRONG — pure insertion as a widened `PUT`: retyped keepers get dropped (here line 4).
+PUT 2.=4:
 +    msg = "Hello, " + name
 +    extra = compute(name)
 +    print(msg)
 # RIGHT — touch nothing you keep.
-INS.POST 2:
+PUT >2:
 +    extra = compute(name)
 
-# WRONG — `INS.BLK.POST` anchored on the closing delimiter / last visible line. RIGHT: plain `INS.POST M:`
-INS.BLK.POST 3:
+# WRONG — `PUT >N*:` anchored on the closing delimiter / last visible line. RIGHT: plain `PUT >M:`
+PUT >3*:
 +after()
 # RIGHT
-INS.POST 3:
+PUT >3:
 +after()
 
-# WRONG — body rows under PASTE; the clipboard is the body. RIGHT: capture first, then a bodyless `PASTE.POST 20`.
-PASTE.POST 20:
+# WRONG — body rows under register PUT; register pastes take no body. RIGHT: bodyless `PUT >20 @fn`.
+PUT >20 @fn:
 +function f() {}
 </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 → `SWAP.BLK N`.
+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`.
 </critical>

package/src/recovery.ts

@@ -49,6 +49,15 @@ function getEditAnchors(edit: Edit): Anchor[] {
 		for (let line = edit.range.start.line; line <= edit.range.end.line; line++) anchors.push({ line });
 		return anchors;
 	}
+	if (edit.kind === "paste") {
+		if (edit.at.kind === "span") {
+			const anchors: Anchor[] = [];
+			for (let line = edit.at.range.start.line; line <= edit.at.range.end.line; line++) anchors.push({ line });
+			return anchors;
+		}
+		const cursor = edit.at.cursor;
+		return cursor.kind === "before_anchor" || cursor.kind === "after_anchor" ? [cursor.anchor] : [];
+	}
 	return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor" ? [edit.cursor.anchor] : [];
 }
 
@@ -236,23 +245,55 @@ function remapEditsToCurrent(previousText: string, currentText: string, edits: r
 			remapped.push({ ...edit, range: { start: { line: start }, end: { line: end } } });
 			continue;
 		}
-
-		let blockStart = edit.blockStart;
-		if (blockStart !== undefined) {
-			const mappedBlockStart = mapLine(blockStart);
-			if (mappedBlockStart === null) return null;
-			blockStart = mappedBlockStart;
-		}
-
-		const cursor = edit.cursor;
-		if (cursor.kind !== "before_anchor" && cursor.kind !== "after_anchor") {
-			remapped.push(blockStart === edit.blockStart ? edit : { ...edit, blockStart });
+		if (edit.kind === "paste") {
+			let blockStart = edit.blockStart;
+			if (blockStart !== undefined) {
+				const mappedBlockStart = mapLine(blockStart);
+				if (mappedBlockStart === null) return null;
+				blockStart = mappedBlockStart;
+			}
+			if (edit.at.kind === "span") {
+				const start = mapLine(edit.at.range.start.line);
+				if (start === null) return null;
+				let end = start;
+				for (let line = edit.at.range.start.line + 1; line <= edit.at.range.end.line; line++) {
+					const mapped = mapLine(line);
+					if (mapped === null) return null;
+					end = mapped;
+				}
+				remapped.push({
+					...edit,
+					at: { kind: "span", range: { start: { line: start }, end: { line: end } } },
+					blockStart,
+				});
+				continue;
+			}
+			const cursor = edit.at.cursor;
+			if (cursor.kind !== "before_anchor" && cursor.kind !== "after_anchor") {
+				remapped.push(blockStart === edit.blockStart ? edit : { ...edit, blockStart });
+				continue;
+			}
+			const anchor = mapAnchor(cursor.anchor);
+			if (anchor === null) return null;
+			remapped.push({ ...edit, at: { kind: "gap", cursor: { kind: cursor.kind, anchor } }, blockStart });
 			continue;
 		}
-
-		const anchor = mapAnchor(cursor.anchor);
-		if (anchor === null) return null;
-		remapped.push({ ...edit, cursor: { kind: cursor.kind, anchor }, blockStart });
+		if (edit.kind === "insert") {
+			let blockStart = edit.blockStart;
+			if (blockStart !== undefined) {
+				const mappedBlockStart = mapLine(blockStart);
+				if (mappedBlockStart === null) return null;
+				blockStart = mappedBlockStart;
+			}
+			const cursor = edit.cursor;
+			if (cursor.kind !== "before_anchor" && cursor.kind !== "after_anchor") {
+				remapped.push(blockStart === edit.blockStart ? edit : { ...edit, blockStart });
+				continue;
+			}
+			const anchor = mapAnchor(cursor.anchor);
+			if (anchor === null) return null;
+			remapped.push({ ...edit, cursor: { kind: cursor.kind, anchor }, blockStart });
+		}
 	}
 
 	if (offsets.length === 0) return null;