pi-better-paste-markers 0.2.0 → 0.3.1

package/README.md

@@ -21,7 +21,9 @@ Pastes over 10 lines or 1000 chars render as a three-line block:
 - Everywhere else (drafts, autocomplete, undo) the block collapses back to the standard single-line `[paste #N ...]` marker.
 - The block deletes as one unit: a single Backspace/Delete (or Ctrl+W/U/K) that touches it removes the whole block, like the built-in `[paste #N ...]` marker. Text before and after the block on the same line is kept.
 - Undo restores the whole block and it keeps expanding/submitting correctly.
+- Survives `/new`, `/resume` and fork: pi rebuilds the editor component during a session switch, so blocks are rebuilt from the shared registry (and from paste content captured out of the base editor) instead of degrading to a literal `[paste #N ...]` marker.
 - The input is prefixed with a gray `❯` prompt (the one pi-powerline-footer draws on the default editor is lost when a custom editor component replaces it).
+- The block is painted with the theme's `userMessageBg` background (follows light/dark and theme switches); only the block text is filled, the padding after it stays normal.
 
 ## Install
 
@@ -38,6 +40,8 @@ The extension replaces the main editor on `session_start` via `ctx.ui.setEditorC
 - `getText()` — collapses blocks back to canonical `[paste #N ...]` markers (drafts, autocomplete snapshots, undo).
 - `expandPasteMarkers()` — plain Enter submits through the base editor's private `submitValue()`, which expands paste markers with this method; shadowing it makes Enter submit the original pasted content instead of the three-line preview.
 - `getExpandedText()` — used by the follow-up (Alt+Enter), external-editor and extension-API (`getEditorText`) paths.
-- `render()` — prefixes the input with a gray `❯` and keeps the other content lines indented, matching the chrome pi-powerline-footer adds to the default editor.
+- `render()` — prefixes the input with a gray `❯`, keeps the other content lines indented, and paints the paste-block text with `ctx.ui.theme.bg("userMessageBg", …)` (re-applied after the cursor's reset so the highlight survives the cursor).
 
 Paste records are kept after a block is deleted so that undoing the deletion restores a block that still collapses and expands correctly.
+
+The registry is shared across editor instances: during `/new`, `/resume` or a fork, pi tears the custom editor down (`resetExtensionUI()`), rebuilds it, and carries the draft over with `setText(editor.getText())` — i.e. collapsed markers. Blocks are therefore rebuilt on `setText`, from the shared registry or from content captured out of the base editor (whose `pastes` map pi clears on the same path).

package/index.ts

@@ -64,23 +64,98 @@ interface PasteBlock {
 /** Which side of the block a deletion key bites from. */
 type DeleteDirection = "backward" | "forward" | "line";
 
+/** Minimal slice of pi's app theme we need to paint the block background. */
+interface ThemeBackgroundProvider {
+	bg(color: string, text: string): string;
+}
+
+/** Theme key used as the paste-block background (also used for user messages). */
+const BLOCK_BG = "userMessageBg";
+
+/**
+ * Paste content captured from the base editor right before it drops its
+ * registry, keyed by its canonical single-line marker.
+ *
+ * Session switches (`/new`, `/resume`, fork) tear our editor down
+ * (`resetExtensionUI()` -> `setCustomEditorComponent(undefined)`), so a paste
+ * made while the session is rebuilt lands in the base `CustomEditor`. pi then
+ * rebuilds our editor with `setText(editor.getText())` — the collapsed marker —
+ * and the base `setText` clears its `pastes` map. The content would be lost and
+ * Enter would submit a literal `[paste #N ...]`. Capturing it in `getText()`
+ * (which pi calls just before the rebuild) keeps it recoverable.
+ */
+const recoveredPastes = new Map<string, PasteRecord>();
+
+/**
+ * Block registry shared by every editor instance of this session.
+ *
+ * pi rebuilds the editor component more than once around a session switch and
+ * carries the draft across with `setText(editor.getText())`, i.e. collapsed
+ * markers. Keeping the registry per instance lost the content on the second
+ * rebuild (the new instance saw no records and submitted the marker verbatim),
+ * so it lives here instead.
+ */
+const sharedPastes = new Map<number, PasteRecord>();
+let sharedPasteCounter = 0;
+
+let baseEditorCaptureInstalled = false;
+
+/** Snapshot paste content of a base editor before its registry gets cleared. */
+function installBaseEditorCapture(): void {
+	if (baseEditorCaptureInstalled) return;
+	baseEditorCaptureInstalled = true;
+
+	const proto = CustomEditor.prototype as unknown as { getText(): string };
+	const originalGetText = proto.getText;
+
+	proto.getText = function (this: unknown): string {
+		const text = originalGetText.call(this);
+		const registry = (this as { pastes?: Map<number, string> }).pastes;
+		if (!registry || registry.size === 0 || !text.includes("[paste #")) return text;
+
+		for (const [id, content] of registry) {
+			const lines = content.split("\n");
+			const marker =
+				lines.length > 10
+					? `[paste #${id} +${lines.length} lines]`
+					: `[paste #${id} ${content.length} chars]`;
+			if (!text.includes(marker) || recoveredPastes.has(marker)) continue;
+			recoveredPastes.set(marker, {
+				content,
+				lines: lines.length,
+				chars: content.length,
+				first: lines[0] ?? "",
+				last: lines[lines.length - 1] ?? "",
+			});
+		}
+		return text;
+	};
+}
+
 export default function betterPasteMarkers(pi: ExtensionAPI): void {
+	installBaseEditorCapture();
 	pi.on("session_start", (_event, ctx) => {
+		const getAppTheme = () => ctx.ui.theme as unknown as ThemeBackgroundProvider;
 		ctx.ui.setEditorComponent(
-			(tui, theme, keybindings) => new BetterPasteEditor(tui, theme, keybindings),
+			(tui, theme, keybindings) => new BetterPasteEditor(tui, theme, keybindings, getAppTheme),
 		);
 	});
 }
 
 export class BetterPasteEditor extends CustomEditor {
-	/** id -> record; ids come from our own counter, so they never collide. */
-	private pasteRecords = new Map<number, PasteRecord>();
-	private ownPasteCounter = 0;
 	private editorKeybindings: KeybindingsManager;
-
-	constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
+	/** Resolves the current app theme so the block background follows theme switches. */
+	private getAppTheme?: () => ThemeBackgroundProvider;
+
+	constructor(
+		tui: TUI,
+		theme: EditorTheme,
+		keybindings: KeybindingsManager,
+		getAppTheme?: () => ThemeBackgroundProvider,
+	) {
 		super(tui, theme, keybindings);
 		this.editorKeybindings = keybindings;
+		this.getAppTheme = getAppTheme;
 	}
 
 	/**
@@ -94,7 +169,7 @@ export class BetterPasteEditor extends CustomEditor {
 	}
 
 	private tryDeleteBlock(data: string): boolean {
-		if (this.pasteRecords.size === 0 || this.isShowingAutocomplete()) return false;
+		if (sharedPastes.size === 0 || this.isShowingAutocomplete()) return false;
 
 		const kb = this.editorKeybindings;
 		let direction: DeleteDirection | null = null;
@@ -134,7 +209,7 @@ export class BetterPasteEditor extends CustomEditor {
 			const middle = MIDDLE_RE.exec(lines[i + 1] ?? "");
 			if (!middle) continue;
 			const id = Number(middle[1]);
-			const record = this.pasteRecords.get(id);
+			const record = sharedPastes.get(id);
 			if (!record) continue;
 			const opening = `[${record.first}`;
 			const closing = `${record.last}]`;
@@ -207,8 +282,8 @@ export class BetterPasteEditor extends CustomEditor {
 		this.lastAction = null;
 		this.pushUndoSnapshot();
 
-		const id = ++this.ownPasteCounter;
-		this.pasteRecords.set(id, {
+		const id = ++sharedPasteCounter;
+		sharedPastes.set(id, {
 			content: filteredText,
 			lines: pastedLines.length,
 			chars: filteredText.length,
@@ -216,7 +291,7 @@ export class BetterPasteEditor extends CustomEditor {
 			last: previewTail(pastedLines[pastedLines.length - 1] ?? ""),
 		});
 
-		const record = this.pasteRecords.get(id)!;
+		const record = sharedPastes.get(id)!;
 		const block = [
 			`[${record.first}`,
 			`paste #${id} ${filteredText.length} chars / ${pastedLines.length} lines`,
@@ -255,7 +330,7 @@ export class BetterPasteEditor extends CustomEditor {
 
 	/** Collapse every intact 3-line block back to its canonical single-line marker. */
 	private collapse(text: string): string {
-		if (this.pasteRecords.size === 0) return text;
+		if (sharedPastes.size === 0) return text;
 		const lines = text.split("\n");
 		const blocks = this.findBlocks(lines);
 		if (blocks.length === 0) return text;
@@ -278,7 +353,7 @@ export class BetterPasteEditor extends CustomEditor {
 	/** Replace collapsed canonical markers with their original content. */
 	private expand(text: string): string {
 		let result = text;
-		for (const [id, rec] of this.pasteRecords) {
+		for (const [id, rec] of sharedPastes) {
 			result = result
 				.split(`[paste #${id} ${rec.chars} chars]`)
 				.join(rec.content)
@@ -288,6 +363,53 @@ export class BetterPasteEditor extends CustomEditor {
 		return result;
 	}
 
+	/**
+	 * Rebuild blocks from collapsed markers handed back by pi.
+	 *
+	 * pi rebuilds the editor component around session switches with
+	 * `setText(editor.getText())`, i.e. canonical inline markers. Without this
+	 * the block would return as literal text that submits verbatim. Content
+	 * comes from the shared registry (a previous instance's paste) or from
+	 * `recoveredPastes` (a paste that landed in the base editor during the
+	 * switch).
+	 */
+	override setText(text: string): void {
+		super.setText(this.restoreBlocks(text));
+		recoveredPastes.clear();
+	}
+
+	private restoreBlocks(text: string): string {
+		if (!text.includes("[paste #")) return text;
+
+		let result = text;
+		for (const [id, record] of sharedPastes) {
+			result = this.substituteMarker(result, id, record);
+		}
+		for (const [marker, record] of recoveredPastes) {
+			const id = Number(/\[paste #(\d+)/.exec(marker)?.[1]);
+			if (!Number.isFinite(id)) continue;
+			sharedPastes.set(id, record);
+			sharedPasteCounter = Math.max(sharedPasteCounter, id);
+			result = this.substituteMarker(result, id, record);
+		}
+		return result;
+	}
+
+	/** Replace one paste's canonical marker(s) with its three-line block. */
+	private substituteMarker(text: string, id: number, record: PasteRecord): string {
+		const linesMarker = `[paste #${id} +${record.lines} lines]`;
+		const charsMarker = `[paste #${id} ${record.chars} chars]`;
+		const marker = text.includes(linesMarker) ? linesMarker : text.includes(charsMarker) ? charsMarker : null;
+		if (!marker) return text;
+
+		const first = previewHead(record.first);
+		const last = previewTail(record.last);
+		sharedPastes.set(id, { ...record, first, last });
+		return text
+			.split(marker)
+			.join([`[${first}`, `paste #${id} ${record.chars} chars / ${record.lines} lines`, `${last}]`].join("\n"));
+	}
+
 	override getText(): string {
 		return this.collapse(super.getText());
 	}
@@ -346,8 +468,58 @@ export class BetterPasteEditor extends CustomEditor {
 		for (let i = bottomBorderIndex + 1; i < lines.length; i++) {
 			result.push(lines[i] ?? "");
 		}
+		this.paintBlocks(result, bottomBorderIndex);
 		return result;
 	}
+
+	/** Block text portions that should carry the background, longest first. */
+	private blockSpans(): string[] {
+		const lines = this.state.lines;
+		const spans: string[] = [];
+		for (const block of this.findBlocks()) {
+			const first = lines[block.startLine] ?? "";
+			const middle = lines[block.startLine + 1] ?? "";
+			const last = lines[block.endLine] ?? "";
+			if (block.endLine === block.startLine + 2) {
+				spans.push(first.slice(block.startCol), middle, last.slice(0, block.endCol));
+			} else {
+				for (let line = block.startLine; line <= block.endLine; line++) spans.push(lines[line] ?? "");
+			}
+		}
+		return spans.filter((span) => span.length > 0).sort((a, b) => b.length - a.length);
+	}
+
+	/** ANSI prefix for the block background, or null when the theme lacks it. */
+	private blockBackground(): string | null {
+		const theme = this.getAppTheme?.();
+		if (!theme) return null;
+		try {
+			const wrapped = theme.bg(BLOCK_BG, "");
+			const reset = "\x1b[49m";
+			const ansi = wrapped.endsWith(reset) ? wrapped.slice(0, -reset.length) : wrapped;
+			return ansi || null;
+		} catch {
+			return null;
+		}
+	}
+
+	/** Paint only the block text (not the padding) with the theme background. */
+	private paintBlocks(rows: string[], bottomBorderIndex: number): void {
+		const spans = this.blockSpans();
+		if (spans.length === 0) return;
+		const background = this.blockBackground();
+		if (!background) return;
+		for (let i = 1; i < bottomBorderIndex; i++) {
+			const row = rows[i];
+			if (row === undefined) continue;
+			for (const span of spans) {
+				if (stripAnsi(row).includes(span)) {
+					rows[i] = paintSpan(row, span, background);
+					break;
+				}
+			}
+		}
+	}
 }
 
 /** First-line preview: keep the head, add `...` only when something was cut. */
@@ -359,3 +531,65 @@ function previewHead(text: string): string {
 function previewTail(text: string): string {
 	return text.length <= PREVIEW_MAX_CHARS ? text : `...${text.slice(text.length - (PREVIEW_MAX_CHARS - 3))}`;
 }
+
+/** Length of the escape/APC sequence starting at `index`, or 0 for plain text. */
+function ansiSequenceLength(text: string, index: number): number {
+	if (text[index] !== "\x1b") return 0;
+	const next = text[index + 1];
+	if (next === "[") {
+		for (let i = index + 2; i < text.length; i++) {
+			const code = text.charCodeAt(i);
+			if (code >= 0x40 && code <= 0x7e) return i - index + 1;
+		}
+		return text.length - index;
+	}
+	if (next === "_" || next === "]" || next === "P" || next === "^") {
+		for (let i = index + 2; i < text.length; i++) {
+			if (text[i] === "\x07") return i - index + 1;
+			if (text[i] === "\x1b" && text[i + 1] === "\\") return i - index + 2;
+		}
+		return text.length - index;
+	}
+	return 2;
+}
+
+/** Drop ANSI/APC escape sequences, keeping the visible characters. */
+function stripAnsi(text: string): string {
+	let out = "";
+	for (let i = 0; i < text.length; ) {
+		const esc = ansiSequenceLength(text, i);
+		if (esc > 0) {
+			i += esc;
+			continue;
+		}
+		out += text[i];
+		i++;
+	}
+	return out;
+}
+
+/** Paint only the `span` characters of `row` with `background`, leaving padding untouched. */
+function paintSpan(row: string, span: string, background: string): string {
+	const startPlain = stripAnsi(row).indexOf(span);
+	if (startPlain < 0) return row;
+	const endPlain = startPlain + span.length;
+	let plain = 0;
+	let start = -1;
+	let end = -1;
+	for (let i = 0; i < row.length; ) {
+		const esc = ansiSequenceLength(row, i);
+		if (esc > 0) {
+			i += esc;
+			continue;
+		}
+		if (plain === startPlain) start = i;
+		// `end` sits right after the last span character, so a cursor escape that
+		// follows the text stays outside the painted range.
+		if (plain === endPlain - 1) end = i + 1;
+		plain++;
+		i++;
+	}
+	if (start < 0 || end < 0) return row;
+	const inner = row.slice(start, end).replaceAll("\x1b[0m", `\x1b[0m${background}`);
+	return `${row.slice(0, start)}${background}${inner}\x1b[49m${row.slice(end)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-better-paste-markers",
-	"version": "0.2.0",
+	"version": "0.3.1",
 	"description": "Richer collapsed paste markers for pi: first/last line preview around the canonical paste marker",
 	"type": "module",
 	"license": "MIT",