@oh-my-pi/hashline 17.1.7 → 17.2.0

package/src/tokenizer.ts

@@ -10,8 +10,8 @@
  */
 import {
 	describeAnchorExamples,
-	HL_DELETE_BLOCK_KEYWORD,
-	HL_DELETE_KEYWORD,
+	HL_CUT_BLOCK_KEYWORD,
+	HL_CUT_KEYWORD,
 	HL_FILE_HASH_LENGTH,
 	HL_FILE_HASH_SEP,
 	HL_FILE_PREFIX,
@@ -24,6 +24,8 @@ import {
 	HL_INSERT_KEYWORD,
 	HL_INSERT_TAIL,
 	HL_MOVE_KEYWORD,
+	HL_PASTE_AFTER_BLOCK_KEYWORD,
+	HL_PASTE_KEYWORD,
 	HL_PAYLOAD_REPLACE,
 	HL_REM_KEYWORD,
 	HL_REPLACE_BLOCK_KEYWORD,
@@ -132,6 +134,7 @@ function scanLineNumber(line: string, index: number, end: number): NumberScan |
 		const code = line.charCodeAt(nextIndex);
 		if (!isDigitCode(code)) break;
 		lineNumber = lineNumber * 10 + (code - CHAR_ZERO);
+		if (!Number.isSafeInteger(lineNumber)) return null;
 		nextIndex++;
 	}
 	return { line: lineNumber, nextIndex };
@@ -214,11 +217,13 @@ function scanHeaderRange(line: string, index = 0, end = trimEndIndex(line), allo
 export type BlockTarget =
 	| { kind: "replace"; range: ParsedRange }
 	| { kind: "block"; anchor: Anchor }
-	| { kind: "delete"; range: ParsedRange }
-	| { kind: "delete_block"; anchor: Anchor }
 	| { kind: "insert_before"; anchor: Anchor }
 	| { kind: "insert_after"; anchor: Anchor }
 	| { kind: "insert_after_block"; anchor: Anchor }
+	| { kind: "cut"; range: ParsedRange }
+	| { kind: "cut_block"; anchor: Anchor }
+	| { kind: "paste"; cursor: Cursor }
+	| { kind: "paste_after_block"; anchor: Anchor }
 	| { kind: "rem" }
 	| { kind: "move"; dest: string }
 	| { kind: "bof" }
@@ -269,30 +274,52 @@ function consumeReplaceColon(line: string, index: number, end: number): number {
 	return skipWhitespace(line, afterEquals + 1, end);
 }
 
-function scanInsertTarget(line: string, index: number, end: number): TargetScan | null {
+interface PositionScan {
+	cursor: Cursor;
+	nextIndex: number;
+}
+
+/** Scan the `.PRE N` / `.POST N` / `.HEAD` / `.TAIL` positional suffix shared by `INS` and `PASTE`. */
+function scanPositionalSuffix(line: string, index: number, end: number): PositionScan | null {
 	if (index >= end || line.charCodeAt(index) !== CHAR_DOT) return null;
-	const cursor = skipWhitespace(line, index + 1, end);
-	const beforeEnd = scanKeyword(line, cursor, end, HL_INSERT_BEFORE);
+	const probe = skipWhitespace(line, index + 1, end);
+	const beforeEnd = scanKeyword(line, probe, end, HL_INSERT_BEFORE);
 	if (beforeEnd !== null) {
 		const anchor = scanLineNumber(line, skipWhitespace(line, beforeEnd, end), end);
 		if (anchor === null) return null;
 		const nextIndex = consumeOptionalColon(line, anchor.nextIndex, end);
-		return { target: { kind: "insert_before", anchor: { line: anchor.line } }, nextIndex };
+		return { cursor: { kind: "before_anchor", anchor: { line: anchor.line } }, nextIndex };
 	}
-	const afterEnd = scanKeyword(line, cursor, end, HL_INSERT_AFTER);
+	const afterEnd = scanKeyword(line, probe, end, HL_INSERT_AFTER);
 	if (afterEnd !== null) {
 		const anchor = scanLineNumber(line, skipWhitespace(line, afterEnd, end), end);
 		if (anchor === null) return null;
 		const nextIndex = consumeOptionalColon(line, anchor.nextIndex, end);
-		return { target: { kind: "insert_after", anchor: { line: anchor.line } }, nextIndex };
+		return { cursor: { kind: "after_anchor", anchor: { line: anchor.line } }, nextIndex };
 	}
-	const headEnd = scanKeyword(line, cursor, end, HL_INSERT_HEAD);
-	if (headEnd !== null) return { target: { kind: "bof" }, nextIndex: consumeOptionalColon(line, headEnd, end) };
-	const tailEnd = scanKeyword(line, cursor, end, HL_INSERT_TAIL);
-	if (tailEnd !== null) return { target: { kind: "eof" }, nextIndex: consumeOptionalColon(line, tailEnd, end) };
+	const headEnd = scanKeyword(line, probe, end, HL_INSERT_HEAD);
+	if (headEnd !== null) return { cursor: { kind: "bof" }, nextIndex: consumeOptionalColon(line, headEnd, end) };
+	const tailEnd = scanKeyword(line, probe, end, HL_INSERT_TAIL);
+	if (tailEnd !== null) return { cursor: { kind: "eof" }, nextIndex: consumeOptionalColon(line, tailEnd, end) };
 	return null;
 }
 
+function scanInsertTarget(line: string, index: number, end: number): TargetScan | null {
+	const scan = scanPositionalSuffix(line, index, end);
+	if (scan === null) return null;
+	const { cursor, nextIndex } = scan;
+	switch (cursor.kind) {
+		case "before_anchor":
+			return { target: { kind: "insert_before", anchor: cursor.anchor }, nextIndex };
+		case "after_anchor":
+			return { target: { kind: "insert_after", anchor: cursor.anchor }, nextIndex };
+		case "bof":
+			return { target: { kind: "bof" }, nextIndex };
+		case "eof":
+			return { target: { kind: "eof" }, nextIndex };
+	}
+}
+
 function unquotePath(pathText: string): string {
 	if (pathText.length < 2) return pathText;
 	const first = pathText[0];
@@ -360,28 +387,6 @@ function scanHunkAnchor(line: string, start: number, end: number): TargetScan |
 			nextIndex: consumeReplaceColon(line, range.nextIndex, end),
 		};
 	}
-	// `delete_block N` — resolve N to a tree-sitter block range at apply time
-	// and delete its whole span. Like `delete N.=M`, it takes no body and no
-	// trailing colon.
-	const deleteBlockEnd = scanKeyword(line, cursor, end, HL_DELETE_BLOCK_KEYWORD);
-	if (deleteBlockEnd !== null) {
-		const anchor = scanLineNumber(line, skipWhitespace(line, deleteBlockEnd, end), end);
-		if (anchor === null) return null;
-		let next = skipWhitespace(line, anchor.nextIndex, end);
-		next = skipStrayDot(line, next, end);
-		if (next < end && line.charCodeAt(next) === CHAR_COLON) return null;
-		return { target: { kind: "delete_block", anchor: { line: anchor.line } }, nextIndex: next };
-	}
-	// `delete N.=M` — like `delete_block N`, takes no body and no trailing
-	// colon; a colon here falls through to contamination detection.
-	const deleteEnd = scanKeyword(line, cursor, end, HL_DELETE_KEYWORD);
-	if (deleteEnd !== null) {
-		const range = scanHeaderRange(line, deleteEnd, end, true);
-		if (range === null) return null;
-		const next = skipStrayDot(line, range.nextIndex, end);
-		if (next < end && line.charCodeAt(next) === CHAR_COLON) return null;
-		return { target: { kind: "delete", range: range.range }, nextIndex: next };
-	}
 	// `insert_after_block N:` — insert after the last line of the tree-sitter
 	// block at N.
 	const insertAfterBlockEnd = scanKeyword(line, cursor, end, HL_INSERT_AFTER_BLOCK_KEYWORD);
@@ -393,6 +398,47 @@ function scanHunkAnchor(line: string, start: number, end: number): TargetScan |
 			nextIndex: consumeOptionalColon(line, anchor.nextIndex, end),
 		};
 	}
