@greppleai/grip 0.0.0-stage → 0.0.1

package/examples/extensions/auto-commit-on-exit.ts

@@ -0,0 +1,46 @@
+/**
+ * Auto-Commit on Exit Extension
+ *
+ * Automatically commits changes when the agent exits.
+ * Uses the last assistant message to generate a commit message.
+ */
+
+import type { ExtensionAPI, SessionEntry } from "@greppleai/grip";
+
+function findLastAssistantText(entries: SessionEntry[]): string {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		const content = entry.message.content;
+		if (!Array.isArray(content)) return "";
+		return content.flatMap((item) => (item.type === "text" ? [item.text] : [])).join("\n");
+	}
+	return "";
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("session_shutdown", async (_event, ctx) => {
+		// Check for uncommitted changes
+		const { stdout: status, code } = await pi.exec("git", ["status", "--porcelain"]);
+
+		if (code !== 0 || status.trim().length === 0) {
+			// Not a git repo or no changes
+			return;
+		}
+
+		// Find the last assistant message for commit context
+		const lastAssistantText = findLastAssistantText(ctx.session.getEntries());
+
+		// Generate a simple commit message
+		const firstLine = lastAssistantText.split("\n")[0] || "Work in progress";
+		const commitMessage = `[grip] ${firstLine.slice(0, 50)}${firstLine.length > 50 ? "..." : ""}`;
+
+		// Stage and commit
+		await pi.exec("git", ["add", "-A"]);
+		const { code: commitCode } = await pi.exec("git", ["commit", "-m", commitMessage]);
+
+		if (commitCode === 0 && ctx.hasUI) {
+			ctx.ui.notify(`Auto-committed: ${commitMessage}`, "info");
+		}
+	});
+}

package/examples/extensions/bash-spawn-hook.ts

@@ -0,0 +1,30 @@
+/**
+ * Bash Spawn Hook Example
+ *
+ * Adjusts command, cwd, and env before execution.
+ *
+ * Usage:
+ *   grip -e ./bash-spawn-hook.ts
+ */
+
+import type { ExtensionAPI } from "@greppleai/grip";
+import { createBashTool, LocalToolOperations } from "@greppleai/grip";
+
+export default function (pi: ExtensionAPI) {
+	const cwd = process.cwd();
+
+	const bashTool = createBashTool(new LocalToolOperations(cwd), {
+		spawnHook: ({ command, cwd, env }) => ({
+			command: `source ~/.profile\n${command}`,
+			cwd,
+			env: { ...env, GRIP_SPAWN_HOOK: "1" },
+		}),
+	});
+
+	pi.registerTool({
+		...bashTool,
+		execute: async (id, params, signal, onUpdate, _ctx) => {
+			return bashTool.execute(id, params, signal, onUpdate);
+		},
+	});
+}

package/examples/extensions/bookmark.ts

@@ -0,0 +1,50 @@
+/**
+ * Entry bookmarking example.
+ *
+ * Shows setLabel to mark entries with labels for easy navigation in /tree.
+ * Labels appear in the tree view and help you find important points.
+ *
+ * Usage: /bookmark [label] - bookmark the last assistant message
+ */
+
+import type { ExtensionAPI } from "@greppleai/grip";
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("bookmark", {
+		description: "Bookmark last message (usage: /bookmark [label])",
+		handler: async (args, ctx) => {
+			const label = args.trim() || `bookmark-${Date.now()}`;
+
+			// Find the last assistant message entry
+			const entries = ctx.session.getEntries();
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				if (entry.type === "message" && entry.message.role === "assistant") {
+					pi.setLabel(entry.id, label);
+					ctx.ui.notify(`Bookmarked as: ${label}`, "info");
+					return;
+				}
+			}
+
+			ctx.ui.notify("No assistant message to bookmark", "warning");
+		},
+	});
+
+	// Remove bookmark
+	pi.registerCommand("unbookmark", {
+		description: "Remove bookmark from last labeled entry",
+		handler: async (_args, ctx) => {
+			const entries = ctx.session.getEntries();
+			for (let i = entries.length - 1; i >= 0; i--) {
+				const entry = entries[i];
+				const label = ctx.session.getLabel(entry.id);
+				if (label) {
+					pi.setLabel(entry.id, undefined);
+					ctx.ui.notify(`Removed bookmark: ${label}`, "info");
+					return;
+				}
+			}
+			ctx.ui.notify("No bookmarked entry found", "warning");
+		},
+	});
+}

