pi-extensions 0.1.9

package/code-actions/README.md

@@ -0,0 +1,65 @@
+# Code Actions extension
+
+/code to pick code blocks (```) or `inline code` from recent assistant messages and then copy or insert them. Helpful for retrieving commands and filepaths mentioned by Pi.
+
+/code opens a menu you can type to search. You can hit enter to copy the snippet, or `right arrow` to insert it in the command line.
+
+<img width="751" height="416" alt="Screenshot 2026-01-09 at 17 09 17" src="https://github.com/user-attachments/assets/0dc10a64-d61f-4b56-9684-5e448c759385" />
+
+
+## Install
+
+```bash
+pi install npm:@tmustier/pi-code-actions
+```
+
+```bash
+pi install git:github.com/tmustier/pi-extensions
+```
+
+Then filter to just this extension in `~/.pi/agent/settings.json`:
+
+```json
+{
+  "packages": [
+    {
+      "source": "git:github.com/tmustier/pi-extensions",
+      "extensions": ["code-actions/index.ts"]
+    }
+  ]
+}
+```
+
+## Usage
+
+- Command: `/code`
+- Optional args:
+  - `all` to scan all assistant messages in the current branch (default: all)
+  - `blocks` to hide inline snippets (default: inline + fenced blocks)
+  - `limit=50` to cap the number of snippets returned (default: 200)
+  - `copy`, `insert`, or `run` to choose an action up front
+  - a number to pick a specific snippet (1-based)
+
+Examples:
+- `/code`
+- `/code blocks`
+- `/code copy`
+- `/code all`
+- `/code limit=50`
+- `/code run 2`
+
+## Actions
+
+- Copy: puts the snippet on your clipboard
+- Insert: inserts the snippet into the input editor
+- Run: executes the snippet in your shell (asks for confirmation)
+
+## Notes
+
+- Only assistant messages are scanned.
+- Inline code uses single backticks. Code blocks use triple backticks.
+- Inline snippets are filtered to path-like content: `~/...`, `./...`, paths with 2+ slashes, or files with extensions. Use `blocks` to show only code blocks.
+
+## Changelog
+
+See `CHANGELOG.md`.

package/code-actions/actions.ts

@@ -0,0 +1,107 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { Container, Text, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import { DynamicBorder } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export async function copyToClipboard(pi: ExtensionAPI, content: string): Promise<boolean> {
+	const tmpPath = path.join(os.tmpdir(), `pi-code-${Date.now()}.txt`);
+	fs.writeFileSync(tmpPath, content, "utf8");
+
+	const commands: Array<{ command: string; args: string[] }> = [];
+	if (process.platform === "darwin") {
+		commands.push({ command: "sh", args: ["-c", `cat "${tmpPath}" | pbcopy`] });
+	} else if (process.platform === "win32") {
+		commands.push({ command: "powershell", args: ["-NoProfile", "-Command", `Get-Content -Raw "${tmpPath}" | Set-Clipboard`] });
+	} else {
+		commands.push({ command: "sh", args: ["-c", `cat "${tmpPath}" | wl-copy`] });
+		commands.push({ command: "sh", args: ["-c", `cat "${tmpPath}" | xclip -selection clipboard`] });
+		commands.push({ command: "sh", args: ["-c", `cat "${tmpPath}" | xsel --clipboard --input`] });
+	}
+
+	let success = false;
+	for (const cmd of commands) {
+		try {
+			const result = await pi.exec(cmd.command, cmd.args);
+			if (result.code === 0) {
+				success = true;
+				break;
+			}
+		} catch {
+			// Try next command
+		}
+	}
+
+	try {
+		fs.unlinkSync(tmpPath);
+	} catch {
+		// Ignore cleanup errors
+	}
+
+	return success;
+}
+
+export function insertIntoEditor(ctx: ExtensionCommandContext, content: string): void {
+	const existing = ctx.ui.getEditorText();
+	const next = existing ? `${existing}\n${content}` : content;
+	ctx.ui.setEditorText(next);
+}
+
+function formatOutput(command: string, result: { stdout: string; stderr: string; code: number }): string {
+	const lines: string[] = [];
+	lines.push(`Command: ${command}`);
+	lines.push(`Exit code: ${result.code}`);
+
+	if (result.stdout.trim().length > 0) {
+		lines.push("");
+		lines.push("STDOUT:");
+		lines.push(result.stdout.trimEnd());
+	}
+
+	if (result.stderr.trim().length > 0) {
+		lines.push("");
+		lines.push("STDERR:");
+		lines.push(result.stderr.trimEnd());
+	}
+
+	return lines.join("\n");
+}
+
+function truncateLines(text: string, maxLines: number): string {
+	const lines = text.split(/\r?\n/);
+	if (lines.length <= maxLines) return text;
+	const truncated = lines.slice(0, maxLines).join("\n");
+	return `${truncated}\n\n[Output truncated to ${maxLines} lines]`;
+}
+
+export async function runSnippet(pi: ExtensionAPI, ctx: ExtensionCommandContext, snippet: string): Promise<void> {
+	const isWindows = process.platform === "win32";
+	const command = isWindows ? "powershell" : "bash";
+	const args = isWindows ? ["-NoProfile", "-Command", snippet] : ["-lc", snippet];
+
+	const result = await pi.exec(command, args, { cwd: ctx.cwd });
+	const output = truncateLines(formatOutput(`${command} ${args.join(" ")}`, result), 200);
+
+	await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+		const container = new Container();
+		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+		container.addChild(new Text(theme.fg("accent", theme.bold("Command Output")), 1, 0));
+
+		const text = new Text(output, 1, 0);
+		container.addChild(text);
+
+		container.addChild(new Text(theme.fg("dim", "Enter/Esc to close"), 1, 0));
+		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+		return {
+			render: (width: number) => container.render(width).map((line) => truncateToWidth(line, width)),
+			invalidate: () => container.invalidate(),
+			handleInput: (data: string) => {
+				if (matchesKey(data, "escape") || matchesKey(data, "enter")) {
+					done();
+				}
+			},
+		};
+	});
+}

package/code-actions/index.ts

@@ -0,0 +1,148 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { extractSnippets, extractText } from "./snippets";
+import type { Snippet } from "./snippets";
+import { pickAction, pickSnippet } from "./ui";
+import type { PickResult } from "./ui";
+import { copyToClipboard, insertIntoEditor, runSnippet } from "./actions";
+
+type ParsedArgs = {
+	scope: "last" | "all";
+	action?: "copy" | "insert" | "run";
+	index?: number;
+	includeInline: boolean;
+	limit: number;
+};
+
+function parseArgs(args?: string): ParsedArgs {
+	const tokens = args?.trim().split(/\s+/).filter(Boolean) ?? [];
+	const parsed: ParsedArgs = { scope: "all", includeInline: true, limit: 200 };
+
+	for (const token of tokens) {
+		if (token === "all" || token === "last") {
+			parsed.scope = token;
+			continue;
+		}
+		if (token === "inline") {
+			parsed.includeInline = true;
+			continue;
+		}
+		if (token === "blocks") {
+			parsed.includeInline = false;
+			continue;
+		}
+		if (token === "copy" || token === "insert" || token === "run") {
+			parsed.action = token;
+			continue;
+		}
+		if (token.startsWith("limit=")) {
+			const value = Number.parseInt(token.slice("limit=".length), 10);
+			if (!Number.isNaN(value) && value > 0) parsed.limit = value;
+			continue;
+		}
+		if (/^\d+$/.test(token)) {
+			parsed.index = Math.max(0, Number.parseInt(token, 10) - 1);
+		}
+	}
+
+	return parsed;
+}
+
+function collectSnippets(
+	ctx: ExtensionCommandContext,
+	scope: "last" | "all",
+	includeInline: boolean,
+	limit: number,
+): Snippet[] {
+	const branchEntries = ctx.sessionManager.getBranch();
+	const assistantEntries = branchEntries.filter(
+		(entry) => entry.type === "message" && entry.message?.role === "assistant",
+	);
+
+	if (assistantEntries.length === 0) return [];
+
+	const sorted = assistantEntries.slice().sort((a, b) => {
+		const aTime = Date.parse(a.timestamp);
+		const bTime = Date.parse(b.timestamp);
+		return bTime - aTime;
+	});
+
+	const entriesToScan = scope === "all" ? sorted : [sorted[0]!];
+
+	let snippets: Snippet[] = [];
+	let nextId = 0;
+	for (const entry of entriesToScan) {
+		if (snippets.length >= limit) break;
+		const text = extractText(entry.message.content);
+		if (!text) continue;
+		const label = new Date(entry.timestamp).toLocaleTimeString();
+		const extracted = extractSnippets(text, entry.id, label, nextId, includeInline, limit - snippets.length);
+		snippets = snippets.concat(extracted);
+		nextId = snippets.length;
+	}
+
+	return snippets;
+}
+
+export default function codeActionsExtension(pi: ExtensionAPI) {
+	pi.registerCommand("code", {
+		description: "Pick code from assistant messages and copy/insert/run it",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI && (!args || args.trim().length === 0)) {
+				return;
+			}
+
+			const parsed = parseArgs(args);
+			const snippets = collectSnippets(ctx, parsed.scope, parsed.includeInline, parsed.limit);
+
+			if (snippets.length === 0) {
+				if (ctx.hasUI) ctx.ui.notify("No code snippets found. /code tracks code blocks and filepaths only.", "warning");
+				return;
+			}
+
+			let snippet: Snippet | undefined;
+			let pickedAction: PickResult["action"] | undefined;
+			if (parsed.index !== undefined) {
+				snippet = snippets[parsed.index];
+				if (!snippet) {
+					if (ctx.hasUI) ctx.ui.notify("Snippet index out of range.", "warning");
+					return;
+				}
+			} else {
+				if (!ctx.hasUI) return;
+				const result = await pickSnippet(ctx, snippets);
+				if (!result) return;
+				snippet = result.snippet;
+				pickedAction = result.action;
+			}
+
+			let action = parsed.action ?? pickedAction;
+			if (!action) {
+				if (!ctx.hasUI) return;
+				action = await pickAction(ctx);
+			}
+			if (!action) return;
+
+			if (action === "copy") {
+				const ok = await copyToClipboard(pi, snippet.content);
+				if (ctx.hasUI) {
+					ctx.ui.notify(ok ? "Copied to clipboard." : "Failed to copy to clipboard.", ok ? "info" : "error");
+				}
+				return;
+			}
+
+			if (action === "insert") {
+				if (!ctx.hasUI) return;
+				insertIntoEditor(ctx, snippet.content);
+				ctx.ui.notify("Inserted snippet into editor.", "info");
+				return;
+			}
+
+			if (action === "run") {
+				if (!ctx.hasUI) return;
+				const ok = await ctx.ui.confirm("Run snippet?", "This will execute the selected snippet in your shell.");
+				if (!ok) return;
+				await runSnippet(pi, ctx, snippet.content);
+			}
+		},
+	});
+}

package/code-actions/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@tmustier/pi-code-actions",
+  "version": "0.1.0",
+  "description": "Pick code blocks or inline snippets from recent assistant messages to copy or insert.",
+  "license": "MIT",
+  "author": "Thomas Mustier",
+  "keywords": [
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tmustier/pi-extensions.git",
+    "directory": "code-actions"
+  },
+  "bugs": "https://github.com/tmustier/pi-extensions/issues",
+  "homepage": "https://github.com/tmustier/pi-extensions/tree/main/code-actions",
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  }
+}

package/code-actions/search.ts

@@ -0,0 +1,79 @@
+import type { SelectItem } from "@mariozechner/pi-tui";
+import type { Snippet } from "./snippets";
+import { getSnippetPreview } from "./snippets";
+
+export type SearchIndexItem = {
+	item: SelectItem;
+	idx: number;
+	raw: string;
+	normalized: string;
+};
+
+export function normalizeForSearch(value: string): string {
+	return value
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+export function buildSearchIndex(snippets: Snippet[], items: SelectItem[]): SearchIndexItem[] {
+	return snippets.map((snippet, idx) => {
+		const preview = getSnippetPreview(snippet);
+		const type = snippet.type;
+		const lang = snippet.language ?? "";
+		const raw = `${preview} ${type} ${lang} ${snippet.sourceLabel}`.toLowerCase();
+		return {
+			item: items[idx]!,
+			idx,
+			raw,
+			normalized: normalizeForSearch(raw),
+		};
+	});
+}
+
+export function rankedFilterItems(
+	filter: string,
+	items: SelectItem[],
+	searchIndex: SearchIndexItem[],
+): SelectItem[] {
+	const lower = filter.toLowerCase();
+	if (lower.length === 0) return items;
+
+	const norm = normalizeForSearch(lower);
+	const tokens = norm.length > 0 ? norm.split(" ") : [];
+	const scored: Array<{ item: SelectItem; idx: number; score: number }> = [];
+
+	for (const entry of searchIndex) {
+		let score = 0;
+
+		const rawIndex = entry.raw.indexOf(lower);
+		if (rawIndex !== -1) {
+			score = 1000 - rawIndex;
+		} else if (tokens.length > 0) {
+			let allMatch = true;
+			let firstPos = Number.MAX_SAFE_INTEGER;
+			for (const token of tokens) {
+				const pos = entry.normalized.indexOf(token);
+				if (pos === -1) {
+					allMatch = false;
+					break;
+				}
+				firstPos = Math.min(firstPos, pos);
+			}
+			if (!allMatch) continue;
+			score = 500 - firstPos;
+		} else {
+			continue;
+		}
+
+		scored.push({ item: entry.item, idx: entry.idx, score });
+	}
+
+	scored.sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		return a.idx - b.idx;
+	});
+
+	return scored.map((entry) => entry.item);
+}

package/code-actions/snippets.ts

@@ -0,0 +1,179 @@
+export type SnippetType = "block" | "inline";
+
+export type Snippet = {
+	id: number;
+	type: SnippetType;
+	language?: string;
+	content: string;
+	messageId: string;
+	sourceLabel: string;
+};
+
+// ─────────────────────────────────────────────────────────────
+// Constants
+// ─────────────────────────────────────────────────────────────
+
+/** Minimum slashes required for generic path-like content (e.g. `foo/bar/baz`) */
+const MIN_SLASH_COUNT = 2;
+
+/** Matches file extensions like .ts, .html, .json */
+const HAS_FILE_EXTENSION = /\.[a-zA-Z0-9]{1,6}$/;
+
+/** Commands/keywords that appear in inline code but aren't actionable */
+const IGNORED_COMMANDS = new Set([
+	"main",
+	"inline",
+	"blocks",
+	"bash -lc",
+	"ls",
+	"pwd",
+	"cd",
+	"git status",
+	"git diff",
+	"git add",
+	"git commit",
+	"git push",
+	"git pull",
+	"git checkout",
+	"git switch",
+	"npm install",
+	"pnpm install",
+	"yarn install",
+	"bun install",
+	"npm test",
+	"pnpm test",
+	"yarn test",
+	"npm run",
+	"pnpm run",
+	"yarn run",
+	"make",
+	"make test",
+	"make lint",
+	"make build",
+]);
+
+export function extractText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+
+	let text = "";
+	for (const part of content) {
+		if (part && typeof part === "object" && (part as { type?: string }).type === "text") {
+			const value = (part as { text?: string }).text;
+			if (value) text += value;
+		}
+	}
+
+	return text;
+}
+
+// ─────────────────────────────────────────────────────────────
+// Filtering
+// ─────────────────────────────────────────────────────────────
+
+/** Check if content looks like a file path worth extracting */
+function looksLikePath(content: string): boolean {
+	const slashCount = (content.match(/\//g) || []).length;
+
+	// ~/... or commands containing ~/ (e.g. "open ~/file.html")
+	if (/(?:^|[\s"'])~\//.test(content)) return true;
+
+	// ./... (current directory)
+	if (content.startsWith("./")) return true;
+
+	// Absolute paths: /foo/bar (2+ slashes) or /file.html (has extension)
+	if (content.startsWith("/")) {
+		return slashCount >= MIN_SLASH_COUNT || HAS_FILE_EXTENSION.test(content);
+	}
+
+	// Generic: foo/bar/baz requires 2+ slashes
+	return slashCount >= MIN_SLASH_COUNT;
+}
+
+function shouldIncludeInlineSnippet(content: string): boolean {
+	const trimmed = content.trim();
+
+	// Reject: empty, comments, known commands, short identifiers
+	if (trimmed.length === 0) return false;
+	if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) return false;
+	if (IGNORED_COMMANDS.has(trimmed)) return false;
+	if (/^[A-Za-z0-9._-]{1,5}$/.test(trimmed)) return false;
+
+	return looksLikePath(trimmed);
+}
+
+// ─────────────────────────────────────────────────────────────
+// Extraction
+// ─────────────────────────────────────────────────────────────
+
+export function extractSnippets(
+	text: string,
+	messageId: string,
+	sourceLabel: string,
+	startId: number,
+	includeInline: boolean,
+	limit: number,
+): Snippet[] {
+	const snippets: Snippet[] = [];
+	const fencedRanges: Array<{ start: number; end: number }> = [];
+	const fencedRegex = /```([^\n`]*)\n([\s\S]*?)```/g;
+	let match: RegExpExecArray | null;
+
+	while ((match = fencedRegex.exec(text))) {
+		if (snippets.length >= limit) return snippets;
+		const language = match[1]?.trim() || undefined;
+		const content = match[2]?.replace(/\n$/, "") ?? "";
+		snippets.push({
+			id: startId + snippets.length,
+			type: "block",
+			language,
+			content,
+			messageId,
+			sourceLabel,
+		});
+		fencedRanges.push({ start: match.index, end: match.index + match[0].length });
+	}
+
+	if (!includeInline) return snippets;
+
+	const inlineRegex = /`([^`\n]+)`/g;
+	while ((match = inlineRegex.exec(text))) {
+		if (snippets.length >= limit) return snippets;
+		const index = match.index;
+		const inFence = fencedRanges.some((range) => index >= range.start && index < range.end);
+		if (inFence) continue;
+
+		const content = match[1] ?? "";
+		if (!shouldIncludeInlineSnippet(content)) continue;
+
+		snippets.push({
+			id: startId + snippets.length,
+			type: "inline",
+			content,
+			messageId,
+			sourceLabel,
+		});
+	}
+
+	return snippets;
+}
+
+export function getSnippetPreview(snippet: Snippet): string {
+	const content = snippet.content.trim();
+	if (content.length === 0) return "(empty)";
+
+	if (snippet.type === "block") {
+		return content.replace(/\s+/g, " ");
+	}
+
+	const lines = content.split(/\r?\n/);
+	const firstNonEmpty = lines.find((line) => line.trim().length > 0) ?? lines[0] ?? "";
+	const preview = firstNonEmpty.trim();
+	return preview.length > 0 ? preview : "(empty)";
+}
+
+export function truncatePreview(value: string, width: number): string {
+	if (value.length <= width) return value;
+	if (width <= 1) return value.slice(0, width);
+	return `${value.slice(0, width - 1)}…`;
+}