pi-yank 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# pi-yank
+
+Lightweight `/yank` extension for [pi](https://github.com/badlogic/pi-mono).
+
+`/yank` copies the last assistant response to the clipboard, or lets you choose an individual fenced code block from that response.
+
+## Features
+
+- Copy the last assistant message to the clipboard
+- Detect fenced Markdown code blocks in the last assistant message
+- Use arrow keys + Enter to choose a specific code block
+- Optionally disable the menu for the current session so `/yank` behaves like `/copy`
+- Reuse pi's official clipboard pipeline via `copyToClipboard()` for `/copy`-compatible behavior
+- Zero third-party runtime dependencies
+
+## Installation
+
+### Quick test
+
+Load temporarily without installing:
+
+```bash
+pi --extension /path/to/pi-yank/extensions/yank.ts
+```
+
+### Install as pi package
+
+Globally:
+
+```bash
+pi install /path/to/pi-yank
+```
+
+Project-local:
+
+```bash
+pi install -l /path/to/pi-yank
+```
+
+### Install as a project-local extension file
+
+```bash
+mkdir -p .pi/extensions
+cp /path/to/pi-yank/extensions/yank.ts .pi/extensions/yank.ts
+```
+
+### Install as a global extension file
+
+```bash
+mkdir -p ~/.pi/agent/extensions
+cp /path/to/pi-yank/extensions/yank.ts ~/.pi/agent/extensions/yank.ts
+```
+
+## Usage
+
+Run:
+
+```text
+/yank
+```
+
+Behavior:
+
+- No assistant message yet → shows `No agent messages to copy yet.`
+- Last assistant message has no fenced code blocks → copies the full message
+- Last assistant message has code blocks → opens a selection menu
+- Selecting a code block copies only that code block's content
+- Selecting the session option disables the menu for later `/yank` calls in the current session
+- Pressing `Escape` in the selector cancels without copying
+
+### Code block detection notes
+
+`/yank` uses a line-by-line fenced block parser instead of a simple regex.
+This makes it more robust for LLM output such as:
+
+- a top-level ````markdown` fenced block containing literal nested ` ```js ` examples
+- multiple top-level sibling code blocks
+- `~~~` fenced blocks
+- unterminated fences, which are ignored
+
+Menu previews now include more context when available, for example:
+
+- `1. Full last message (24 lines • 812 chars)`
+- `2. Code block — markdown: # Title (18 lines • 640 chars)`
+- `3. Code block — js: console.log("hi") (1 line • 18 chars)`
+- `4. Always copy full last message in this session`
+
+## Development
+
+Run parser tests:
+
+```bash
+npm run check
+```
+
+## Package structure
+
+This repository follows pi package conventions:
+
+- extension entry: `extensions/yank.ts`
+- `package.json` includes a `pi` manifest
+- pi core package is declared as a `peerDependency`
+
+## License
+
+MIT

package/extensions/yank-core.js

@@ -0,0 +1,159 @@
+/**
+ * @typedef {{ content: string; preview: string; startLine: number; infoString: string }} CodeBlock
+ * @typedef {{ fenceChar: '`' | '~'; fenceLength: number; lines: string[]; startLine: number; infoString: string }} OpenCodeBlock
+ */
+
+/**
+ * Extract top-level fenced code blocks from markdown-like text.
+ *
+ * This is intentionally tolerant of LLM output that contains a large fenced
+ * markdown block which itself includes literal nested fences as examples.
+ * Only fully-closed top-level blocks are returned as yank candidates.
+ *
+ * @param {string} markdown
+ * @returns {CodeBlock[]}
+ */
+export function extractCodeBlocks(markdown) {
+	/** @type {CodeBlock[]} */
+	const blocks = [];
+	/** @type {OpenCodeBlock[]} */
+	const openBlocks = [];
+	const lines = markdown.split(/\r?\n/);
+
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index];
+		const fence = parseFenceLine(line);
+
+		if (!fence) {
+			for (const block of openBlocks) {
+				block.lines.push(line);
+			}
+			continue;
+		}
+
+		if (openBlocks.length === 0) {
+			openBlocks.push({
+				fenceChar: fence.char,
+				fenceLength: fence.length,
+				lines: [],
+				startLine: index,
+				infoString: fence.info,
+			});
+			continue;
+		}
+
+		const currentBlock = openBlocks[openBlocks.length - 1];
+		const closesCurrentBlock =
+			fence.char === currentBlock.fenceChar &&
+			fence.length >= currentBlock.fenceLength &&
+			fence.info.length === 0;
+
+		if (closesCurrentBlock) {
+			for (
+				let parentIndex = 0;
+				parentIndex < openBlocks.length - 1;
+				parentIndex++
+			) {
+				openBlocks[parentIndex].lines.push(line);
+			}
+
+			const finishedBlock = openBlocks.pop();
+			if (finishedBlock && openBlocks.length === 0) {
+				const content = finishedBlock.lines.join("\n");
+				blocks.push({
+					content,
+					preview: "",
+					startLine: finishedBlock.startLine,
+					infoString: finishedBlock.infoString,
+				});
+			}
+			continue;
+		}
+
+		for (const block of openBlocks) {
+			block.lines.push(line);
+		}
+		openBlocks.push({
+			fenceChar: fence.char,
+			fenceLength: fence.length,
+			lines: [],
+			startLine: index,
+			infoString: fence.info,
+		});
+	}
+
+	return blocks
+		.sort((left, right) => left.startLine - right.startLine)
+		.map((block, index) => ({
+			...block,
+			preview: buildCodeBlockPreview(
+				block.content,
+				index + 1,
+				block.infoString,
+			),
+		}));
+}
+
+/**
+ * @param {string} line
+ * @returns {{ char: '`' | '~'; length: number; info: string } | null}
+ */
+export function parseFenceLine(line) {
+	const match = /^[ \t]*(`{3,}|~{3,})([^\n]*)$/.exec(line);
+	if (!match) return null;
+
+	const fence = match[1];
+	const info = match[2]?.trim() ?? "";
+	if (fence[0] === "`" && info.includes("`")) return null;
+
+	const char = fence[0];
+	if (char !== "`" && char !== "~") return null;
+
+	return {
+		char,
+		length: fence.length,
+		info,
+	};
+}
+
+/**
+ * @param {string} content
+ * @param {number} index
+ * @param {string} [infoString]
+ * @returns {string}
+ */
+export function buildCodeBlockPreview(content, index, infoString = "") {
+	const firstNonEmptyLine = content
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.find((line) => line.length > 0);
+
+	const language = getFenceLabel(infoString);
+	if (!firstNonEmptyLine) {
+		return language
+			? `${language}: Code block ${index}`
+			: `Code block ${index}`;
+	}
+
+	const body = truncate(firstNonEmptyLine, 72);
+	return language ? `${language}: ${body}` : body;
+}
+
+/**
+ * @param {string} infoString
+ * @returns {string}
+ */
+export function getFenceLabel(infoString) {
+	const label = infoString.trim().split(/\s+/)[0] ?? "";
+	return label;
+}
+
+/**
+ * @param {string} value
+ * @param {number} maxLength
+ * @returns {string}
+ */
+export function truncate(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	return `${value.slice(0, maxLength - 1)}…`;
+}

package/extensions/yank.ts

@@ -0,0 +1,157 @@
+import {
+	copyToClipboard,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type SessionEntry,
+} from "@mariozechner/pi-coding-agent";
+import { extractCodeBlocks } from "./yank-core.js";
+
+interface AssistantMessageLike {
+	role?: unknown;
+	stopReason?: unknown;
+	content?: unknown;
+}
+
+const COPY_SUCCESS_MESSAGE = "Copied last agent message to clipboard";
+const COPY_EMPTY_MESSAGE = "No agent messages to copy yet.";
+const COPY_CODE_BLOCK_SUCCESS_MESSAGE = "Copied code block to clipboard";
+const MENU_DISABLED_MESSAGE =
+	"Future /yank commands will copy the full last message in this session";
+
+function getLastAssistantText(entries: SessionEntry[]): string | undefined {
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry.type !== "message") continue;
+
+		const message = entry.message as AssistantMessageLike;
+		if (message.role !== "assistant") continue;
+
+		const text = extractAssistantText(message);
+		if (text) return text;
+	}
+
+	return undefined;
+}
+
+function extractAssistantText(
+	message: AssistantMessageLike,
+): string | undefined {
+	const content = Array.isArray(message.content) ? message.content : [];
+	if (message.stopReason === "aborted" && content.length === 0) {
+		return undefined;
+	}
+
+	let text = "";
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const part = item as { type?: unknown; text?: unknown };
+		if (part.type === "text" && typeof part.text === "string") {
+			text += part.text;
+		}
+	}
+
+	const trimmed = text.trim();
+	return trimmed || undefined;
+}
+
+function countNonEmptyLines(text: string): number {
+	return text.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+}
+
+function summarizeBlock(content: string): string {
+	const lines = countNonEmptyLines(content);
+	const chars = content.length;
+	return `${lines} line${lines === 1 ? "" : "s"} • ${chars} chars`;
+}
+
+function buildMenuOptions(
+	text: string,
+	codeBlocks: ReturnType<typeof extractCodeBlocks>,
+) {
+	const fullMessageOption = `1. Full last message (${summarizeBlock(text)})`;
+	const codeBlockOptions = codeBlocks.map(
+		(block, index) =>
+			`${index + 2}. Code block — ${block.preview} (${summarizeBlock(block.content)})`,
+	);
+	const skipMenuOption = `${codeBlocks.length + 2}. Always copy full last message in this session`;
+
+	return {
+		fullMessageOption,
+		codeBlockOptions,
+		skipMenuOption,
+		all: [fullMessageOption, ...codeBlockOptions, skipMenuOption],
+	};
+}
+
+async function copyAndNotify(
+	text: string,
+	successMessage: string,
+	ctx: ExtensionCommandContext,
+): Promise<void> {
+	await copyToClipboard(text);
+	ctx.ui.notify(successMessage, "info");
+}
+
+export default function yankExtension(pi: ExtensionAPI) {
+	let skipMenuForSession = false;
+
+	pi.registerCommand("yank", {
+		description: "Copy the last assistant message or a code block from it",
+		handler: async (_args, ctx) => {
+			const text = getLastAssistantText(ctx.sessionManager.getBranch());
+			if (!text) {
+				ctx.ui.notify(COPY_EMPTY_MESSAGE, "error");
+				return;
+			}
+
+			const codeBlocks = extractCodeBlocks(text);
+			if (!ctx.hasUI || skipMenuForSession || codeBlocks.length === 0) {
+				try {
+					await copyAndNotify(text, COPY_SUCCESS_MESSAGE, ctx);
+				} catch (error) {
+					ctx.ui.notify(
+						error instanceof Error ? error.message : String(error),
+						"error",
+					);
+				}
+				return;
+			}
+
+			const menu = buildMenuOptions(text, codeBlocks);
+			const selected = await ctx.ui.select("Yank from last response", menu.all);
+			if (!selected) return;
+
+			try {
+				if (selected === menu.fullMessageOption) {
+					await copyAndNotify(text, COPY_SUCCESS_MESSAGE, ctx);
+					return;
+				}
+
+				if (selected === menu.skipMenuOption) {
+					skipMenuForSession = true;
+					await copyAndNotify(text, COPY_SUCCESS_MESSAGE, ctx);
+					ctx.ui.notify(MENU_DISABLED_MESSAGE, "info");
+					return;
+				}
+
+				const codeBlockIndex = menu.codeBlockOptions.indexOf(selected);
+				const codeBlock = codeBlocks[codeBlockIndex];
+				if (!codeBlock) {
+					ctx.ui.notify("Invalid selection", "error");
+					return;
+				}
+
+				await copyAndNotify(
+					codeBlock.content,
+					COPY_CODE_BLOCK_SUCCESS_MESSAGE,
+					ctx,
+				);
+			} catch (error) {
+				ctx.ui.notify(
+					error instanceof Error ? error.message : String(error),
+					"error",
+				);
+			}
+		},
+	});
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+	"name": "pi-yank",
+	"private": false,
+	"version": "0.1.0",
+	"type": "module",
+	"description": "Lightweight /yank extension for pi that copies the last assistant message or a selected code block.",
+	"keywords": [
+		"pi-package"
+	],
+	"license": "MIT",
+	"scripts": {
+		"build": "echo 'nothing to build'",
+		"check": "node --test tests/*.test.mjs"
+	},
+	"peerDependencies": {
+		"@mariozechner/pi-coding-agent": "*"
+	},
+	"pi": {
+		"extensions": [
+			"./extensions/yank.ts"
+		]
+	}
+}