package/examples/extensions/border-status-editor.ts

@@ -0,0 +1,145 @@
+import { CustomEditor, type ExtensionAPI, type ExtensionContext, type KeybindingsManager } from "@greppleai/grip";
+import type { Component, EditorTheme, TUI } from "@greppleai/grip-tui";
+import { truncateToWidth, visibleWidth } from "@greppleai/grip-tui";
+
+function fitBorder(
+	left: string,
+	right: string,
+	width: number,
+	border: (text: string) => string,
+	fill: (text: string) => string = border,
+): string {
+	if (width <= 0) return "";
+	if (width === 1) return border("─");
+
+	let leftText = left;
+	let rightText = right;
+	const fixedWidth = 2;
+	const minimumGap = 3;
+
+	while (
+		fixedWidth + visibleWidth(leftText) + visibleWidth(rightText) + minimumGap > width &&
+		visibleWidth(rightText) > 0
+	) {
+		rightText = truncateToWidth(rightText, Math.max(0, visibleWidth(rightText) - 1), "");
+	}
+	while (
+		fixedWidth + visibleWidth(leftText) + visibleWidth(rightText) + minimumGap > width &&
+		visibleWidth(leftText) > 0
+	) {
+		leftText = truncateToWidth(leftText, Math.max(0, visibleWidth(leftText) - 1), "");
+	}
+
+	const gapWidth = Math.max(0, width - fixedWidth - visibleWidth(leftText) - visibleWidth(rightText));
+	return `${border("─")}${leftText}${fill("─".repeat(gapWidth))}${rightText}${border("─")}`;
+}
+
+function formatCwd(cwd: string): string {
+	const home = process.env.HOME;
+	if (home && cwd.startsWith(home)) {
+		return `~${cwd.slice(home.length)}`;
+	}
+	return cwd;
+}
+
+function formatContext(ctx: ExtensionContext): string {
+	const usage = ctx.getContextUsage();
+	const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow;
+	if (!contextWindow || !usage || usage.percent === null) {
+		return "ctx ?";
+	}
+	return `ctx ${Math.round(usage.percent)}%/${(contextWindow / 1000).toFixed(0)}k`;
+}
+
+function formatThinking(level: string): string {
+	return level === "off" ? "off" : level;
+}
+
+class EmptyFooter implements Component {
+	render(): string[] {
+		return [];
+	}
+
+	invalidate(): void {}
+}
+
+export default function (pi: ExtensionAPI) {
+	let isWorking = false;
+	let spinnerIndex = 0;
+	let spinnerTimer: ReturnType<typeof setInterval> | undefined;
+	let activeTui: TUI | undefined;
+	const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+	const stopSpinner = () => {
+		if (spinnerTimer) {
+			clearInterval(spinnerTimer);
+			spinnerTimer = undefined;
+		}
+	};
+
+	pi.on("agent_start", () => {
+		isWorking = true;
+		stopSpinner();
+		spinnerTimer = setInterval(() => {
+			spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+			activeTui?.requestRender();
+		}, 80);
+		activeTui?.requestRender();
+	});
+
+	pi.on("agent_end", () => {
+		isWorking = false;
+		stopSpinner();
+		activeTui?.requestRender();
+	});
+
+	pi.on("session_shutdown", () => {
+		stopSpinner();
+		activeTui = undefined;
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui.setWorkingVisible(false);
+		ctx.ui.setFooter(() => new EmptyFooter());
+
+		let branch: string | undefined;
+
+		const refreshBranch = async () => {
+			const result = await pi.exec("git", ["branch", "--show-current"], { cwd: ctx.cwd }).catch(() => undefined);
+			const stdout = result?.stdout.trim();
+			branch = stdout && stdout.length > 0 ? stdout : undefined;
+			activeTui?.requestRender();
+		};
+		void refreshBranch();
+
+		class BorderStatusEditor extends CustomEditor {
+			constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
+				super(tui, theme, keybindings, { paddingX: 0 });
+				activeTui = tui;
+			}
+
+			render(width: number): string[] {
+				const lines = super.render(width);
+				if (lines.length < 2) return lines;
+
+				const thm = ctx.ui.theme;
+				const model = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "no model";
+				const thinking = pi.getThinkingLevel();
+				const topLeft = isWorking ? thm.fg("accent", ` ${spinnerFrames[spinnerIndex]} `) : "";
+				const topRight = "";
+				const bottomLeft = thm.fg("muted", ` ${model} · ${formatThinking(thinking)} `);
+				const bottomRight = thm.fg(
+					"muted",
+					` ${formatContext(ctx)} · ${formatCwd(ctx.cwd)}${branch ? ` (${branch})` : ""} `,
+				);
+				const borderColor = (text: string) => this.borderColor(text);
+
+				lines[0] = fitBorder(topLeft, topRight, width, borderColor);
+				lines[lines.length - 1] = fitBorder(bottomLeft, bottomRight, width, borderColor);
+				return lines;
+			}
+		}
+
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => new BorderStatusEditor(tui, theme, keybindings));
+	});
+}

