pi-copy-message 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 1.0.0 - 2026-06-07
+
+Initial release.
+
+- Add `/copy-message` custom TUI picker.
+- Copy raw stored session message text instead of rendered terminal lines.
+- Show messages in chronological chat order with newest selected by default.
+- Add role filters for user, assistant, and tool/bash messages.
+- Hide tool/bash messages by default.
+- Add type-to-filter search with selection restore when search is cleared.
+- Add Home/End jumps for oldest/newest visible messages.
+- Add fast paths: `/copy-message latest`, `/copy-message last`, and `/copy-message newest`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mitch Fultz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# pi copy-message extension
+
+A [pi](https://github.com/earendil-works/pi-mono) extension that adds `/copy-message`: a keyboard-first picker for copying raw session message text without terminal wrapping, padding, or rendered TUI artifacts.
+
+`pi-copy-message` supersedes [`pi-copy-user-message`](https://github.com/fitchmultz/pi-copy-user-message), which only copied the most recent user message.
+
+## What it does
+
+- Adds `/copy-message`
+- Copies raw stored session message text, not rendered terminal lines
+- Shows messages in chat order: oldest at top, newest at bottom
+- Selects the newest visible message by default
+- Supports role filters for user, assistant, and tool/bash messages
+- Hides tool/bash messages by default
+- Supports type-to-filter search across role, time, and message text
+- Supports Home/End jumps for oldest/newest visible messages
+- Includes fast paths: `/copy-message latest`, `/copy-message last`, and `/copy-message newest`
+
+## Install
+
+Install it from npm with pi:
+
+```bash
+pi install npm:pi-copy-message
+```
+
+Or install it directly from GitHub with pi:
+
+```bash
+pi install https://github.com/fitchmultz/pi-copy-message
+```
+
+Then reload pi from inside the app:
+
+```text
+/reload
+```
+
+If you prefer to load it directly from a local checkout during development:
+
+```bash
+pi -e ./extensions/copy-message.ts
+```
+
+## Usage
+
+Open the picker:
+
+```text
+/copy-message
+```
+
+Copy the latest visible default message directly:
+
+```text
+/copy-message latest
+```
+
+Aliases:
+
+```text
+/copy-message last
+/copy-message newest
+```
+
+## Keyboard controls
+
+| Key | Action |
+|---|---|
+| `↑` | Move to older visible message |
+| `↓` | Move to newer visible message |
+| `Home` | Jump to oldest visible message |
+| `End` | Jump to newest visible message |
+| Type text | Filter visible messages |
+| `Backspace` | Delete one search character |
+| `Ctrl+U` | Toggle user messages |
+| `Ctrl+A` | Toggle assistant messages |
+| `Ctrl+T` | Toggle tool/bash messages |
+| `Enter` | Copy selected raw message text |
+| `Esc` | Cancel |
+
+## Behavior notes
+
+- Entry IDs are hidden from the picker.
+- The picker caps visible rows and scrolls instead of filling the screen.
+- Search preserves your original selected message and restores it when the search is cleared.
+- Filter labels honor the active pi theme.
+- `/copy-message latest` respects default visibility: user and assistant messages are visible, tool/bash messages are hidden. If only hidden messages exist, it falls back to the newest message so the command still does something useful.
+- The command requires interactive TUI mode because the picker is a custom TUI component.
+
+## Compatibility
+
+- Tested with pi 0.78.1
+- Supported Node.js range for local repo tooling: `>=22.19.0`
+- `.nvmrc` pins Node 22.19.0 for local development
+
+This package keeps pi core packages as optional wildcard peers per current pi package guidance. Local development uses `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` as dev dependencies for typechecking and tests.
+
+## Development
+
+```bash
+npm install
+npm run check
+```
+
+Key files:
+
+- `extensions/copy-message.ts` — publishable extension implementation
+- `tests/copy-message.test.ts` — regression tests for command wiring, filtering, search, jumps, and clipboard behavior

package/extensions/copy-message.ts

@@ -0,0 +1,450 @@
+import { spawnSync } from "node:child_process";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+const MAX_VISIBLE_MESSAGES = 8;
+
+export interface CopyableMessage {
+	id: string;
+	role: string;
+	timestamp?: string;
+	text: string;
+}
+
+type CopyMessageTheme = Parameters<Parameters<ExtensionCommandContext["ui"]["custom"]>[0]>[1];
+
+function textFromContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+
+	return content
+		.filter((part): part is { type: string; text: string } => {
+			return (
+				part !== null &&
+				typeof part === "object" &&
+				"type" in part &&
+				(part as { type?: unknown }).type === "text" &&
+				"text" in part &&
+				typeof (part as { text?: unknown }).text === "string"
+			);
+		})
+		.map((part) => part.text)
+		.join("\n\n");
+}
+
+function textFromMessage(message: Record<string, unknown>): string {
+	const role = message.role;
+
+	if (role === "bashExecution") {
+		const command = typeof message.command === "string" ? message.command : "";
+		const output = typeof message.output === "string" ? message.output : "";
+		return command ? `$ ${command}\n${output}`.trimEnd() : output;
+	}
+
+	if (role === "branchSummary") {
+		return typeof message.summary === "string" ? message.summary : "";
+	}
+
+	if (role === "compactionSummary") {
+		return typeof message.summary === "string" ? message.summary : "";
+	}
+
+	return textFromContent(message.content);
+}
+
+function compactPreview(text: string, max = 96): string {
+	const preview = text.replace(/\s+/g, " ").trim();
+	if (preview.length <= max) return preview;
+	return `${preview.slice(0, max - 1)}…`;
+}
+
+function roleLabel(role: string): string {
+	switch (role) {
+		case "assistant":
+			return "assistant";
+		case "user":
+			return "user";
+		case "toolResult":
+			return "tool";
+		case "bashExecution":
+			return "bash";
+		case "custom":
+			return "custom";
+		case "branchSummary":
+			return "branch-summary";
+		case "compactionSummary":
+			return "compaction";
+		default:
+			return role || "message";
+	}
+}
+
+function formatTime(timestamp: unknown): string {
+	if (typeof timestamp !== "string") return "";
+	const date = new Date(timestamp);
+	if (Number.isNaN(date.getTime())) return "";
+	return date.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" });
+}
+
+export function collectCopyableMessages(ctx: { sessionManager: { getBranch(): unknown[] } }): CopyableMessage[] {
+	const messages: CopyableMessage[] = [];
+
+	for (const entry of ctx.sessionManager.getBranch()) {
+		if (entry === null || typeof entry !== "object") continue;
+		const record = entry as Record<string, unknown>;
+		if (record.type !== "message") continue;
+		if (record.message === null || typeof record.message !== "object") continue;
+
+		const message = record.message as Record<string, unknown>;
+		const role = typeof message.role === "string" ? message.role : "message";
+		const text = textFromMessage(message);
+		if (!text.trim()) continue;
+
+		messages.push({
+			id: typeof record.id === "string" ? record.id : "unknown",
+			role,
+			timestamp: typeof record.timestamp === "string" ? record.timestamp : undefined,
+			text,
+		});
+	}
+
+	return messages;
+}
+
+function commandExists(command: string): boolean {
+	const result = spawnSync("sh", ["-c", "command -v \"$1\" >/dev/null 2>&1", "sh", command], { stdio: "ignore" });
+	return result.status === 0;
+}
+
+function copyWith(command: string, args: string[], text: string): boolean {
+	const result = spawnSync(command, args, { input: text, encoding: "utf8" });
+	return !result.error && result.status === 0;
+}
+
+function copyToClipboard(text: string): string | undefined {
+	if (process.platform === "darwin" && commandExists("pbcopy")) {
+		return copyWith("pbcopy", [], text) ? undefined : "pbcopy failed";
+	}
+
+	if (process.env.TERMUX_VERSION && commandExists("termux-clipboard-set")) {
+		return copyWith("termux-clipboard-set", [], text) ? undefined : "termux-clipboard-set failed";
+	}
+
+	if (commandExists("wl-copy")) {
+		return copyWith("wl-copy", [], text) ? undefined : "wl-copy failed";
+	}
+
+	if (commandExists("xclip")) {
+		return copyWith("xclip", ["-selection", "clipboard"], text) ? undefined : "xclip failed";
+	}
+
+	if (commandExists("xsel")) {
+		return copyWith("xsel", ["--clipboard", "--input"], text) ? undefined : "xsel failed";
+	}
+
+	return "No clipboard command found (tried pbcopy, termux-clipboard-set, wl-copy, xclip, xsel)";
+}
+
+function isToolMessage(message: CopyableMessage): boolean {
+	return message.role === "toolResult" || message.role === "bashExecution";
+}
+
+export interface MessageVisibility {
+	showAssistant: boolean;
+	showUser: boolean;
+	showTools: boolean;
+}
+
+function isVisibleMessage(message: CopyableMessage, visibility: MessageVisibility): boolean {
+	if (isToolMessage(message)) return visibility.showTools;
+	if (message.role === "assistant") return visibility.showAssistant;
+	if (message.role === "user") return visibility.showUser;
+	return true;
+}
+
+function messageSearchText(message: CopyableMessage): string {
+	return [roleLabel(message.role), formatTime(message.timestamp), message.text].join(" ").toLowerCase();
+}
+
+function messageMatchesSearch(message: CopyableMessage, search: string): boolean {
+	const terms = search
+		.trim()
+		.toLowerCase()
+		.split(/\s+/)
+		.filter(Boolean);
+	if (terms.length === 0) return true;
+	const haystack = messageSearchText(message);
+	return terms.every((term) => haystack.includes(term));
+}
+
+export function filteredMessages(messages: CopyableMessage[], visibility: MessageVisibility, search = ""): CopyableMessage[] {
+	return messages.filter((message) => isVisibleMessage(message, visibility) && messageMatchesSearch(message, search));
+}
+
+export function latestDefaultMessage(messages: CopyableMessage[]): CopyableMessage | undefined {
+	return filteredMessages(messages, { showAssistant: true, showUser: true, showTools: false }).at(-1) ?? messages.at(-1);
+}
+
+function isPrintableSearchInput(data: string): boolean {
+	return data.length > 0 && [...data].every((char) => {
+		const code = char.charCodeAt(0);
+		return code >= 32 && code !== 127 && !(code >= 0x80 && code <= 0x9f);
+	});
+}
+
+function filterLabel(theme: CopyMessageTheme, label: string, enabled: boolean, color: "accent" | "warning" | "dim"): string {
+	const text = `${label} ${enabled ? "✓" : "—"}`;
+	return enabled ? theme.fg(color, text) : theme.fg("muted", text);
+}
+
+function hotkeyHint(theme: CopyMessageTheme, text: string): string {
+	return theme.fg("text", text);
+}
+
+function roleColor(theme: CopyMessageTheme, role: string, text: string): string {
+	switch (roleLabel(role)) {
+		case "user":
+			return theme.fg("warning", text);
+		case "assistant":
+			return theme.fg("accent", text);
+		case "tool":
+		case "bash":
+			return theme.fg("dim", text);
+		default:
+			return theme.fg("muted", text);
+	}
+}
+
+function styleRoleText(theme: CopyMessageTheme, role: string, text: string, selected: boolean): string {
+	return roleColor(theme, role, selected ? theme.bold(text) : text);
+}
+
+function renderMessageLine(
+	message: CopyableMessage,
+	index: number,
+	total: number,
+	width: number,
+	selected: boolean,
+	theme: CopyMessageTheme,
+): string {
+	const numberWidth = String(total).length;
+	const arrow = selected ? theme.fg("accent", "→") : " ";
+	const number = `${String(index + 1).padStart(numberWidth)}.`;
+	const styledNumber = selected ? theme.fg("accent", theme.bold(number)) : theme.fg("dim", number);
+	const role = styleRoleText(theme, message.role, roleLabel(message.role), selected);
+	const time = theme.fg("muted", formatTime(message.timestamp));
+	const separator = theme.fg("dim", "·");
+	const meta = `${arrow} ${styledNumber} ${role} ${separator} ${time}`;
+	const previewWidth = Math.max(0, width - visibleWidth(meta) - 2);
+	const preview = truncateToWidth(compactPreview(message.text, 300), previewWidth, "…");
+	const styledPreview = styleRoleText(theme, message.role, preview, selected);
+	return preview ? `${meta}  ${styledPreview}` : meta;
+}
+
+type PickerInputResult = "copy" | "cancel" | "render" | "none";
+
+export class CopyMessagePickerState {
+	readonly visibility: MessageVisibility = {
+		showAssistant: true,
+		showUser: true,
+		showTools: false,
+	};
+	search = "";
+	visibleMessages: CopyableMessage[];
+	selectedIndex: number;
+	private searchAnchorId: string | undefined;
+
+	constructor(private readonly messages: CopyableMessage[]) {
+		this.visibleMessages = filteredMessages(messages, this.visibility, this.search);
+		this.selectedIndex = Math.max(0, this.visibleMessages.length - 1);
+	}
+
+	selectedMessage(): CopyableMessage | undefined {
+		return this.visibleMessages[this.selectedIndex];
+	}
+
+	render(width: number, theme: CopyMessageTheme): string[] {
+		const maxVisible = Math.min(this.visibleMessages.length, MAX_VISIBLE_MESSAGES);
+		const start = maxVisible === 0 ? 0 : Math.max(0, Math.min(this.selectedIndex - maxVisible + 1, this.visibleMessages.length - maxVisible));
+		const end = Math.min(this.visibleMessages.length, start + maxVisible);
+		const userState = filterLabel(theme, "user", this.visibility.showUser, "warning");
+		const assistantState = filterLabel(theme, "assistant", this.visibility.showAssistant, "accent");
+		const toolState = filterLabel(theme, "tools", this.visibility.showTools, "dim");
+		const searchState = this.search ? theme.fg("accent", `search “${this.search}”`) : theme.fg("dim", "type to filter");
+
+		const lines = [
+			theme.bold(theme.fg("accent", "Copy raw message")),
+			theme.fg("muted", "Newest is selected at bottom. Up goes back in time."),
+			"",
+		];
+
+		if (this.visibleMessages.length === 0) {
+			lines.push(theme.fg("warning", this.search ? "No messages match current filters and search." : "No messages visible with current filters."));
+		} else {
+			for (let i = start; i < end; i++) {
+				const message = this.visibleMessages[i];
+				if (!message) continue;
+				lines.push(renderMessageLine(message, i, this.visibleMessages.length, width, i === this.selectedIndex, theme));
+			}
+		}
+
+		const position = this.visibleMessages.length === 0 ? "0/0" : `${this.selectedIndex + 1}/${this.visibleMessages.length}`;
+		lines.push(`${theme.fg("dim", `(${position})`)} · ${userState} · ${assistantState} · ${toolState} · ${searchState}`);
+		lines.push("");
+		lines.push(hotkeyHint(theme, "type search · Home/End jump · Ctrl+U/A/T filters · Enter copy · Esc cancel"));
+		lines.push("");
+		return lines.map((line) => truncateToWidth(line, width, ""));
+	}
+
+	handleInput(data: string): PickerInputResult {
+		if (matchesKey(data, "ctrl+t")) {
+			this.visibility.showTools = !this.visibility.showTools;
+			this.refreshMessages();
+			return "render";
+		}
+		if (matchesKey(data, "ctrl+a")) {
+			this.visibility.showAssistant = !this.visibility.showAssistant;
+			this.refreshMessages();
+			return "render";
+		}
+		if (matchesKey(data, "ctrl+u")) {
+			this.visibility.showUser = !this.visibility.showUser;
+			this.refreshMessages();
+			return "render";
+		}
+		if (matchesKey(data, "backspace") || data === "\x7f") {
+			this.setSearch(this.search.slice(0, -1));
+			return "render";
+		}
+		if (isPrintableSearchInput(data)) {
+			this.setSearch(this.search + data);
+			return "render";
+		}
+		if (matchesKey(data, "up")) {
+			this.move(-1);
+			return "render";
+		}
+		if (matchesKey(data, "down")) {
+			this.move(1);
+			return "render";
+		}
+		if (matchesKey(data, "home")) {
+			this.jumpToTop();
+			return "render";
+		}
+		if (matchesKey(data, "end")) {
+			this.jumpToBottom();
+			return "render";
+		}
+		if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+			return this.visibleMessages.length > 0 ? "copy" : "none";
+		}
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			return "cancel";
+		}
+		return "none";
+	}
+
+	private refreshMessages(preferredId?: string) {
+		const selectedId = preferredId ?? this.visibleMessages[this.selectedIndex]?.id;
+		this.visibleMessages = filteredMessages(this.messages, this.visibility, this.search);
+		const nextIndex = selectedId ? this.visibleMessages.findIndex((message) => message.id === selectedId) : -1;
+		this.selectedIndex = nextIndex >= 0 ? nextIndex : Math.max(0, this.visibleMessages.length - 1);
+	}
+
+	private setSearch(nextSearch: string) {
+		if (this.search.length === 0 && nextSearch.length > 0) {
+			this.searchAnchorId = this.visibleMessages[this.selectedIndex]?.id;
+		}
+
+		this.search = nextSearch;
+
+		if (this.search.length === 0) {
+			const anchorId = this.searchAnchorId;
+			this.searchAnchorId = undefined;
+			this.refreshMessages(anchorId);
+			return;
+		}
+
+		this.refreshMessages();
+	}
+
+	private move(delta: number) {
+		if (this.visibleMessages.length === 0) return;
+		this.selectedIndex = Math.max(0, Math.min(this.visibleMessages.length - 1, this.selectedIndex + delta));
+	}
+
+	private jumpToTop() {
+		if (this.visibleMessages.length === 0) return;
+		this.selectedIndex = 0;
+	}
+
+	private jumpToBottom() {
+		if (this.visibleMessages.length === 0) return;
+		this.selectedIndex = this.visibleMessages.length - 1;
+	}
+}
+
+async function pickMessage(ctx: ExtensionCommandContext, messages: CopyableMessage[]) {
+	return ctx.ui.custom<CopyableMessage | null>((tui, theme, _keybindings, done) => {
+		const state = new CopyMessagePickerState(messages);
+		return {
+			render(width: number) {
+				return state.render(width, theme);
+			},
+			invalidate() {},
+			handleInput(data: string) {
+				const result = state.handleInput(data);
+				if (result === "copy") {
+					done(state.selectedMessage() ?? null);
+					return;
+				}
+				if (result === "cancel") {
+					done(null);
+					return;
+				}
+				if (result === "render") tui.requestRender();
+			},
+		};
+	});
+}
+
+function copySelectedMessage(ctx: Pick<ExtensionCommandContext, "ui">, selected: CopyableMessage) {
+	const error = copyToClipboard(selected.text);
+	if (error) {
+		ctx.ui.notify(error, "error");
+		return;
+	}
+
+	ctx.ui.notify(`Copied ${roleLabel(selected.role)} message`, "info");
+}
+
+export default function copyMessageExtension(pi: Pick<ExtensionAPI, "registerCommand">) {
+	pi.registerCommand("copy-message", {
+		description: "Select a session message and copy its raw text to the clipboard",
+		handler: async (args, ctx) => {
+			if (ctx.mode !== "tui") {
+				ctx.ui.notify("/copy-message requires interactive TUI mode", "error");
+				return;
+			}
+
+			const messages = collectCopyableMessages(ctx);
+			if (messages.length === 0) {
+				ctx.ui.notify("No copyable messages found in the current branch", "error");
+				return;
+			}
+
+			const trimmedArgs = (args ?? "").trim().toLowerCase();
+			if (trimmedArgs === "last" || trimmedArgs === "latest" || trimmedArgs === "newest") {
+				const latestVisible = latestDefaultMessage(messages);
+				if (latestVisible) copySelectedMessage(ctx, latestVisible);
+				return;
+			}
+
+			const selected = await pickMessage(ctx, messages);
+			if (!selected) return;
+
+			copySelectedMessage(ctx, selected);
+		},
+	});
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "pi-copy-message",
+  "version": "1.0.0",
+  "description": "pi extension that adds /copy-message for copying raw session messages with role filters and search",
+  "author": "Mitch Fultz (https://github.com/fitchmultz)",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "extension",
+    "clipboard",
+    "copy",
+    "tui",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fitchmultz/pi-copy-message.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fitchmultz/pi-copy-message/issues"
+  },
+  "homepage": "https://github.com/fitchmultz/pi-copy-message#readme",
+  "scripts": {
+    "test": "tsx tests/copy-message.test.ts",
+    "typecheck": "tsc --noEmit",
+    "check": "npm test && npm run typecheck",
+    "prepublishOnly": "npm run check && npm pack --dry-run"
+  },
+  "files": [
+    "extensions",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.78.1",
+    "@earendil-works/pi-tui": "^0.78.1",
+    "@types/node": "^25.9.1",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  },
+  "overrides": {
+    "basic-ftp": "6.0.1"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "packageManager": "npm@11.16.0",
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    }
+  }
+}