pi-paster 0.1.0

package/dist/index.mjs

@@ -0,0 +1,634 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, statSync, unlinkSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, isAbsolute, join, resolve } from "node:path";
+import { Image, getCellDimensions, getImageDimensions, truncateToWidth } from "@earendil-works/pi-tui";
+import { CustomEditor } from "@earendil-works/pi-coding-agent";
+//#region src/types.ts
+const EXTENSION_NAME = "paster";
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+//#endregion
+//#region src/image-utils.ts
+function detectImageMimeType(bytes) {
+	if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) return "image/png";
+	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+	if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) return "image/gif";
+	if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
+}
+function resolveImagePath(input, cwd) {
+	if (input === "~") return homedir();
+	if (input.startsWith("~/")) return resolve(homedir(), input.slice(2));
+	if (isAbsolute(input)) return input;
+	return resolve(cwd, input);
+}
+function shellUnescape(input) {
+	let result = "";
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+		if (char === "\\" && i + 1 < input.length) result += input[++i];
+		else result += char;
+	}
+	return result;
+}
+function isPathLike(value) {
+	return value.startsWith("/") || value.startsWith("~/") || value === "~" || value.startsWith("./") || value.startsWith("../");
+}
+function tokenizePathLikeText(text) {
+	const tokens = [];
+	let index = 0;
+	while (index < text.length) {
+		const char = text[index];
+		if (/\s/.test(char)) {
+			index++;
+			continue;
+		}
+		const start = index;
+		if (char === "'" || char === "\"") {
+			const quote = char;
+			index++;
+			let value = "";
+			let closed = false;
+			while (index < text.length) {
+				const current = text[index];
+				if (current === "\\" && quote === "\"" && index + 1 < text.length) {
+					value += text[index + 1];
+					index += 2;
+					continue;
+				}
+				if (current === quote) {
+					index++;
+					closed = true;
+					break;
+				}
+				value += current;
+				index++;
+			}
+			if (closed && isPathLike(value)) tokens.push({
+				raw: text.slice(start, index),
+				value,
+				start,
+				end: index
+			});
+			continue;
+		}
+		let rawValue = "";
+		while (index < text.length) {
+			const current = text[index];
+			if (/\s/.test(current)) break;
+			if (current === "\\" && index + 1 < text.length) {
+				rawValue += current + text[index + 1];
+				index += 2;
+				continue;
+			}
+			rawValue += current;
+			index++;
+		}
+		const value = shellUnescape(rawValue);
+		if (isPathLike(value)) tokens.push({
+			raw: rawValue,
+			value,
+			start,
+			end: index
+		});
+	}
+	return tokens;
+}
+function dimensionsForImage(data, mimeType) {
+	return getImageDimensions(data, mimeType) ?? void 0;
+}
+function loadImageFromPath(inputPath, cwd, maxBytes = MAX_IMAGE_BYTES) {
+	const path = resolveImagePath(inputPath, cwd);
+	try {
+		if (!existsSync(path)) return {
+			ok: false,
+			reason: "missing",
+			path
+		};
+		const stat = statSync(path);
+		if (!stat.isFile()) return {
+			ok: false,
+			reason: "not-file",
+			path
+		};
+		if (stat.size > maxBytes) return {
+			ok: false,
+			reason: "too-large",
+			path
+		};
+		const data = readFileSync(path);
+		const mimeType = detectImageMimeType(data);
+		if (!mimeType) return {
+			ok: false,
+			reason: "unsupported",
+			path
+		};
+		const base64Data = data.toString("base64");
+		return {
+			ok: true,
+			image: {
+				originalPath: path,
+				mimeType,
+				data: base64Data,
+				dimensions: dimensionsForImage(base64Data, mimeType)
+			}
+		};
+	} catch {
+		return {
+			ok: false,
+			reason: "read-error",
+			path
+		};
+	}
+}
+function replaceImagePathsInText(text, options) {
+	const tokens = tokenizePathLikeText(text);
+	if (tokens.length === 0) return {
+		text,
+		replaced: 0,
+		accepted: []
+	};
+	let output = "";
+	let cursor = 0;
+	let replaced = 0;
+	const accepted = [];
+	const loadImage = options.loadImage ?? loadImageFromPath;
+	for (const token of tokens) {
+		const result = loadImage(token.value, options.cwd);
+		if (!result.ok) {
+			options.onReject?.(result);
+			continue;
+		}
+		const attachment = options.store.add(result.image);
+		accepted.push(attachment);
+		output += text.slice(cursor, token.start) + attachment.placeholder;
+		cursor = token.end;
+		replaced++;
+	}
+	if (replaced === 0) return {
+		text,
+		replaced: 0,
+		accepted: []
+	};
+	output += text.slice(cursor);
+	return {
+		text: output,
+		replaced,
+		accepted
+	};
+}
+function imagesForText(store, text, existing = []) {
+	return [...existing, ...store.matchingPlaceholders(text).map((attachment) => ({
+		type: "image",
+		mimeType: attachment.mimeType,
+		data: attachment.data
+	}))];
+}
+//#endregion
+//#region src/clipboard.ts
+function readClipboardImage(maxBytes = MAX_IMAGE_BYTES) {
+	if (process.platform !== "darwin") return {
+		ok: false,
+		reason: "unsupported-platform"
+	};
+	return readMacOSClipboardImage(maxBytes);
+}
+function readMacOSClipboardImage(maxBytes) {
+	for (const attempt of [{
+		appleScriptClass: "PNGf",
+		extension: "png"
+	}, {
+		appleScriptClass: "JPEG",
+		extension: "jpg"
+	}]) {
+		const tmpFile = join(tmpdir(), `paster-clipboard-${randomUUID()}.${attempt.extension}`);
+		try {
+			if (spawnSync("osascript", [
+				"-e",
+				`set imageData to the clipboard as «class ${attempt.appleScriptClass}»`,
+				"-e",
+				`set outputFile to open for access POSIX file ${JSON.stringify(tmpFile)} with write permission`,
+				"-e",
+				"set eof of outputFile to 0",
+				"-e",
+				"write imageData to outputFile",
+				"-e",
+				"close access outputFile"
+			], {
+				timeout: 3e3,
+				stdio: "ignore"
+			}).status !== 0) continue;
+			const bytes = readFileSync(tmpFile);
+			if (bytes.length === 0) continue;
+			if (bytes.length > maxBytes) return {
+				ok: false,
+				reason: "too-large"
+			};
+			const mimeType = detectImageMimeType(bytes);
+			if (!mimeType) continue;
+			const data = bytes.toString("base64");
+			return {
+				ok: true,
+				image: {
+					originalPath: `clipboard.${attempt.extension}`,
+					mimeType,
+					data,
+					dimensions: dimensionsForImage(data, mimeType)
+				}
+			};
+		} catch {
+			return {
+				ok: false,
+				reason: "read-error"
+			};
+		} finally {
+			try {
+				unlinkSync(tmpFile);
+			} catch {}
+		}
+	}
+	return {
+		ok: false,
+		reason: "empty"
+	};
+}
+//#endregion
+//#region src/config.ts
+const DEFAULT_PASTER_CONFIG = { customEditor: {
+	enabled: true,
+	showImagePreview: true,
+	deletePlaceholderAsBlock: true
+} };
+function resolvePasterConfig(config = {}) {
+	return { customEditor: {
+		enabled: config.customEditor?.enabled ?? DEFAULT_PASTER_CONFIG.customEditor.enabled,
+		showImagePreview: config.customEditor?.showImagePreview ?? DEFAULT_PASTER_CONFIG.customEditor.showImagePreview,
+		deletePlaceholderAsBlock: config.customEditor?.deletePlaceholderAsBlock ?? DEFAULT_PASTER_CONFIG.customEditor.deletePlaceholderAsBlock
+	} };
+}
+//#endregion
+//#region src/editor.ts
+const PASTE_START = "\x1B[200~";
+const PASTE_END = "\x1B[201~";
+const PLACEHOLDER_REGEX = /\[#image \d+\]/g;
+function findPlaceholderAtCursor(store, lines, cursor, mode) {
+	const line = lines[cursor.line] ?? "";
+	for (const match of line.matchAll(PLACEHOLDER_REGEX)) {
+		const placeholder = match[0];
+		const start = match.index;
+		const end = start + placeholder.length;
+		const attachment = store.get(placeholder);
+		if (!attachment) continue;
+		if (mode === "hover" && cursor.col >= start && cursor.col < end) return {
+			attachment,
+			line: cursor.line,
+			start,
+			end
+		};
+		if (mode === "backspace" && cursor.col > start && cursor.col <= end) return {
+			attachment,
+			line: cursor.line,
+			start,
+			end
+		};
+		if (mode === "delete" && cursor.col >= start && cursor.col < end) return {
+			attachment,
+			line: cursor.line,
+			start,
+			end
+		};
+	}
+}
+var PasterEditor = class extends CustomEditor {
+	pasterPasteBuffer;
+	activePreviewPlaceholder;
+	constructor(tui, theme, pasterKeybindings, pasterOptions) {
+		super(tui, theme, pasterKeybindings);
+		this.pasterKeybindings = pasterKeybindings;
+		this.pasterOptions = pasterOptions;
+		this.onPasteImage = () => {
+			this.handlePasteClipboardImage();
+		};
+	}
+	insertTextAtCursor(text) {
+		const transformed = this.transform(text);
+		super.insertTextAtCursor(transformed.replaced > 0 ? transformed.text : text);
+		this.updateCursorPreview();
+	}
+	handleInput(data) {
+		if (this.handleBracketedPaste(data)) return;
+		if (this.pasterOptions.deletePlaceholderAsBlock && this.handleAtomicPlaceholderDelete(data)) return;
+		super.handleInput(data);
+		this.updateCursorPreview();
+	}
+	clearCursorPreview() {
+		this.activePreviewPlaceholder = void 0;
+		this.pasterOptions.setCursorPreview(void 0);
+	}
+	async handlePasteClipboardImage() {
+		const attachment = await this.pasterOptions.pasteClipboardImage?.();
+		if (!attachment) return;
+		super.insertTextAtCursor(attachment.placeholder);
+		this.updateCursorPreview();
+		this.tui.requestRender();
+	}
+	handleBracketedPaste(data) {
+		let prefix = "";
+		const original = data;
+		const wasBuffered = this.pasterPasteBuffer !== void 0;
+		if (this.pasterPasteBuffer === void 0) {
+			const start = data.indexOf(PASTE_START);
+			if (start === -1) return false;
+			prefix = data.slice(0, start);
+			this.pasterPasteBuffer = data.slice(start + 6);
+			if (!this.pasterPasteBuffer.includes("\x1B[201~")) {
+				if (prefix) super.handleInput(prefix);
+				return true;
+			}
+		} else {
+			this.pasterPasteBuffer += data;
+			if (!this.pasterPasteBuffer.includes("\x1B[201~")) return true;
+		}
+		const end = this.pasterPasteBuffer.indexOf(PASTE_END);
+		const content = this.pasterPasteBuffer.slice(0, end);
+		const remaining = this.pasterPasteBuffer.slice(end + 6);
+		this.pasterPasteBuffer = void 0;
+		const transformed = this.transform(content);
+		if (transformed.replaced === 0) {
+			super.handleInput(wasBuffered ? `${PASTE_START}${content}${PASTE_END}${remaining}` : original);
+			this.updateCursorPreview();
+			return true;
+		}
+		if (prefix) super.handleInput(prefix);
+		super.insertTextAtCursor(transformed.text);
+		if (remaining) super.handleInput(remaining);
+		this.updateCursorPreview();
+		return true;
+	}
+	handleAtomicPlaceholderDelete(data) {
+		const isBackspace = this.pasterKeybindings.matches(data, "tui.editor.deleteCharBackward");
+		const isDelete = this.pasterKeybindings.matches(data, "tui.editor.deleteCharForward");
+		if (!isBackspace && !isDelete) return false;
+		if (isDelete && this.getText().length === 0) return false;
+		const target = findPlaceholderAtCursor(this.pasterOptions.store, this.getLines(), this.getCursor(), isBackspace ? "backspace" : "delete");
+		if (!target) return false;
+		this.deleteLineRange(target.line, target.start, target.end);
+		this.updateCursorPreview();
+		return true;
+	}
+	deleteLineRange(lineIndex, start, end) {
+		const editor = this;
+		editor.pushUndoSnapshot?.();
+		const line = editor.state.lines[lineIndex] ?? "";
+		editor.state.lines[lineIndex] = line.slice(0, start) + line.slice(end);
+		editor.state.cursorLine = lineIndex;
+		if (editor.setCursorCol) editor.setCursorCol(start);
+		else editor.state.cursorCol = start;
+		editor.lastAction = null;
+		editor.historyIndex = -1;
+		this.onChange?.(this.getText());
+		this.tui.requestRender();
+	}
+	transform(text) {
+		return replaceImagePathsInText(text, {
+			cwd: this.pasterOptions.cwd,
+			store: this.pasterOptions.store,
+			onReject: (result) => {
+				if (result.reason === "too-large") this.pasterOptions.notify(`paster: image is over 10 MB and was not attached: ${result.path}`);
+			}
+		});
+	}
+	updateCursorPreview() {
+		const target = findPlaceholderAtCursor(this.pasterOptions.store, this.getLines(), this.getCursor(), "hover");
+		const nextPlaceholder = target?.attachment.placeholder;
+		if (nextPlaceholder === this.activePreviewPlaceholder) return;
+		this.activePreviewPlaceholder = nextPlaceholder;
+		this.pasterOptions.setCursorPreview(target?.attachment);
+	}
+};
+//#endregion
+//#region src/preview.ts
+var ImagePreviewMessage = class {
+	images;
+	constructor(attachments, theme) {
+		this.attachments = attachments;
+		this.theme = theme;
+		this.images = attachments.map((attachment) => new Image(attachment.data, attachment.mimeType, theme, {
+			maxWidthCells: 60,
+			maxHeightCells: 16,
+			filename: attachment.placeholder
+		}));
+	}
+	render(width) {
+		const lines = [];
+		for (let index = 0; index < this.attachments.length; index++) {
+			lines.push(this.theme.fallbackColor(`Attached ${this.attachments[index].placeholder} (${this.attachments[index].mimeType})`));
+			lines.push(...this.images[index].render(width));
+		}
+		return lines;
+	}
+	invalidate() {
+		for (const image of this.images) image.invalidate();
+	}
+};
+var CursorImagePreviewWidget = class {
+	image;
+	constructor(attachment, theme) {
+		this.attachment = attachment;
+		this.theme = theme;
+		this.image = this.createImage(attachment);
+	}
+	render(width) {
+		const imageWidth = this.constrainedImageWidth(width);
+		this.image = this.createImage(this.attachment, imageWidth);
+		return [this.headerLine(width), ...this.image.render(imageWidth + 2)];
+	}
+	invalidate() {
+		this.image.invalidate();
+	}
+	headerLine(width) {
+		const title = `${this.attachment.placeholder} ${basename(this.attachment.originalPath)}`;
+		return this.theme.title(truncateToWidth(title, Math.max(1, width), ""));
+	}
+	createImage(attachment, maxWidthCells = 60) {
+		return new Image(attachment.data, attachment.mimeType, { fallbackColor: this.theme.accent }, {
+			maxWidthCells,
+			filename: attachment.placeholder
+		}, attachment.dimensions);
+	}
+	constrainedImageWidth(width) {
+		const maxWidth = Math.max(1, Math.min(60, width - 2));
+		const maxRows = 14;
+		const dimensions = this.attachment.dimensions;
+		if (!dimensions || dimensions.widthPx <= 0 || dimensions.heightPx <= 0) return maxWidth;
+		const cell = getCellDimensions();
+		const widthForMaxRows = Math.floor(maxRows * cell.heightPx * dimensions.widthPx / (dimensions.heightPx * cell.widthPx));
+		return Math.max(1, Math.min(maxWidth, widthForMaxRows));
+	}
+};
+//#endregion
+//#region src/store.ts
+var AttachmentStore = class {
+	nextId = 1;
+	attachments = /* @__PURE__ */ new Map();
+	clear() {
+		this.nextId = 1;
+		this.attachments.clear();
+	}
+	list() {
+		return [...this.attachments.values()].sort((a, b) => a.id - b.id);
+	}
+	add(input) {
+		const id = this.nextId++;
+		const attachment = {
+			...input,
+			id,
+			placeholder: `[#image ${id}]`,
+			createdAt: Date.now()
+		};
+		this.attachments.set(attachment.placeholder, attachment);
+		return attachment;
+	}
+	get(placeholder) {
+		return this.attachments.get(placeholder);
+	}
+	matchingPlaceholders(text) {
+		return this.list().map((attachment) => ({
+			attachment,
+			index: text.indexOf(attachment.placeholder)
+		})).filter((match) => match.index >= 0).sort((a, b) => a.index - b.index).map((match) => match.attachment);
+	}
+};
+//#endregion
+//#region src/terminal-input.ts
+function createImagePasteTerminalInputHandler(options) {
+	let pasteBuffer;
+	const transform = (text) => replaceImagePathsInText(text, {
+		cwd: options.cwd,
+		store: options.store,
+		loadImage: options.loadImage,
+		onReject: (result) => {
+			if (result.reason === "too-large") options.notify?.(`paster: image is over 10 MB and was not attached: ${result.path}`);
+		}
+	});
+	return (data) => {
+		let prefix = "";
+		const wasBuffered = pasteBuffer !== void 0;
+		if (pasteBuffer === void 0) {
+			const start = data.indexOf(PASTE_START);
+			if (start === -1) return void 0;
+			prefix = data.slice(0, start);
+			pasteBuffer = data.slice(start + 6);
+			if (!pasteBuffer.includes("\x1B[201~")) return prefix ? { data: prefix } : { consume: true };
+		} else {
+			pasteBuffer += data;
+			if (!pasteBuffer.includes("\x1B[201~")) return { consume: true };
+		}
+		const end = pasteBuffer.indexOf(PASTE_END);
+		const content = pasteBuffer.slice(0, end);
+		const remaining = pasteBuffer.slice(end + 6);
+		pasteBuffer = void 0;
+		const transformed = transform(content);
+		if (transformed.replaced === 0) return wasBuffered ? { data: `${PASTE_START}${content}${PASTE_END}${remaining}` } : void 0;
+		options.onAccept?.(transformed.accepted);
+		return { data: `${prefix}${transformed.text}${remaining}` };
+	};
+}
+//#endregion
+//#region src/index.ts
+function createPaster(config = {}) {
+	return (pi) => paster(pi, config);
+}
+function paster(pi, config = {}) {
+	const resolvedConfig = resolvePasterConfig(config);
+	const store = new AttachmentStore();
+	let pendingPreview = [];
+	let activeEditor;
+	let unsubscribeTerminalInput;
+	pi.registerMessageRenderer("paster-preview", (message, _options, theme) => {
+		const placeholders = message.details?.placeholders ?? [];
+		const attachments = store.list().filter((attachment) => placeholders.includes(attachment.placeholder));
+		if (attachments.length === 0) return void 0;
+		return new ImagePreviewMessage(attachments, { fallbackColor: (text) => theme.fg("muted", text) });
+	});
+	pi.on("session_start", (_event, ctx) => {
+		store.clear();
+		pendingPreview = [];
+		if (!ctx.hasUI) return;
+		unsubscribeTerminalInput?.();
+		unsubscribeTerminalInput = void 0;
+		activeEditor?.clearCursorPreview();
+		activeEditor = void 0;
+		ctx.ui.setWidget("paster-cursor-preview", void 0, { placement: "aboveEditor" });
+		if (!resolvedConfig.customEditor.enabled) {
+			unsubscribeTerminalInput = ctx.ui.onTerminalInput(createImagePasteTerminalInputHandler({
+				cwd: ctx.cwd,
+				store,
+				notify: (message) => ctx.ui.notify(message, "warning")
+			}));
+			return;
+		}
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => {
+			activeEditor = new PasterEditor(tui, theme, keybindings, {
+				cwd: ctx.cwd,
+				store,
+				notify: (message) => ctx.ui.notify(message, "warning"),
+				deletePlaceholderAsBlock: resolvedConfig.customEditor.deletePlaceholderAsBlock,
+				pasteClipboardImage: () => {
+					const result = readClipboardImage();
+					if (!result.ok) {
+						if (result.reason !== "empty" && result.reason !== "unsupported-platform") ctx.ui.notify("paster: clipboard image could not be attached", "warning");
+						return;
+					}
+					return store.add(result.image);
+				},
+				setCursorPreview: (attachment) => {
+					if (!resolvedConfig.customEditor.showImagePreview) return;
+					ctx.ui.setWidget("paster-cursor-preview", attachment ? (_tui, widgetTheme) => new CursorImagePreviewWidget(attachment, {
+						title: (text) => widgetTheme.fg("accent", text),
+						muted: (text) => widgetTheme.fg("muted", text),
+						accent: (text) => widgetTheme.fg("accent", text)
+					}) : void 0, { placement: "aboveEditor" });
+				}
+			});
+			return activeEditor;
+		});
+	});
+	pi.on("session_shutdown", (_event, ctx) => {
+		pendingPreview = [];
+		if (ctx.hasUI) {
+			unsubscribeTerminalInput?.();
+			unsubscribeTerminalInput = void 0;
+			activeEditor?.clearCursorPreview();
+			activeEditor = void 0;
+			ctx.ui.setWidget("paster-cursor-preview", void 0, { placement: "aboveEditor" });
+			ctx.ui.setEditorComponent(void 0);
+		}
+		store.clear();
+	});
+	pi.on("input", (event, ctx) => {
+		if (event.source === "extension") return { action: "continue" };
+		if (ctx.hasUI) activeEditor?.clearCursorPreview();
+		const attachments = store.matchingPlaceholders(event.text);
+		if (attachments.length === 0) return { action: "continue" };
+		pendingPreview = attachments;
+		return {
+			action: "transform",
+			text: event.text,
+			images: imagesForText(store, event.text, event.images)
+		};
+	});
+	pi.on("before_agent_start", () => {
+		if (pendingPreview.length === 0) return;
+		const placeholders = pendingPreview.map((attachment) => attachment.placeholder);
+		pendingPreview = [];
+		return { message: {
+			customType: "paster-preview",
+			content: "",
+			display: true,
+			details: { placeholders }
+		} };
+	});
+}
+//#endregion
+export { AttachmentStore, CursorImagePreviewWidget, DEFAULT_PASTER_CONFIG, EXTENSION_NAME, ImagePreviewMessage, MAX_IMAGE_BYTES, PASTE_END, PASTE_START, PasterEditor, createImagePasteTerminalInputHandler, createPaster, paster as default, detectImageMimeType, dimensionsForImage, imagesForText, loadImageFromPath, readClipboardImage, replaceImagePathsInText, resolveImagePath, resolvePasterConfig, shellUnescape, tokenizePathLikeText };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "pi-paster",
+  "version": "0.1.0",
+  "description": "Pi extension that turns pasted image paths into first-class image attachments.",
+  "keywords": [
+    "image-attachments",
+    "pi-extension",
+    "pi-package"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src",
+    "docs",
+    "spec.md",
+    "README.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "prepare": "vp config",
+    "prepublishOnly": "vp run build"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0",
+    "@types/node": "^25.8.0",
+    "@typescript/native-preview": "7.0.0-dev.20260515.1",
+    "typescript": "^6.0.3",
+    "vite-plus": "catalog:"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "packageManager": "pnpm@11.1.2",
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "image": "https://unpkg.com/pi-paster@0.1.0/docs/preview.png"
+  }
+}