package/examples/extensions/built-in-tool-renderer.ts

@@ -0,0 +1,259 @@
+/**
+ * Built-in Tool Renderer Example - Custom rendering for built-in tools
+ *
+ * Demonstrates how to override the rendering of built-in tools (read, bash,
+ * edit, write) without changing their behavior. Each tool is re-registered
+ * with the same name, delegating execution to the original implementation
+ * while providing compact custom renderCall/renderResult functions.
+ *
+ * This is useful for users who prefer more concise tool output, or who want
+ * to highlight specific information (e.g., showing only the diff stats for
+ * edit, or just the exit code for bash).
+ *
+ * How it works:
+ * - registerTool() with the same name as a built-in replaces it entirely
+ * - We create instances of the original tools via createReadTool(), etc.
+ *   and delegate execute() to them
+ * - renderCall() controls what's shown when the tool is invoked
+ * - renderResult() controls what's shown after execution completes
+ * - renderShell: "self" lets a tool render its own outer shell instead of
+ *   using the default boxed shell from ToolExecutionComponent
+ * - The `expanded` flag in renderResult indicates whether the user has
+ *   toggled the tool output open (via ctrl+e or clicking)
+ *
+ * Usage:
+ *   grip -e ./built-in-tool-renderer.ts
+ */
+
+import type { BashToolDetails, EditToolDetails, ExtensionAPI, ReadToolDetails, Theme } from "@greppleai/grip";
+import { createBashTool, createEditTool, createReadTool, createWriteTool, LocalToolOperations } from "@greppleai/grip";
+import { Text } from "@greppleai/grip-tui";
+
+function appendExpandedBashOutput(summary: string, output: string, theme: Theme): string {
+	let text = summary;
+	const lines = output.split("\n");
+	for (const line of lines.slice(0, 20)) text += `\n${theme.fg("dim", line)}`;
+	if (lines.length > 20) text += `\n${theme.fg("muted", "... more output")}`;
+	return text;
+}
+
+interface DiffStats {
+	additions: number;
+	removals: number;
+}
+
+function countDiffStats(lines: string[]): DiffStats {
+	let additions = 0;
+	let removals = 0;
+	for (const line of lines) {
+		if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+		if (line.startsWith("-") && !line.startsWith("---")) removals++;
+	}
+	return { additions, removals };
+}
+
+function appendExpandedDiffOutput(summary: string, lines: string[], theme: Theme): string {
+	let text = summary;
+	for (const line of lines.slice(0, 30)) {
+		if (line.startsWith("+") && !line.startsWith("+++")) {
+			text += `\n${theme.fg("success", line)}`;
+		} else if (line.startsWith("-") && !line.startsWith("---")) {
+			text += `\n${theme.fg("error", line)}`;
+		} else {
+			text += `\n${theme.fg("dim", line)}`;
+		}
+	}
+	if (lines.length > 30) text += `\n${theme.fg("muted", `... ${lines.length - 30} more diff lines`)}`;
+	return text;
+}
+
+export default function (pi: ExtensionAPI) {
+	const cwd = process.cwd();
+	const operations = new LocalToolOperations(cwd);
+
+	// --- Read tool: show path and line count ---
+	const originalRead = createReadTool(operations);
+	pi.registerTool({
+		name: "read",
+		label: "read",
+		description: originalRead.description,
+		parameters: originalRead.parameters,
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalRead.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("read "));
+			text += theme.fg("accent", args.path);
+			if (args.offset || args.limit) {
+				const parts: string[] = [];
+				if (args.offset) parts.push(`offset=${args.offset}`);
+				if (args.limit) parts.push(`limit=${args.limit}`);
+				text += theme.fg("dim", ` (${parts.join(", ")})`);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded, isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Reading..."), 0, 0);
+
+			const details = result.details as ReadToolDetails | undefined;
+			const content = result.content[0];
+
+			if (content?.type === "image") {
+				return new Text(theme.fg("success", "Image loaded"), 0, 0);
+			}
+
+			if (content?.type !== "text") {
+				return new Text(theme.fg("error", "No content"), 0, 0);
+			}
+
+			const lineCount = content.text.split("\n").length;
+			let text = theme.fg("success", `${lineCount} lines`);
+
+			if (details?.truncation?.truncated) {
+				text += theme.fg("warning", ` (truncated from ${details.truncation.totalLines})`);
+			}
+
+			if (expanded) {
+				const lines = content.text.split("\n").slice(0, 15);
+				text += lines.map((line) => `\n${theme.fg("dim", line)}`).join("");
+				if (lineCount > 15) {
+					text += `\n${theme.fg("muted", `... ${lineCount - 15} more lines`)}`;
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// --- Bash tool: show command and exit code ---
+	const originalBash = createBashTool(operations);
+	pi.registerTool({
+		name: "bash",
+		label: "bash",
+		description: originalBash.description,
+		parameters: originalBash.parameters,
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalBash.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("$ "));
+			const cmd = args.command.length > 80 ? `${args.command.slice(0, 77)}...` : args.command;
+			text += theme.fg("accent", cmd);
+			if (args.timeout) {
+				text += theme.fg("dim", ` (timeout: ${args.timeout}s)`);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded, isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Running..."), 0, 0);
+
+			const details = result.details as BashToolDetails | undefined;
+			const content = result.content[0];
+			const output = content?.type === "text" ? content.text : "";
+
+			const exitMatch = output.match(/exit code: (\d+)/);
+			const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : null;
+			const lineCount = output.split("\n").filter((l) => l.trim()).length;
+
+			let text = "";
+			if (exitCode === 0 || exitCode === null) {
+				text += theme.fg("success", "done");
+			} else {
+				text += theme.fg("error", `exit ${exitCode}`);
+			}
+			text += theme.fg("dim", ` (${lineCount} lines)`);
+
+			if (details?.truncation?.truncated) {
+				text += theme.fg("warning", " [truncated]");
+			}
+
+			if (expanded) text = appendExpandedBashOutput(text, output, theme);
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// --- Edit tool: show path and diff stats ---
+	const originalEdit = createEditTool(operations);
+	pi.registerTool({
+		name: "edit",
+		label: "edit",
+		description: originalEdit.description,
+		parameters: originalEdit.parameters,
+		renderShell: "self",
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalEdit.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("edit "));
+			text += theme.fg("accent", args.path);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { expanded, isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Editing..."), 0, 0);
+
+			const details = result.details as EditToolDetails | undefined;
+			const content = result.content[0];
+
+			if (content?.type === "text" && content.text.startsWith("Error")) {
+				return new Text(theme.fg("error", content.text.split("\n")[0]), 0, 0);
+			}
+
+			if (!details?.diff) {
+				return new Text(theme.fg("success", "Applied"), 0, 0);
+			}
+
+			const diffLines = details.diff.split("\n");
+			const { additions, removals } = countDiffStats(diffLines);
+
+			let text = theme.fg("success", `+${additions}`);
+			text += theme.fg("dim", " / ");
+			text += theme.fg("error", `-${removals}`);
+
+			if (expanded) text = appendExpandedDiffOutput(text, diffLines, theme);
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// --- Write tool: show path and size ---
+	const originalWrite = createWriteTool(operations);
+	pi.registerTool({
+		name: "write",
+		label: "write",
+		description: originalWrite.description,
+		parameters: originalWrite.parameters,
+
+		async execute(toolCallId, params, signal, onUpdate) {
+			return originalWrite.execute(toolCallId, params, signal, onUpdate);
+		},
+
+		renderCall(args, theme, _context) {
+			let text = theme.fg("toolTitle", theme.bold("write "));
+			text += theme.fg("accent", args.path);
+			const lineCount = args.content.split("\n").length;
+			text += theme.fg("dim", ` (${lineCount} lines)`);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme, _context) {
+			if (isPartial) return new Text(theme.fg("warning", "Writing..."), 0, 0);
+
+			const content = result.content[0];
+			if (content?.type === "text" && content.text.startsWith("Error")) {
+				return new Text(theme.fg("error", content.text.split("\n")[0]), 0, 0);
+			}
+
+			return new Text(theme.fg("success", "Written"), 0, 0);
+		},
+	});
+}

package/examples/extensions/claude-rules.ts

@@ -0,0 +1,86 @@
+/**
+ * Claude Rules Extension
+ *
+ * Scans the project's .claude/rules/ folder for rule files and lists them
+ * in the system prompt. The agent can then use the read tool to load
+ * specific rules when needed.
+ *
+ * Best practices for .claude/rules/:
+ * - Keep rules focused: Each file should cover one topic (e.g., testing.md, api-design.md)
+ * - Use descriptive filenames: The filename should indicate what the rules cover
+ * - Use conditional rules sparingly: Only add paths frontmatter when rules truly apply to specific file types
+ * - Organize with subdirectories: Group related rules (e.g., frontend/, backend/)
+ *
+ * Usage:
+ * 1. Copy this file to ~/.grip/agent/extensions/ or your project's .grip/extensions/
+ * 2. Create .claude/rules/ folder in your project root
+ * 3. Add .md files with your rules
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@greppleai/grip";
+
+/**
+ * Recursively find all .md files in a directory
+ */
+function findMarkdownFiles(dir: string, basePath: string = ""): string[] {
+	const results: string[] = [];
+
+	if (!fs.existsSync(dir)) {
+		return results;
+	}
+
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+
+		if (entry.isDirectory()) {
+			results.push(...findMarkdownFiles(path.join(dir, entry.name), relativePath));
+		} else if (entry.isFile() && entry.name.endsWith(".md")) {
+			results.push(relativePath);
+		}
+	}
+
+	return results;
+}
+
+export default function claudeRulesExtension(pi: ExtensionAPI) {
+	let ruleFiles: string[] = [];
+	let rulesDir: string = "";
+
+	// Scan for rules on session start
+	pi.on("session_start", async (_event, ctx) => {
+		rulesDir = path.join(ctx.cwd, ".claude", "rules");
+		ruleFiles = findMarkdownFiles(rulesDir);
+
+		if (ruleFiles.length > 0) {
+			ctx.ui.notify(`Found ${ruleFiles.length} rule(s) in .claude/rules/`, "info");
+		}
+	});
+
+	// Append available rules to system prompt
+	pi.on("before_agent_start", async (event) => {
+		if (ruleFiles.length === 0) {
+			return;
+		}
+
+		const rulesList = ruleFiles.map((f) => `- .claude/rules/${f}`).join("\n");
+
+		return {
+			systemPrompt:
+				event.systemPrompt +
+				`
+
+## Project Rules
+
+The following project rules are available in .claude/rules/:
+
+${rulesList}
+
+When working on tasks related to these rules, use the read tool to load the relevant rule files for guidance.
+`,
+		};
+	});
+}

package/examples/extensions/commands.ts

@@ -0,0 +1,82 @@
+/**
+ * Commands Extension
+ *
+ * Demonstrates the grip extension API by providing a /commands command
+ * that lists all available slash commands in the current session.
+ *
+ * Usage:
+ * 1. Copy this file to ~/.grip/agent/extensions/ or your project's .grip/extensions/
+ * 2. Use /commands to see available commands
+ * 3. Use /commands extensions to filter by source
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext, SlashCommandInfo, SlashCommandSource } from "@greppleai/grip";
+
+interface CommandSourceGroup {
+	key: SlashCommandSource;
+	label: string;
+}
+
+const COMMAND_SOURCE_GROUPS: CommandSourceGroup[] = [
+	{ key: "extension", label: "Extensions" },
+	{ key: "prompt", label: "Prompts" },
+	{ key: "skill", label: "Skills" },
+];
+
+function buildCommandSelectionItems(commands: SlashCommandInfo[]): string[] {
+	const items: string[] = [];
+	const itemsBySource = new Map<SlashCommandSource, string[]>(COMMAND_SOURCE_GROUPS.map(({ key }) => [key, []]));
+	for (const command of commands) {
+		const description = command.description ? ` - ${command.description}` : "";
+		itemsBySource.get(command.source)?.push(`/${command.name}${description}`);
+	}
+	for (const { key, label } of COMMAND_SOURCE_GROUPS) {
+		const sourceItems = itemsBySource.get(key);
+		if (!sourceItems || sourceItems.length === 0) continue;
+		items.push(`--- ${label} ---`);
+		items.push(...sourceItems);
+	}
+	return items;
+}
+
+async function showSelectedCommandPath(
+	selected: string | undefined,
+	commands: SlashCommandInfo[],
+	ctx: ExtensionCommandContext,
+): Promise<void> {
+	if (!selected || selected.startsWith("---")) return;
+	const commandName = selected.split(" - ")[0].slice(1);
+	const command = commands.find((candidate) => candidate.name === commandName);
+	if (!command?.sourceInfo.path) return;
+	const showPath = await ctx.ui.confirm(command.name, `View source path?\n${command.sourceInfo.path}`);
+	if (showPath) ctx.ui.notify(command.sourceInfo.path, "info");
+}
+
+export default function commandsExtension(pi: ExtensionAPI) {
+	pi.registerCommand("commands", {
+		description: "List available slash commands",
+		getArgumentCompletions: (prefix) => {
+			const sources = ["extension", "prompt", "skill"];
+			const filtered = sources.filter((s) => s.startsWith(prefix));
+			return filtered.length > 0 ? filtered.map((s) => ({ value: s, label: s })) : null;
+		},
+		handler: async (args, ctx) => {
+			const commands = pi.getCommands();
+			const sourceFilter = args.trim() as "extension" | "prompt" | "skill" | "";
+
+			// Filter by source if specified
+			const filtered = sourceFilter ? commands.filter((c) => c.source === sourceFilter) : commands;
+
+			if (filtered.length === 0) {
+				ctx.ui.notify(sourceFilter ? `No ${sourceFilter} commands found` : "No commands found", "info");
+				return;
+			}
+
+			const items = buildCommandSelectionItems(filtered);
+
+			// Show in a selector (user can scroll and see all commands)
+			const selected = await ctx.ui.select("Available Commands", items);
+			await showSelectedCommandPath(selected, commands, ctx);
+		},
+	});
+}