+	// `PASTE.BLK.POST N` — insert the clipboard after the tree-sitter block
+	// at N. Like all clipboard ops, takes no body rows.
+	const pasteAfterBlockEnd = scanKeyword(line, cursor, end, HL_PASTE_AFTER_BLOCK_KEYWORD);
+	if (pasteAfterBlockEnd !== null) {
+		const anchor = scanLineNumber(line, skipWhitespace(line, pasteAfterBlockEnd, end), end);
+		if (anchor === null) return null;
+		return {
+			target: { kind: "paste_after_block", anchor: { line: anchor.line } },
+			nextIndex: consumeOptionalColon(line, anchor.nextIndex, end),
+		};
+	}
+	// `PASTE.PRE|POST N` / `PASTE.HEAD|TAIL` — insert the clipboard at the position.
+	const pasteEnd = scanKeyword(line, cursor, end, HL_PASTE_KEYWORD);
+	if (pasteEnd !== null) {
+		const scan = scanPositionalSuffix(line, pasteEnd, end);
+		if (scan === null) return null;
+		return { target: { kind: "paste", cursor: scan.cursor }, nextIndex: scan.nextIndex };
+	}
+	// `CUT.BLK N` captures and deletes the tree-sitter block beginning at N.
+	// Scan it before the plain form so `.BLK` is not parsed as a range.
+	const cutBlockEnd = scanKeyword(line, cursor, end, HL_CUT_BLOCK_KEYWORD);
+	if (cutBlockEnd !== null) {
+		const anchor = scanLineNumber(line, skipWhitespace(line, cutBlockEnd, end), end);
+		if (anchor === null) return null;
+		return {
+			target: { kind: "cut_block", anchor: { line: anchor.line } },
+			nextIndex: consumeOptionalColon(line, anchor.nextIndex, end),
+		};
+	}
+	// `CUT N.=M` captures and deletes concrete lines. A trailing colon is
+	// tolerated and ignored; body rows are rejected by the parser.
+	const cutEnd = scanKeyword(line, cursor, end, HL_CUT_KEYWORD);
+	if (cutEnd !== null) {
+		const range = scanHeaderRange(line, cutEnd, end, true);
+		if (range === null) return null;
+		const next = skipStrayDot(line, range.nextIndex, end);
+		return {
+			target: { kind: "cut", range: range.range },
+			nextIndex: consumeOptionalColon(line, next, end),
+		};
+	}
 	const insertEnd = scanKeyword(line, cursor, end, HL_INSERT_KEYWORD);
 	if (insertEnd !== null) return scanInsertTarget(line, insertEnd, end);
 	return null;