package/tests/yank-core.test.mjs

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	buildCodeBlockPreview,
+	extractCodeBlocks,
+} from "../extensions/yank-core.js";
+
+test("extracts a single outer markdown block when nested fences appear as literal examples", () => {
+	const text = `我来为你创建一个 Markdown 格式的测试文本：
+
+\`\`\`markdown
+# Markdown 格式测试文档
+
+## 代码块
+
+### JavaScript 代码
+\`\`\`javascript
+function hello() {
+  console.log("Hello, World!");
+}
+\`\`\`
+
+### Python 代码
+\`\`\`python
+def hello():
+    print("Hello, World!")
+\`\`\`
+
+*文档结束*
+\`\`\`
+
+说明文字`;
+
+	const blocks = extractCodeBlocks(text);
+	assert.equal(blocks.length, 1);
+	assert.match(blocks[0].content, /function hello\(\)/);
+	assert.match(blocks[0].content, /def hello\(\):/);
+	assert.equal(blocks[0].preview, "markdown: # Markdown 格式测试文档");
+});
+
+test("extracts sibling top-level code blocks independently", () => {
+	const text = `before
+\`\`\`js
+console.log("a");
+\`\`\`
+
+between
+
+\`\`\`python
+print("b")
+\`\`\`
+after`;
+
+	const blocks = extractCodeBlocks(text);
+	assert.equal(blocks.length, 2);
+	assert.equal(blocks[0].content, 'console.log("a");');
+	assert.equal(blocks[1].content, 'print("b")');
+	assert.equal(blocks[0].preview, 'js: console.log("a");');
+	assert.equal(blocks[1].preview, 'python: print("b")');
+});
+
+test("supports tilde fences", () => {
+	const text = `~~~sql
+select 1;
+~~~`;
+	const blocks = extractCodeBlocks(text);
+	assert.equal(blocks.length, 1);
+	assert.equal(blocks[0].content, "select 1;");
+	assert.equal(blocks[0].preview, "sql: select 1;");
+});
+
+test("ignores unterminated fences", () => {
+	const text = `\`\`\`ts
+const x = 1;`;
+	const blocks = extractCodeBlocks(text);
+	assert.equal(blocks.length, 0);
+});
+
+test("preview falls back cleanly for empty blocks", () => {
+	assert.equal(
+		buildCodeBlockPreview("", 3, "markdown"),
+		"markdown: Code block 3",
+	);
+});