@openeryc/pi-coding-agent 0.75.28 → 0.75.30

package/examples/extensions/doom-overlay/wad-finder.ts

@@ -0,0 +1,51 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Get the bundled WAD path (relative to this module)
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_WAD = join(__dirname, "doom1.wad");
+const WAD_URL = "https://distro.ibiblio.org/slitaz/sources/packages/d/doom1.wad";
+
+const DEFAULT_WAD_PATHS = ["./doom1.wad", "./DOOM1.WAD", "~/doom1.wad", "~/.doom/doom1.wad"];
+
+export function findWadFile(customPath?: string): string | null {
+	if (customPath) {
+		const resolved = resolve(customPath.replace(/^~/, process.env.HOME || ""));
+		if (existsSync(resolved)) return resolved;
+		return null;
+	}
+
+	// Check bundled WAD first
+	if (existsSync(BUNDLED_WAD)) {
+		return BUNDLED_WAD;
+	}
+
+	// Fall back to default paths
+	for (const p of DEFAULT_WAD_PATHS) {
+		const resolved = resolve(p.replace(/^~/, process.env.HOME || ""));
+		if (existsSync(resolved)) return resolved;
+	}
+
+	return null;
+}
+
+/** Download the shareware WAD if not present. Returns path or null on failure. */
+export async function ensureWadFile(): Promise<string | null> {
+	// Check if already exists
+	const existing = findWadFile();
+	if (existing) return existing;
+
+	// Download to bundled location
+	try {
+		const response = await fetch(WAD_URL);
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}`);
+		}
+		const buffer = await response.arrayBuffer();
+		writeFileSync(BUNDLED_WAD, Buffer.from(buffer));
+		return BUNDLED_WAD;
+	} catch {
+		return null;
+	}
+}

package/examples/extensions/github-issue-autocomplete.ts

@@ -0,0 +1,185 @@
+// Requires GitHub CLI (`gh`) and a GitHub repository checkout.
+// Preloads the latest open issues once per session, then filters them locally for fast `#...` completion.
+
+import type { ExtensionAPI } from "@openeryc/pi-coding-agent";
+import {
+	type AutocompleteItem,
+	type AutocompleteProvider,
+	type AutocompleteSuggestions,
+	fuzzyFilter,
+} from "@openeryc/pi-tui";
+
+type GitHubIssue = {
+	number: number;
+	title: string;
+	state: string;
+};
+
+type RepoResolution = { ok: true; repo: string } | { ok: false; error: string };
+
+const MAX_ISSUES = 100;
+const MAX_SUGGESTIONS = 20;
+
+function extractIssueToken(textBeforeCursor: string): string | undefined {
+	const match = textBeforeCursor.match(/(?:^|[ \t])#([^\s#]*)$/);
+	return match?.[1];
+}
+
+function parseGitHubRepo(remoteUrl: string): string | undefined {
+	const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+\/[^/]+?)(?:\.git)?$/);
+	if (sshMatch) {
+		return sshMatch[1];
+	}
+
+	const httpsMatch = remoteUrl.match(/^https?:\/\/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+	if (httpsMatch) {
+		return httpsMatch[1];
+	}
+
+	return undefined;
+}
+
+async function resolveGitHubRepo(pi: ExtensionAPI, cwd: string): Promise<RepoResolution> {
+	const result = await pi.exec("git", ["remote", "-v"], { cwd, timeout: 5_000 });
+	if (result.code !== 0) {
+		return { ok: false, error: "github-issue-autocomplete: cwd is not a git repository" };
+	}
+
+	for (const line of result.stdout.split("\n")) {
+		const columns = line.trim().split(/\s+/);
+		const remoteUrl = columns[1];
+		if (!remoteUrl) {
+			continue;
+		}
+		const repo = parseGitHubRepo(remoteUrl);
+		if (repo) {
+			return { ok: true, repo };
+		}
+	}
+
+	return { ok: false, error: "github-issue-autocomplete: cwd is not a GitHub repository" };
+}
+
+function formatIssueItem(issue: GitHubIssue): AutocompleteItem {
+	return {
+		value: `#${issue.number}`,
+		label: `#${issue.number}`,
+		description: `[${issue.state.toLowerCase()}] ${issue.title}`,
+	};
+}
+
+function filterIssues(issues: GitHubIssue[], query: string): AutocompleteItem[] {
+	if (!query.trim()) {
+		return issues.slice(0, MAX_SUGGESTIONS).map(formatIssueItem);
+	}
+
+	if (/^\d+$/.test(query)) {
+		const numericMatches = issues
+			.filter((issue) => String(issue.number).startsWith(query))
+			.slice(0, MAX_SUGGESTIONS)
+			.map(formatIssueItem);
+		if (numericMatches.length > 0) {
+			return numericMatches;
+		}
+	}
+
+	return fuzzyFilter(issues, query, (issue) => `${issue.number} ${issue.title}`)
+		.slice(0, MAX_SUGGESTIONS)
+		.map(formatIssueItem);
+}
+
+function createIssueAutocompleteProvider(
+	current: AutocompleteProvider,
+	getIssues: () => Promise<GitHubIssue[] | undefined>,
+): AutocompleteProvider {
+	return {
+		async getSuggestions(lines, cursorLine, cursorCol, options): Promise<AutocompleteSuggestions | null> {
+			const currentLine = lines[cursorLine] ?? "";
+			const textBeforeCursor = currentLine.slice(0, cursorCol);
+			const token = extractIssueToken(textBeforeCursor);
+			if (token === undefined) {
+				return current.getSuggestions(lines, cursorLine, cursorCol, options);
+			}
+
+			const issues = await getIssues();
+			if (options.signal.aborted || !issues || issues.length === 0) {
+				return current.getSuggestions(lines, cursorLine, cursorCol, options);
+			}
+
+			const suggestions = filterIssues(issues, token);
+			if (suggestions.length === 0) {
+				return current.getSuggestions(lines, cursorLine, cursorCol, options);
+			}
+
+			return {
+				items: suggestions,
+				prefix: `#${token}`,
+			};
+		},
+
+		applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+			return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+		},
+
+		shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+			return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+		},
+	};
+}
+
+export default function (pi: ExtensionAPI): void {
+	pi.on("session_start", async (_event, ctx) => {
+		const resolvedRepo = await resolveGitHubRepo(pi, ctx.cwd);
+		if (!resolvedRepo.ok) {
+			ctx.ui.notify(resolvedRepo.error, "error");
+			return;
+		}
+
+		const repo = resolvedRepo.repo;
+		let issuesPromise: Promise<GitHubIssue[] | undefined> | undefined;
+		let loadErrorShown = false;
+
+		const getIssues = async (): Promise<GitHubIssue[] | undefined> => {
+			issuesPromise ||= (async () => {
+				const result = await pi.exec(
+					"gh",
+					[
+						"issue",
+						"list",
+						"--repo",
+						repo,
+						"--state",
+						"open",
+						"--limit",
+						String(MAX_ISSUES),
+						"--json",
+						"number,title,state",
+					],
+					{ cwd: ctx.cwd, timeout: 5_000 },
+				);
+				if (result.code !== 0) {
+					if (!loadErrorShown) {
+						loadErrorShown = true;
+						const details = result.stderr.trim() || `exit code ${result.code}`;
+						ctx.ui.notify(`github-issue-autocomplete: failed to load issues: ${details}`, "error");
+					}
+					return undefined;
+				}
+
+				try {
+					return JSON.parse(result.stdout) as GitHubIssue[];
+				} catch {
+					if (!loadErrorShown) {
+						loadErrorShown = true;
+						ctx.ui.notify("github-issue-autocomplete: failed to parse gh issue list output", "error");
+					}
+					return undefined;
+				}
+			})();
+			return issuesPromise;
+		};
+
+		void getIssues();
+		ctx.ui.addAutocompleteProvider((current) => createIssueAutocompleteProvider(current, getIssues));
+	});
+}

