@lenylvt/pi-coding-agent 0.64.0

package/examples/extensions/git-checkpoint.ts

@@ -0,0 +1,53 @@
+/**
+ * Git Checkpoint Extension
+ *
+ * Creates git stash checkpoints at each turn so /fork can restore code state.
+ * When forking, offers to restore code to that point in history.
+ */
+
+import type { ExtensionAPI } from "@lenylvt/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	const checkpoints = new Map<string, string>();
+	let currentEntryId: string | undefined;
+
+	// Track the current entry ID when user messages are saved
+	pi.on("tool_result", async (_event, ctx) => {
+		const leaf = ctx.sessionManager.getLeafEntry();
+		if (leaf) currentEntryId = leaf.id;
+	});
+
+	pi.on("turn_start", async () => {
+		// Create a git stash entry before LLM makes changes
+		const { stdout } = await pi.exec("git", ["stash", "create"]);
+		const ref = stdout.trim();
+		if (ref && currentEntryId) {
+			checkpoints.set(currentEntryId, ref);
+		}
+	});
+
+	pi.on("session_before_fork", async (event, ctx) => {
+		const ref = checkpoints.get(event.entryId);
+		if (!ref) return;
+
+		if (!ctx.hasUI) {
+			// In non-interactive mode, don't restore automatically
+			return;
+		}
+
+		const choice = await ctx.ui.select("Restore code state?", [
+			"Yes, restore code to that point",
+			"No, keep current code",
+		]);
+
+		if (choice?.startsWith("Yes")) {
+			await pi.exec("git", ["stash", "apply", ref]);
+			ctx.ui.notify("Code restored to checkpoint", "info");
+		}
+	});
+
+	pi.on("agent_end", async () => {
+		// Clear checkpoints after agent completes
+		checkpoints.clear();
+	});
+}

package/examples/extensions/handoff.ts

@@ -0,0 +1,153 @@
+/**
+ * Handoff extension - transfer context to a new focused session
+ *
+ * Instead of compacting (which is lossy), handoff extracts what matters
+ * for your next task and creates a new session with a generated prompt.
+ *
+ * Usage:
+ *   /handoff now implement this for teams as well
+ *   /handoff execute phase one of the plan
+ *   /handoff check other places that need this fix
+ *
+ * The generated prompt appears as a draft in the editor for review/editing.
+ */
+
+import { complete, type Message } from "@lenylvt/pi-ai";
+import type { ExtensionAPI, SessionEntry } from "@lenylvt/pi-coding-agent";
+import { BorderedLoader, convertToLlm, serializeConversation } from "@lenylvt/pi-coding-agent";
+
+const SYSTEM_PROMPT = `You are a context transfer assistant. Given a conversation history and the user's goal for a new thread, generate a focused prompt that:
+
+1. Summarizes relevant context from the conversation (decisions made, approaches taken, key findings)
+2. Lists any relevant files that were discussed or modified
+3. Clearly states the next task based on the user's goal
+4. Is self-contained - the new thread should be able to proceed without the old conversation
+
+Format your response as a prompt the user can send to start the new thread. Be concise but include all necessary context. Do not include any preamble like "Here's the prompt" - just output the prompt itself.
+
+Example output format:
+## Context
+We've been working on X. Key decisions:
+- Decision 1
+- Decision 2
+
+Files involved:
+- path/to/file1.ts
+- path/to/file2.ts
+
+## Task
+[Clear description of what to do next based on user's goal]`;
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("handoff", {
+		description: "Transfer context to a new focused session",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("handoff requires interactive mode", "error");
+				return;
+			}
+
+			if (!ctx.model) {
+				ctx.ui.notify("No model selected", "error");
+				return;
+			}
+
+			const goal = args.trim();
+			if (!goal) {
+				ctx.ui.notify("Usage: /handoff <goal for new thread>", "error");
+				return;
+			}
+
+			// Gather conversation context from current branch
+			const branch = ctx.sessionManager.getBranch();
+			const messages = branch
+				.filter((entry): entry is SessionEntry & { type: "message" } => entry.type === "message")
+				.map((entry) => entry.message);
+
+			if (messages.length === 0) {
+				ctx.ui.notify("No conversation to hand off", "error");
+				return;
+			}
+
+			// Convert to LLM format and serialize
+			const llmMessages = convertToLlm(messages);
+			const conversationText = serializeConversation(llmMessages);
+			const currentSessionFile = ctx.sessionManager.getSessionFile();
+
+			// Generate the handoff prompt with loader UI
+			const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+				const loader = new BorderedLoader(tui, theme, `Generating handoff prompt...`);
+				loader.onAbort = () => done(null);
+
+				const doGenerate = async () => {
+					const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model!);
+					if (!auth.ok || !auth.apiKey) {
+						throw new Error(auth.ok ? `No API key for ${ctx.model!.provider}` : auth.error);
+					}
+
+					const userMessage: Message = {
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: `## Conversation History\n\n${conversationText}\n\n## User's Goal for New Thread\n\n${goal}`,
+							},
+						],
+						timestamp: Date.now(),
+					};
+
+					const response = await complete(
+						ctx.model!,
+						{ systemPrompt: SYSTEM_PROMPT, messages: [userMessage] },
+						{ apiKey: auth.apiKey, headers: auth.headers, signal: loader.signal },
+					);
+
+					if (response.stopReason === "aborted") {
+						return null;
+					}
+
+					return response.content
+						.filter((c): c is { type: "text"; text: string } => c.type === "text")
+						.map((c) => c.text)
+						.join("\n");
+				};
+
+				doGenerate()
+					.then(done)
+					.catch((err) => {
+						console.error("Handoff generation failed:", err);
+						done(null);
+					});
+
+				return loader;
+			});
+
+			if (result === null) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			// Let user edit the generated prompt
+			const editedPrompt = await ctx.ui.editor("Edit handoff prompt", result);
+
+			if (editedPrompt === undefined) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			// Create new session with parent tracking
+			const newSessionResult = await ctx.newSession({
+				parentSession: currentSessionFile,
+			});
+
+			if (newSessionResult.cancelled) {
+				ctx.ui.notify("New session cancelled", "info");
+				return;
+			}
+
+			// Set the edited prompt in the main editor for submission
+			ctx.ui.setEditorText(editedPrompt);
+			ctx.ui.notify("Handoff ready. Submit when ready.", "info");
+		},
+	});
+}

