@oh-my-pi/pi-coding-agent 12.7.5 → 12.8.0

package/src/slash-commands/builtin-registry.ts

@@ -0,0 +1,419 @@
+import type { SettingPath, SettingValue } from "../config/settings";
+import { settings } from "../config/settings";
+import type { InteractiveModeContext } from "../modes/types";
+
+/** Declarative subcommand definition for commands like /mcp. */
+export interface SubcommandDef {
+	name: string;
+	description: string;
+	/** Usage hint shown as dim ghost text, e.g. "<name> [--scope project|user]". */
+	usage?: string;
+}
+
+/** Declarative builtin slash command definition used by autocomplete and help UI. */
+export interface BuiltinSlashCommand {
+	name: string;
+	description: string;
+	/** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
+	subcommands?: SubcommandDef[];
+	/** Static inline hint when command takes a simple argument (no subcommands). */
+	inlineHint?: string;
+}
+
+interface ParsedBuiltinSlashCommand {
+	name: string;
+	args: string;
+	text: string;
+}
+
+interface BuiltinSlashCommandSpec extends BuiltinSlashCommand {
+	aliases?: string[];
+	allowArgs?: boolean;
+	handle: (command: ParsedBuiltinSlashCommand, runtime: BuiltinSlashCommandRuntime) => Promise<void> | void;
+}
+
+export interface BuiltinSlashCommandRuntime {
+	ctx: InteractiveModeContext;
+	handleBackgroundCommand: () => void;
+}
+
+function parseBuiltinSlashCommand(text: string): ParsedBuiltinSlashCommand | null {
+	if (!text.startsWith("/")) return null;
+	const body = text.slice(1);
+	if (!body) return null;
+
+	const firstWhitespace = body.search(/\s/);
+	if (firstWhitespace === -1) {
+		return {
+			name: body,
+			args: "",
+			text,
+		};
+	}
+
+	return {
+		name: body.slice(0, firstWhitespace),
+		args: body.slice(firstWhitespace).trim(),
+		text,
+	};
+}
+
+const shutdownHandler = (_command: ParsedBuiltinSlashCommand, runtime: BuiltinSlashCommandRuntime): void => {
+	runtime.ctx.editor.setText("");
+	void runtime.ctx.shutdown();
+};
+
+const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
+	{
+		name: "settings",
+		description: "Open settings menu",
+		handle: (_command, runtime) => {
+			runtime.ctx.showSettingsSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "plan",
+		description: "Toggle plan mode (agent plans before executing)",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handlePlanModeCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "model",
+		aliases: ["models"],
+		description: "Select model (opens selector UI)",
+		handle: (_command, runtime) => {
+			runtime.ctx.showModelSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "export",
+		description: "Export session to HTML file",
+		inlineHint: "[path]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			await runtime.ctx.handleExportCommand(command.text);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "dump",
+		description: "Copy session transcript to clipboard",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleDumpCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "share",
+		description: "Share session as a secret GitHub gist",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleShareCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "browser",
+		description: "Toggle browser headless vs visible mode",
+		subcommands: [
+			{ name: "headless", description: "Switch to headless mode" },
+			{ name: "visible", description: "Switch to visible mode" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const arg = command.args.toLowerCase();
+			const current = settings.get("browser.headless" as SettingPath) as boolean;
+			let next = current;
+			if (!(settings.get("browser.enabled" as SettingPath) as boolean)) {
+				runtime.ctx.showWarning("Browser tool is disabled (enable in settings)");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (!arg) {
+				next = !current;
+			} else if (["headless", "hidden"].includes(arg)) {
+				next = true;
+			} else if (["visible", "show", "headful"].includes(arg)) {
+				next = false;
+			} else {
+				runtime.ctx.showStatus("Usage: /browser [headless|visible]");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			settings.set("browser.headless" as SettingPath, next as SettingValue<SettingPath>);
+			const tool = runtime.ctx.session.getToolByName("browser");
+			if (tool && "restartForModeChange" in tool) {
+				try {
+					await (tool as { restartForModeChange: () => Promise<void> }).restartForModeChange();
+				} catch (error) {
+					runtime.ctx.showWarning(
+						`Failed to restart browser: ${error instanceof Error ? error.message : String(error)}`,
+					);
+					runtime.ctx.editor.setText("");
+					return;
+				}
+			}
+			runtime.ctx.showStatus(`Browser mode: ${next ? "headless" : "visible"}`);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "copy",
+		description: "Copy last agent message to clipboard",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleCopyCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "session",
+		description: "Show session info and stats",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleSessionCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "usage",
+		description: "Show provider usage and limits",
+		handle: async (_command, runtime) => {
+			await runtime.ctx.handleUsageCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "changelog",
+		description: "Show changelog entries",
+		subcommands: [{ name: "full", description: "Show complete changelog" }],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const showFull = command.args.split(/\s+/).filter(Boolean).includes("full");
+			await runtime.ctx.handleChangelogCommand(showFull);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "hotkeys",
+		description: "Show all keyboard shortcuts",
+		handle: (_command, runtime) => {
+			runtime.ctx.handleHotkeysCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "extensions",
+		aliases: ["status"],
+		description: "Open Extension Control Center dashboard",
+		handle: (_command, runtime) => {
+			runtime.ctx.showExtensionsDashboard();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "branch",
+		description: "Create a new branch from a previous message",
+		handle: (_command, runtime) => {
+			if (settings.get("doubleEscapeAction") === "tree") {
+				runtime.ctx.showTreeSelector();
+			} else {
+				runtime.ctx.showUserMessageSelector();
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "fork",
+		description: "Create a new fork from a previous message",
+		handle: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleForkCommand();
+		},
+	},
+	{
+		name: "tree",
+		description: "Navigate session tree (switch branches)",
+		handle: (_command, runtime) => {
+			runtime.ctx.showTreeSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "login",
+		description: "Login with OAuth provider",
+		handle: (_command, runtime) => {
+			void runtime.ctx.showOAuthSelector("login");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "logout",
+		description: "Logout from OAuth provider",
+		handle: (_command, runtime) => {
+			void runtime.ctx.showOAuthSelector("logout");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "mcp",
+		description: "Manage MCP servers (add, list, remove, test)",
+		subcommands: [
+			{
+				name: "add",
+				description: "Add a new MCP server",
+				usage: "<name> [--scope project|user] [--url <url>] [-- <command...>]",
+			},
+			{ name: "list", description: "List all configured MCP servers" },
+			{ name: "remove", description: "Remove an MCP server", usage: "<name> [--scope project|user]" },
+			{ name: "test", description: "Test connection to a server", usage: "<name>" },
+			{ name: "reauth", description: "Reauthorize OAuth for a server", usage: "<name>" },
+			{ name: "unauth", description: "Remove OAuth auth from a server", usage: "<name>" },
+			{ name: "enable", description: "Enable an MCP server", usage: "<name>" },
+			{ name: "disable", description: "Disable an MCP server", usage: "<name>" },
+			{ name: "reload", description: "Force reload MCP runtime tools" },
+			{ name: "help", description: "Show help message" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			runtime.ctx.editor.addToHistory(command.text);
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleMCPCommand(command.text);
+		},
+	},
+	{
+		name: "new",
+		description: "Start a new session",
+		handle: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleClearCommand();
+		},
+	},
+	{
+		name: "compact",
+		description: "Manually compact the session context",
+		inlineHint: "[focus instructions]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const customInstructions = command.args || undefined;
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleCompactCommand(customInstructions);
+		},
+	},
+	{
+		name: "handoff",
+		description: "Hand off session context to a new session",
+		inlineHint: "[focus instructions]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const customInstructions = command.args || undefined;
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleHandoffCommand(customInstructions);
+		},
+	},
+	{
+		name: "resume",
+		description: "Resume a different session",
+		handle: (_command, runtime) => {
+			runtime.ctx.showSessionSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "background",
+		aliases: ["bg"],
+		description: "Detach UI and continue running in background",
+		handle: (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			runtime.handleBackgroundCommand();
+		},
+	},
+	{
+		name: "debug",
+		description: "Write debug log (TUI state and messages)",
+		handle: (_command, runtime) => {
+			runtime.ctx.showDebugSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "memory",
+		description: "Inspect and operate memory maintenance",
+		subcommands: [
+			{ name: "view", description: "Show current memory injection payload" },
+			{ name: "clear", description: "Clear persisted memory data and artifacts" },
+			{ name: "reset", description: "Alias for clear" },
+			{ name: "enqueue", description: "Enqueue memory consolidation maintenance" },
+			{ name: "rebuild", description: "Alias for enqueue" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleMemoryCommand(command.text);
+		},
+	},
+	{
+		name: "move",
+		description: "Move session to a different working directory",
+		inlineHint: "<path>",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const targetPath = command.args;
+			if (!targetPath) {
+				runtime.ctx.showError("Usage: /move <path>");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleMoveCommand(targetPath);
+		},
+	},
+	{
+		name: "exit",
+		description: "Exit the application",
+		handle: shutdownHandler,
+	},
+	{
+		name: "quit",
+		description: "Quit the application",
+		handle: shutdownHandler,
+	},
+];
+
+const BUILTIN_SLASH_COMMAND_LOOKUP = new Map<string, BuiltinSlashCommandSpec>();
+for (const command of BUILTIN_SLASH_COMMAND_REGISTRY) {
+	BUILTIN_SLASH_COMMAND_LOOKUP.set(command.name, command);
+	for (const alias of command.aliases ?? []) {
+		BUILTIN_SLASH_COMMAND_LOOKUP.set(alias, command);
+	}
+}
+
+/** Builtin command metadata used for slash-command autocomplete and help text. */
+export const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand> = BUILTIN_SLASH_COMMAND_REGISTRY.map(
+	command => ({
+		name: command.name,
+		description: command.description,
+		subcommands: command.subcommands,
+		inlineHint: command.inlineHint,
+	}),
+);
+
+/**
+ * Execute a builtin slash command when it matches known command syntax.
+ *
+ * Returns true when a builtin command consumed the input; false otherwise.
+ */
+export async function executeBuiltinSlashCommand(text: string, runtime: BuiltinSlashCommandRuntime): Promise<boolean> {
+	const parsed = parseBuiltinSlashCommand(text);
+	if (!parsed) return false;
+
+	const command = BUILTIN_SLASH_COMMAND_LOOKUP.get(parsed.name);
+	if (!command) return false;
+	if (parsed.args.length > 0 && !command.allowArgs) {
+		return false;
+	}
+
+	await command.handle(parsed, runtime);
+	return true;
+}

package/src/web/scrapers/github.ts

@@ -11,6 +11,12 @@ interface GitHubUrl {
 	number?: number;
 }
 
+interface GitHubIssueComment {
+	user: { login: string };
+	created_at: string;
+	body: string;
+}
+
 /**
  * Parse GitHub URL into components
  */
@@ -105,6 +111,44 @@ export async function fetchGitHubApi(
 	}
 }
 
+/**
+ * Fetch all issue comments with pagination.
+ */
+async function fetchGitHubIssueComments(
+	owner: string,
+	repo: string,
+	issueNumber: number,
+	expectedCount: number,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<GitHubIssueComment[]> {
+	const perPage = 100;
+	const comments: GitHubIssueComment[] = [];
+
+	for (let page = 1; comments.length < expectedCount; page++) {
+		const result = await fetchGitHubApi(
+			`/repos/${owner}/${repo}/issues/${issueNumber}/comments?per_page=${perPage}&page=${page}`,
+			timeout,
+			signal,
+		);
+		if (!result.ok || !Array.isArray(result.data)) {
+			break;
+		}
+
+		const pageComments = result.data as GitHubIssueComment[];
+		if (pageComments.length === 0) {
+			break;
+		}
+
+		comments.push(...pageComments);
+		if (pageComments.length < perPage) {
+			break;
+		}
+	}
+
+	return comments;
+}
+
 /**
  * Render GitHub issue/PR to markdown
  */
@@ -146,18 +190,12 @@ async function renderGitHubIssue(
 
 	// Fetch comments if any
 	if (issue.comments > 0) {
-		const commentsResult = await fetchGitHubApi(
-			`/repos/${gh.owner}/${gh.repo}/issues/${gh.number}/comments?per_page=50`,
-			timeout,
-			signal,
-		);
-		if (commentsResult.ok && Array.isArray(commentsResult.data)) {
-			md += `## Comments (${issue.comments})\n\n`;
-			for (const comment of commentsResult.data as Array<{
-				user: { login: string };
-				created_at: string;
-				body: string;
-			}>) {
+		const comments = await fetchGitHubIssueComments(gh.owner, gh.repo, issue.number, issue.comments, timeout, signal);
+		if (comments.length > 0) {
+			const commentCount =
+				issue.comments > comments.length ? `${comments.length} of ${issue.comments}` : `${comments.length}`;
+			md += `## Comments (${commentCount})\n\n`;
+			for (const comment of comments) {
 				md += `### @${comment.user.login} · ${comment.created_at}\n\n`;
 				md += `${comment.body}\n\n---\n\n`;
 			}

package/src/web/search/index.ts

@@ -1,7 +1,7 @@
 /**
  * Unified Web Search Tool
  *
- * Single tool supporting Anthropic, Perplexity, Exa, Jina, Gemini, Codex, and Z.AI
+ * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Gemini, Codex, and Z.AI
  * providers with provider-specific parameters exposed conditionally.
  *
  * When EXA_API_KEY is available, additional specialized tools are exposed:
@@ -33,13 +33,13 @@ import { SearchProviderError } from "./types";
 export const webSearchSchema = Type.Object({
 	query: Type.String({ description: "Search query" }),
 	provider: Type.Optional(
-		StringEnum(["auto", "exa", "jina", "zai", "anthropic", "perplexity", "gemini", "codex"], {
+		StringEnum(["auto", "exa", "brave", "jina", "zai", "anthropic", "perplexity", "gemini", "codex"], {
 			description: "Search provider (default: auto)",
 		}),
 	),
 	recency: Type.Optional(
 		StringEnum(["day", "week", "month", "year"], {
-			description: "Recency filter (Perplexity)",
+			description: "Recency filter (Brave, Perplexity)",
 		}),
 	),
 	limit: Type.Optional(Type.Number({ description: "Max results to return" })),
@@ -47,7 +47,7 @@ export const webSearchSchema = Type.Object({
 
 export type SearchParams = {
 	query: string;
-	provider?: "auto" | "exa" | "jina" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex";
+	provider?: "auto" | "exa" | "brave" | "jina" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex";
 	recency?: "day" | "week" | "month" | "year";
 	limit?: number;
 	/** Maximum output tokens. Defaults to 4096. */
@@ -236,7 +236,7 @@ export async function runSearchQuery(
 /**
  * Web search tool implementation.
  *
- * Supports Anthropic, Perplexity, Exa, Jina, Gemini, Codex, and Z.AI providers with automatic fallback.
+ * Supports Anthropic, Perplexity, Exa, Brave, Jina, Gemini, Codex, and Z.AI providers with automatic fallback.
  * Session is accepted for interface consistency but not used.
  */
 export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {

package/src/web/search/provider.ts

@@ -1,5 +1,6 @@
 import { AnthropicProvider } from "./providers/anthropic";
 import type { SearchProvider } from "./providers/base";
+import { BraveProvider } from "./providers/brave";
 import { CodexProvider } from "./providers/codex";
 import { ExaProvider } from "./providers/exa";
 import { GeminiProvider } from "./providers/gemini";
@@ -13,6 +14,7 @@ export { SearchProvider } from "./providers/base";
 
 const SEARCH_PROVIDERS: Record<SearchProviderId, SearchProvider> = {
 	exa: new ExaProvider(),
+	brave: new BraveProvider(),
 	jina: new JinaProvider(),
 	perplexity: new PerplexityProvider(),
 	zai: new ZaiProvider(),
@@ -21,7 +23,16 @@ const SEARCH_PROVIDERS: Record<SearchProviderId, SearchProvider> = {
 	codex: new CodexProvider(),
 } as const;
 
-const SEARCH_PROVIDER_ORDER: SearchProviderId[] = ["exa", "jina", "perplexity", "anthropic", "gemini", "codex", "zai"];
+const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
+	"exa",
+	"brave",
+	"jina",
+	"perplexity",
+	"anthropic",
+	"gemini",
+	"codex",
+	"zai",
+];
 
 export function getSearchProvider(provider: SearchProviderId): SearchProvider {
 	return SEARCH_PROVIDERS[provider];
@@ -35,7 +46,7 @@ export function setPreferredSearchProvider(provider: SearchProviderId | "auto"):
 	preferredProvId = provider;
 }
 
-/** Determine which providers are configured (priority order) */
+/** Determine which providers are configured (priority: Exa → Brave → Jina → Perplexity → Anthropic → Gemini → Codex → Z.AI) */
 export async function resolveProviderChain(
 	preferredProvider: SearchProviderId | "auto" = preferredProvId,
 ): Promise<SearchProvider[]> {