package/examples/extensions/handoff.ts

@@ -0,0 +1,191 @@
+/**
+ * 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 type { AgentMessage } from "@openeryc/pi-agent-core";
+import { complete, type Message } from "@openeryc/pi-ai";
+import type { ExtensionAPI, SessionEntry } from "@openeryc/pi-coding-agent";
+import { BorderedLoader, convertToLlm, serializeConversation } from "@openeryc/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]`;
+
+function entryToMessage(entry: SessionEntry): AgentMessage | undefined {
+	if (entry.type === "message") {
+		return entry.message;
+	}
+	if (entry.type === "compaction") {
+		return {
+			role: "compactionSummary",
+			summary: entry.summary,
+			tokensBefore: entry.tokensBefore,
+			timestamp: new Date(entry.timestamp).getTime(),
+		};
+	}
+	return undefined;
+}
+
+function getHandoffMessages(branch: SessionEntry[]): AgentMessage[] {
+	let compactionIndex = -1;
+	for (let i = branch.length - 1; i >= 0; i--) {
+		if (branch[i].type === "compaction") {
+			compactionIndex = i;
+			break;
+		}
+	}
+	if (compactionIndex < 0) {
+		return branch.map(entryToMessage).filter((message) => message !== undefined);
+	}
+
+	const compaction = branch[compactionIndex];
+	const firstKeptIndex =
+		compaction.type === "compaction" ? branch.findIndex((entry) => entry.id === compaction.firstKeptEntryId) : -1;
+	const compactedBranch = [
+		compaction,
+		...(firstKeptIndex >= 0 ? branch.slice(firstKeptIndex, compactionIndex) : []),
+		...branch.slice(compactionIndex + 1),
+	];
+	return compactedBranch.map(entryToMessage).filter((message) => message !== undefined);
+}
+
+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. If the branch was compacted,
+			// include the compaction summary plus entries from firstKeptEntryId onward.
+			const messages = getHandoffMessages(ctx.sessionManager.getBranch());
+
+			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. Use the replacement-session
+			// context for post-switch UI work; the original ctx is stale after a
+			// successful session replacement.
+			const newSessionResult = await ctx.newSession({
+				parentSession: currentSessionFile,
+				withSession: async (replacementCtx) => {
+					replacementCtx.ui.setEditorText(editedPrompt);
+					replacementCtx.ui.notify("Handoff ready. Submit when ready.", "info");
+				},
+			});
+
+			if (newSessionResult.cancelled) {
+				ctx.ui.notify("New session cancelled", "info");
+			}
+		},
+	});
+}

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 "@openeryc/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/message-renderer.ts

@@ -0,0 +1,59 @@
+/**
+ * Custom message rendering example.
+ *
+ * Shows how to use registerMessageRenderer to control how custom messages
+ * appear in the TUI, with colors, formatting, and expandable details.
+ *
+ * Usage: /status [message] - sends a status message with custom rendering
+ */
+
+import type { ExtensionAPI } from "@openeryc/pi-coding-agent";
+import { Box, Text } from "@openeryc/pi-tui";
+
+export default function (pi: ExtensionAPI) {
+	// Register custom renderer for "status-update" messages
+	pi.registerMessageRenderer("status-update", (message, { expanded }, theme) => {
+		const details = message.details as { level: string; timestamp: number } | undefined;
+		const level = details?.level ?? "info";
+
+		// Color based on level
+		const color = level === "error" ? "error" : level === "warn" ? "warning" : "success";
+		const prefix = theme.fg(color, `[${level.toUpperCase()}]`);
+
+		let text = `${prefix} ${message.content}`;
+
+		// Show timestamp when expanded
+		if (expanded && details?.timestamp) {
+			const time = new Date(details.timestamp).toLocaleTimeString();
+			text += `\n${theme.fg("dim", `  at ${time}`)}`;
+		}
+
+		// Use Box with customMessageBg for consistent styling
+		const box = new Box(1, 1, (t) => theme.bg("customMessageBg", t));
+		box.addChild(new Text(text, 0, 0));
+		return box;
+	});
+
+	// Command to send status messages
+	pi.registerCommand("status", {
+		description: "Send a status message (usage: /status [warn|error] message)",
+		handler: async (args, _ctx) => {
+			const parts = args.trim().split(/\s+/);
+			let level = "info";
+			let content = args.trim();
+
+			// Check for level prefix
+			if (parts[0] === "warn" || parts[0] === "error") {
+				level = parts[0];
+				content = parts.slice(1).join(" ") || "Status update";
+			}
+
+			pi.sendMessage({
+				customType: "status-update",
+				content,
+				display: true,
+				details: { level, timestamp: Date.now() },
+			});
+		},
+	});
+}