package/examples/extensions/hello.ts

@@ -0,0 +1,25 @@
+/**
+ * Hello Tool - Minimal custom tool example
+ */
+
+import { Type } from "@lenylvt/pi-ai";
+import type { ExtensionAPI } from "@lenylvt/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "hello",
+		label: "Hello",
+		description: "A simple greeting tool",
+		parameters: Type.Object({
+			name: Type.String({ description: "Name to greet" }),
+		}),
+
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const { name } = params as { name: string };
+			return {
+				content: [{ type: "text", text: `Hello, ${name}!` }],
+				details: { greeted: name },
+			};
+		},
+	});
+}

package/examples/extensions/hidden-thinking-label.ts

@@ -0,0 +1,57 @@
+/**
+ * Hidden Thinking Label Extension
+ *
+ * Demonstrates `ctx.ui.setHiddenThinkingLabel()` for customizing the label shown
+ * when thinking blocks are hidden.
+ *
+ * Usage:
+ *   pi --extension examples/extensions/hidden-thinking-label.ts
+ *
+ * Test:
+ *   1. Load this extension
+ *   2. Hide thinking blocks with Ctrl+T
+ *   3. Ask for something that produces reasoning output
+ *   4. The collapsed thinking block label will show the custom text
+ *
+ * Commands:
+ *   /thinking-label <text>   Set a custom hidden thinking label
+ *   /thinking-label          Reset to the default label
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@lenylvt/pi-coding-agent";
+
+const DEFAULT_LABEL = "Pondering...";
+
+export default function (pi: ExtensionAPI) {
+	let label = DEFAULT_LABEL;
+
+	const applyLabel = (ctx: ExtensionContext) => {
+		ctx.ui.setHiddenThinkingLabel(label);
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		applyLabel(ctx);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		applyLabel(ctx);
+	});
+
+	pi.registerCommand("thinking-label", {
+		description: "Set the hidden thinking label. Use without args to reset.",
+		handler: async (args, ctx) => {
+			const nextLabel = args.trim();
+
+			if (!nextLabel) {
+				label = DEFAULT_LABEL;
+				ctx.ui.setHiddenThinkingLabel();
+				ctx.ui.notify(`Hidden thinking label reset to: ${DEFAULT_LABEL}`);
+				return;
+			}
+
+			label = nextLabel;
+			ctx.ui.setHiddenThinkingLabel(label);
+			ctx.ui.notify(`Hidden thinking label set to: ${label}`);
+		},
+	});
+}

package/examples/extensions/inline-bash.ts

@@ -0,0 +1,94 @@
+/**
+ * Inline Bash Extension - expands inline bash commands in user prompts.
+ *
+ * Start pi with this extension:
+ *   pi -e ./examples/extensions/inline-bash.ts
+ *
+ * Then type prompts with inline bash:
+ *   What's in !{pwd}?
+ *   The current branch is !{git branch --show-current} and status: !{git status --short}
+ *   My node version is !{node --version}
+ *
+ * The !{command} patterns are executed and replaced with their output before
+ * the prompt is sent to the agent.
+ *
+ * Note: Regular !command syntax (whole-line bash) is preserved and works as before.
+ */
+import type { ExtensionAPI } from "@lenylvt/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	const PATTERN = /!\{([^}]+)\}/g;
+	const TIMEOUT_MS = 30000;
+
+	pi.on("input", async (event, ctx) => {
+		const text = event.text;
+
+		// Don't process if it's a whole-line bash command (starts with !)
+		// This preserves the existing !command behavior
+		if (text.trimStart().startsWith("!") && !text.trimStart().startsWith("!{")) {
+			return { action: "continue" };
+		}
+
+		// Check if there are any inline bash patterns
+		if (!PATTERN.test(text)) {
+			return { action: "continue" };
+		}
+
+		// Reset regex state after test()
+		PATTERN.lastIndex = 0;
+
+		let result = text;
+		const expansions: Array<{ command: string; output: string; error?: string }> = [];
+
+		// Find all matches first (to avoid issues with replacing while iterating)
+		const matches: Array<{ full: string; command: string }> = [];
+		let match = PATTERN.exec(text);
+		while (match) {
+			matches.push({ full: match[0], command: match[1] });
+			match = PATTERN.exec(text);
+		}
+
+		// Execute each command and collect results
+		for (const { full, command } of matches) {
+			try {
+				const bashResult = await pi.exec("bash", ["-c", command], {
+					timeout: TIMEOUT_MS,
+				});
+
+				const output = bashResult.stdout || bashResult.stderr || "";
+				const trimmed = output.trim();
+
+				if (bashResult.code !== 0 && bashResult.stderr) {
+					expansions.push({
+						command,
+						output: trimmed,
+						error: `exit code ${bashResult.code}`,
+					});
+				} else {
+					expansions.push({ command, output: trimmed });
+				}
+
+				result = result.replace(full, trimmed);
+			} catch (err) {
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				expansions.push({ command, output: "", error: errorMsg });
+				result = result.replace(full, `[error: ${errorMsg}]`);
+			}
+		}
+
+		// Show what was expanded (if UI available)
+		if (ctx.hasUI && expansions.length > 0) {
+			const summary = expansions
+				.map((e) => {
+					const status = e.error ? ` (${e.error})` : "";
+					const preview = e.output.length > 50 ? `${e.output.slice(0, 50)}...` : e.output;
+					return `!{${e.command}}${status} -> "${preview}"`;
+				})
+				.join("\n");
+
+			ctx.ui.notify(`Expanded ${expansions.length} inline command(s):\n${summary}`, "info");
+		}
+
+		return { action: "transform", text: result, images: event.images };
+	});
+}