@@ -487,10 +533,11 @@ function classifyLine(line: string, lineNum: number): Token {
 	const lead = skipWhitespace(line, 0);
 	const isHunkLead =
 		line.startsWith(HL_REPLACE_KEYWORD, lead) ||
-		line.startsWith(HL_DELETE_KEYWORD, lead) ||
 		line.startsWith(HL_INSERT_KEYWORD, lead) ||
 		line.startsWith(HL_REM_KEYWORD, lead) ||
-		line.startsWith(HL_MOVE_KEYWORD, lead);
+		line.startsWith(HL_MOVE_KEYWORD, lead) ||
+		line.startsWith(HL_CUT_KEYWORD, lead) ||
+		line.startsWith(HL_PASTE_KEYWORD, lead);
 	if (isHunkLead) {
 		const hunk = tryParseHunkHeader(line);
 		if (hunk !== null) return { kind: "op-block", lineNum, target: hunk.target };

package/src/types.ts

@@ -42,21 +42,46 @@ export type Edit =
 	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string }
 	| {
 			/**
-			 * Deferred block edit (`replace_block N:` / `delete_block N` /
-			 * `insert_after_block N:`). The exact line span is unknown at parse
-			 * time — it is computed by {@link resolveBlockEdits} once file text +
-			 * path (→ language) are available, then expanded into concrete edits:
-			 * a non-empty `payloads` without `mode` (from `replace_block`) becomes
-			 * the same `replacement` inserts + deletes that `replace start.=end:`
-			 * produces; an empty `payloads` (from `delete_block`) becomes a pure
-			 * range deletion; `mode: "insert_after"` becomes plain `after_anchor`
-			 * inserts at the block's last line. `applyEdits` never sees this
-			 * variant.
+			 * Clipboard cut (`CUT N.=M`, or the resolved form of `CUT.BLK N`).
+			 * Captures the range's current lines into the {@link Clipboard}
+			 * register during the applier's clipboard pre-pass and lowers to one
+			 * `delete` per range line at parse/resolve time.
+			 */
+			kind: "cut";
+			range: ParsedRange;
+			lineNum: number;
+			index: number;
+	  }
+	| {
+			/**
+			 * Clipboard insertion (`PASTE.PRE N` / `PASTE.POST N` / `PASTE.HEAD` /
+			 * `PASTE.TAIL`, or the resolved form of `PASTE.BLK.POST N`). Expanded
+			 * by the clipboard pre-pass into one plain insert per captured line.
+			 * `blockStart` mirrors the insert variant's field for block-lowered
+			 * pastes so landing correction can slide the body across trailing
+			 * closer lines.
+			 */
+			kind: "paste";
+			cursor: Cursor;
+			lineNum: number;
+			index: number;
+			blockStart?: number;
+	  }
+	| {
+			/**
+			 * Deferred block edit (`SWAP.BLK N:`, `INS.BLK.POST N:`,
+			 * `CUT.BLK N`, or `PASTE.BLK.POST N`). The exact line span is
+			 * unknown at parse time; {@link resolveBlockEdits} computes it once
+			 * file text and language are available, then expands it into
+			 * concrete edits. `mode: "insert_after"` becomes plain
+			 * `after_anchor` inserts, `"cut"` becomes a clipboard cut plus
+			 * per-line deletes, and `"paste_after"` becomes a paste after the
+			 * resolved block. No mode denotes a block replacement.
 			 */
 			kind: "block";
 			anchor: Anchor;
 			payloads: string[];
-			mode?: "insert_after";
+			mode?: "insert_after" | "cut" | "paste_after";
 			lineNum: number;
 			index: number;
 	  };
@@ -73,10 +98,9 @@ export interface ApplyResult {
 	/** Diagnostic warnings collected by the parser, patcher, or recovery. */
 	warnings?: string[];
 	/**
-	 * Resolved spans for each `replace_block`/`delete_block` op in this apply,
-	 * in patch order. Present only when the apply matched the tagged content
-	 * (the common no-drift path), so the line numbers line up with what the
-	 * caller read. Absent when there were no block ops.
+	 * Resolved spans for each block op in this apply, in patch order. Present
+	 * only when the apply matched the tagged content, so the line numbers match
+	 * what the caller read. Absent when there were no block ops.
 	 */
 	blockResolutions?: BlockResolution[];
 }
@@ -124,9 +148,7 @@ export interface CompactDiffOptions {
 	maxUnchangedRun?: number;
 }
 
-/**
- * Resolved 1-indexed inclusive line span of a `replace_block N:` target.
- */
+/** Resolved 1-indexed inclusive line span of a block target. */
 export interface BlockSpan {
 	/** First line of the block (1-indexed, inclusive). */
 	start: number;
@@ -135,11 +157,9 @@ export interface BlockSpan {
 }
 
 /**
- * One `replace_block N:` / `delete_block N` / `insert_after_block N:` anchor
- * resolved to its concrete line span. Surfaced on {@link ApplyResult} so the
- * host can echo "block N → lines start.=end" and let the model catch a wrong
- * opener — e.g. a decorator or doc-comment that sits in a separate node
- * outside the resolved block.
+ * One block-op anchor resolved to its concrete line span. Surfaced on
+ * {@link ApplyResult} so the host can echo the resolved range and let the
+ * model catch an anchor on the wrong opener.
  */
 export interface BlockResolution {
 	/** The 1-indexed line the block op was anchored on (the `N`). */
@@ -149,10 +169,10 @@ export interface BlockResolution {
 	/** Last line of the resolved span (1-indexed, inclusive). */
 	end: number;
 	/** Which block op produced this resolution. */
-	op: "replace" | "delete" | "insert_after";
+	op: "replace" | "insert_after" | "cut" | "paste_after";
 }
 
-/** Request handed to a {@link BlockResolver} to resolve one `replace_block N:` anchor. */
+/** Request handed to a {@link BlockResolver} to resolve one block-op anchor. */
 export interface BlockResolverRequest {
 	/** Target file path (used to infer language by extension). */
 	path: string;
@@ -163,10 +183,20 @@ export interface BlockResolverRequest {
 }
 
 /**
- * Resolves a `replace_block N:` anchor to the line span of the syntactic block
- * that begins on line N. Returns `null` when no block can be resolved
- * (unrecognized language, blank/out-of-range line, no node begins there, or the
- * resolved subtree has a syntax error). Pure seam: the hashline core declares
- * the contract; the host injects a tree-sitter-backed implementation.
+ * Resolves a block-op anchor to the line span of the syntactic block beginning
+ * on that line. Returns `null` for an unsupported language, invalid line, absent
+ * opener, or syntax error. The host injects the tree-sitter-backed implementation.
  */
 export type BlockResolver = (request: BlockResolverRequest) => BlockSpan | null;
+
+/**
+ * Mutable clipboard register threaded through one patch application. Filled
+ * by `CUT` edits and read by `PASTE` edits in patch source order, across
+ * sections, so content can move between files. Create one per batch (`{}`)
+ * and hand it to every {@link Patcher.prepare} / `applyTo` call in that batch;
+ * callers that omit it get a private per-call register.
+ */
+export interface Clipboard {
+	/** Lines captured by the most recent `CUT`, or unset. */
+	lines?: readonly string[];
+}