pi-better-paste-markers 0.3.0 → 0.3.1

package/README.md

@@ -21,6 +21,7 @@ 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.
 
@@ -42,3 +43,5 @@ The extension replaces the main editor on `session_start` via `ctx.ui.setEditorC
 - `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

@@ -72,7 +72,68 @@ interface ThemeBackgroundProvider {
 /** 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(
@@ -82,9 +143,6 @@ export default function betterPasteMarkers(pi: ExtensionAPI): void {
 }
 
 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;
 	/** Resolves the current app theme so the block background follows theme switches. */
 	private getAppTheme?: () => ThemeBackgroundProvider;
@@ -111,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;
@@ -151,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}]`;
@@ -224,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,
@@ -233,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`,
@@ -272,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;
@@ -295,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)
@@ -305,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());
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-better-paste-markers",
-	"version": "0.3.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",