package/examples/extensions/input-transform.ts

@@ -0,0 +1,43 @@
+/**
+ * Input Transform Example - demonstrates the `input` event for intercepting user input.
+ *
+ * Start pi with this extension:
+ *   pi -e ./examples/extensions/input-transform.ts
+ *
+ * Then type these inside pi:
+ *   ?quick What is TypeScript?  → "Respond briefly: What is TypeScript?"
+ *   ping                        → "pong" (instant, no LLM)
+ *   time                        → current time (instant, no LLM)
+ */
+import type { ExtensionAPI } from "@lenylvt/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	pi.on("input", async (event, ctx) => {
+		// Source-based logic: skip processing for extension-injected messages
+		if (event.source === "extension") {
+			return { action: "continue" };
+		}
+
+		// Transform: ?quick prefix for brief responses
+		if (event.text.startsWith("?quick ")) {
+			const query = event.text.slice(7).trim();
+			if (!query) {
+				ctx.ui.notify("Usage: ?quick <question>", "warning");
+				return { action: "handled" };
+			}
+			return { action: "transform", text: `Respond briefly in 1-2 sentences: ${query}` };
+		}
+
+		// Handle: instant responses without LLM (extension shows its own feedback)
+		if (event.text.toLowerCase() === "ping") {
+			ctx.ui.notify("pong", "info");
+			return { action: "handled" };
+		}
+		if (event.text.toLowerCase() === "time") {
+			ctx.ui.notify(new Date().toLocaleString(), "info");
+			return { action: "handled" };
+		}
+
+		return { action: "continue" };
+	});
+}

package/examples/extensions/interactive-shell.ts

@@ -0,0 +1,196 @@
+/**
+ * Interactive Shell Commands Extension
+ *
+ * Enables running interactive commands (vim, git rebase -i, htop, etc.)
+ * with full terminal access. The TUI suspends while they run.
+ *
+ * Usage:
+ *   pi -e examples/extensions/interactive-shell.ts
+ *
+ *   !vim file.txt        # Auto-detected as interactive
+ *   !i any-command       # Force interactive mode with !i prefix
+ *   !git rebase -i HEAD~3
+ *   !htop
+ *
+ * Configuration via environment variables:
+ *   INTERACTIVE_COMMANDS - Additional commands (comma-separated)
+ *   INTERACTIVE_EXCLUDE  - Commands to exclude (comma-separated)
+ *
+ * Note: This only intercepts user `!` commands, not agent bash tool calls.
+ * If the agent runs an interactive command, it will fail (which is fine).
+ */
+
+import { spawnSync } from "node:child_process";
+import type { ExtensionAPI } from "@lenylvt/pi-coding-agent";
+
+// Default interactive commands - editors, pagers, git ops, TUIs
+const DEFAULT_INTERACTIVE_COMMANDS = [
+	// Editors
+	"vim",
+	"nvim",
+	"vi",
+	"nano",
+	"emacs",
+	"pico",
+	"micro",
+	"helix",
+	"hx",
+	"kak",
+	// Pagers
+	"less",
+	"more",
+	"most",
+	// Git interactive
+	"git commit",
+	"git rebase",
+	"git merge",
+	"git cherry-pick",
+	"git revert",
+	"git add -p",
+	"git add --patch",
+	"git add -i",
+	"git add --interactive",
+	"git stash -p",
+	"git stash --patch",
+	"git reset -p",
+	"git reset --patch",
+	"git checkout -p",
+	"git checkout --patch",
+	"git difftool",
+	"git mergetool",
+	// System monitors
+	"htop",
+	"top",
+	"btop",
+	"glances",
+	// File managers
+	"ranger",
+	"nnn",
+	"lf",
+	"mc",
+	"vifm",
+	// Git TUIs
+	"tig",
+	"lazygit",
+	"gitui",
+	// Fuzzy finders
+	"fzf",
+	"sk",
+	// Remote sessions
+	"ssh",
+	"telnet",
+	"mosh",
+	// Database clients
+	"psql",
+	"mysql",
+	"sqlite3",
+	"mongosh",
+	"redis-cli",
+	// Kubernetes/Docker
+	"kubectl edit",
+	"kubectl exec -it",
+	"docker exec -it",
+	"docker run -it",
+	// Other
+	"tmux",
+	"screen",
+	"ncdu",
+];
+
+function getInteractiveCommands(): string[] {
+	const additional =
+		process.env.INTERACTIVE_COMMANDS?.split(",")
+			.map((s) => s.trim())
+			.filter(Boolean) ?? [];
+	const excluded = new Set(process.env.INTERACTIVE_EXCLUDE?.split(",").map((s) => s.trim().toLowerCase()) ?? []);
+	return [...DEFAULT_INTERACTIVE_COMMANDS, ...additional].filter((cmd) => !excluded.has(cmd.toLowerCase()));
+}
+
+function isInteractiveCommand(command: string): boolean {
+	const trimmed = command.trim().toLowerCase();
+	const commands = getInteractiveCommands();
+
+	for (const cmd of commands) {
+		const cmdLower = cmd.toLowerCase();
+		// Match at start
+		if (trimmed === cmdLower || trimmed.startsWith(`${cmdLower} `) || trimmed.startsWith(`${cmdLower}\t`)) {
+			return true;
+		}
+		// Match after pipe: "cat file | less"
+		const pipeIdx = trimmed.lastIndexOf("|");
+		if (pipeIdx !== -1) {
+			const afterPipe = trimmed.slice(pipeIdx + 1).trim();
+			if (afterPipe === cmdLower || afterPipe.startsWith(`${cmdLower} `)) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("user_bash", async (event, ctx) => {
+		let command = event.command;
+		let forceInteractive = false;
+
+		// Check for !i prefix (command comes without the leading !)
+		// The prefix parsing happens before this event, so we check if command starts with "i "
+		if (command.startsWith("i ") || command.startsWith("i\t")) {
+			forceInteractive = true;
+			command = command.slice(2).trim();
+		}
+
+		const shouldBeInteractive = forceInteractive || isInteractiveCommand(command);
+		if (!shouldBeInteractive) {
+			return; // Let normal handling proceed
+		}
+
+		// No UI available (print mode, RPC, etc.)
+		if (!ctx.hasUI) {
+			return {
+				result: { output: "(interactive commands require TUI)", exitCode: 1, cancelled: false, truncated: false },
+			};
+		}
+
+		// Use ctx.ui.custom() to get TUI access, then run the command
+		const exitCode = await ctx.ui.custom<number | null>((tui, _theme, _kb, done) => {
+			// Stop TUI to release terminal
+			tui.stop();
+
+			// Clear screen
+			process.stdout.write("\x1b[2J\x1b[H");
+
+			// Run command with full terminal access
+			const shell = process.env.SHELL || "/bin/sh";
+			const result = spawnSync(shell, ["-c", command], {
+				stdio: "inherit",
+				env: process.env,
+			});
+
+			// Restart TUI
+			tui.start();
+			tui.requestRender(true);
+
+			// Signal completion
+			done(result.status);
+
+			// Return empty component (immediately disposed since done() was called)
+			return { render: () => [], invalidate: () => {} };
+		});
+
+		// Return result to prevent default bash handling
+		const output =
+			exitCode === 0
+				? "(interactive command completed successfully)"
+				: `(interactive command exited with code ${exitCode})`;
+
+		return {
+			result: {
+				output,
+				exitCode: exitCode ?? 1,
+				cancelled: false,
+				truncated: false,
+			},
+		};
+	});
+}

package/examples/extensions/mac-system-theme.ts

@@ -0,0 +1,47 @@
+/**
+ * Syncs pi theme with macOS system appearance (dark/light mode).
+ *
+ * Usage:
+ *   pi -e examples/extensions/mac-system-theme.ts
+ */
+
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import type { ExtensionAPI } from "@lenylvt/pi-coding-agent";
+
+const execAsync = promisify(exec);
+
+async function isDarkMode(): Promise<boolean> {
+	try {
+		const { stdout } = await execAsync(
+			"osascript -e 'tell application \"System Events\" to tell appearance preferences to return dark mode'",
+		);
+		return stdout.trim() === "true";
+	} catch {
+		return false;
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	let intervalId: ReturnType<typeof setInterval> | null = null;
+
+	pi.on("session_start", async (_event, ctx) => {
+		let currentTheme = (await isDarkMode()) ? "dark" : "light";
+		ctx.ui.setTheme(currentTheme);
+
+		intervalId = setInterval(async () => {
+			const newTheme = (await isDarkMode()) ? "dark" : "light";
+			if (newTheme !== currentTheme) {
+				currentTheme = newTheme;
+				ctx.ui.setTheme(currentTheme);
+			}
+		}, 2000);
+	});
+
+	pi.on("session_shutdown", () => {
+		if (intervalId) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+	});
+}