@oh-my-pi/pi-coding-agent 11.0.3 → 11.2.0

package/src/commands/index/index.ts

@@ -0,0 +1,136 @@
+/**
+ * Root command for the coding agent CLI.
+ */
+import { Args, Command, Flags } from "@oclif/core";
+import { parseArgs } from "../../cli/args";
+import { APP_NAME } from "../../config";
+import { runRootCommand } from "../../main";
+
+export default class Index extends Command {
+	static description = "AI coding assistant";
+	static hidden = true;
+
+	static args = {
+		messages: Args.string({
+			description: "Messages to send (prefix files with @)",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		model: Flags.string({
+			description: 'Model to use (fuzzy match: "opus", "gpt-5.2", or "p-openai/gpt-5.2")',
+		}),
+		smol: Flags.string({
+			description: "Smol/fast model for lightweight tasks (or PI_SMOL_MODEL env)",
+		}),
+		slow: Flags.string({
+			description: "Slow/reasoning model for thorough analysis (or PI_SLOW_MODEL env)",
+		}),
+		plan: Flags.string({
+			description: "Plan model for architectural planning (or PI_PLAN_MODEL env)",
+		}),
+		provider: Flags.string({
+			description: "Provider to use (legacy; prefer --model)",
+		}),
+		"api-key": Flags.string({
+			description: "API key (defaults to env vars)",
+		}),
+		"system-prompt": Flags.string({
+			description: "System prompt (default: coding assistant prompt)",
+		}),
+		"append-system-prompt": Flags.string({
+			description: "Append text or file contents to the system prompt",
+		}),
+		"allow-home": Flags.boolean({
+			description: "Allow starting in ~ without auto-switching to a temp dir",
+		}),
+		mode: Flags.string({
+			description: "Output mode: text (default), json, or rpc",
+			options: ["text", "json", "rpc"],
+		}),
+		print: Flags.boolean({
+			char: "p",
+			description: "Non-interactive mode: process prompt and exit",
+		}),
+		continue: Flags.boolean({
+			char: "c",
+			description: "Continue previous session",
+		}),
+		resume: Flags.boolean({
+			char: "r",
+			description: "Select a session to resume",
+		}),
+		session: Flags.string({
+			description: "Use specific session file",
+		}),
+		"session-dir": Flags.string({
+			description: "Directory for session storage and lookup",
+		}),
+		"no-session": Flags.boolean({
+			description: "Don't save session (ephemeral)",
+		}),
+		models: Flags.string({
+			description: "Comma-separated model patterns for Ctrl+P cycling",
+		}),
+		"no-tools": Flags.boolean({
+			description: "Disable all built-in tools",
+		}),
+		"no-lsp": Flags.boolean({
+			description: "Disable LSP tools, formatting, and diagnostics",
+		}),
+		tools: Flags.string({
+			description: "Comma-separated list of tools to enable (default: all)",
+		}),
+		thinking: Flags.string({
+			description: "Set thinking level: off, minimal, low, medium, high, xhigh",
+			options: ["off", "minimal", "low", "medium", "high", "xhigh"],
+		}),
+		hook: Flags.string({
+			description: "Load a hook/extension file (can be used multiple times)",
+			multiple: true,
+		}),
+		extension: Flags.string({
+			char: "e",
+			description: "Load an extension file (can be used multiple times)",
+			multiple: true,
+		}),
+		"no-extensions": Flags.boolean({
+			description: "Disable extension discovery (explicit -e paths still work)",
+		}),
+		"no-skills": Flags.boolean({
+			description: "Disable skills discovery and loading",
+		}),
+		skills: Flags.string({
+			description: "Comma-separated glob patterns to filter skills (e.g., git-*,docker)",
+		}),
+		export: Flags.string({
+			description: "Export session file to HTML and exit",
+		}),
+		"list-models": Flags.string({
+			description: "List available models (with optional fuzzy search)",
+		}),
+		"no-title": Flags.boolean({
+			description: "Disable title auto-generation",
+		}),
+	};
+
+	static examples = [
+		`# Interactive mode\n  ${APP_NAME}`,
+		`# Interactive mode with initial prompt\n  ${APP_NAME} "List all .ts files in src/"`,
+		`# Include files in initial message\n  ${APP_NAME} @prompt.md @image.png "What color is the sky?"`,
+		`# Non-interactive mode (process and exit)\n  ${APP_NAME} -p "List all .ts files in src/"`,
+		`# Continue previous session\n  ${APP_NAME} --continue "What did we discuss?"`,
+		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
+		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
+		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.omp/agent/sessions/--path--/session.jsonl`,
+	];
+
+	static strict = false;
+
+	async run(): Promise<void> {
+		const parsed = parseArgs(this.argv);
+		await runRootCommand(parsed, this.argv);
+	}
+}

package/src/commands/jupyter.ts

@@ -0,0 +1,32 @@
+/**
+ * Manage the shared Jupyter gateway.
+ */
+import { Args, Command } from "@oclif/core";
+import { type JupyterAction, type JupyterCommandArgs, runJupyterCommand } from "../cli/jupyter-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: JupyterAction[] = ["kill", "status"];
+
+export default class Jupyter extends Command {
+	static description = "Manage the shared Jupyter gateway";
+
+	static args = {
+		action: Args.string({
+			description: "Jupyter action",
+			required: false,
+			options: ACTIONS,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { args } = await this.parse(Jupyter);
+		const action = (args.action ?? "status") as JupyterAction;
+
+		const cmd: JupyterCommandArgs = {
+			action,
+		};
+
+		await initTheme();
+		await runJupyterCommand(cmd);
+	}
+}

package/src/commands/plugin.ts

@@ -0,0 +1,70 @@
+/**
+ * Manage plugins (install, uninstall, list, etc.).
+ */
+import { Args, Command, Flags } from "@oclif/core";
+import { type PluginAction, type PluginCommandArgs, runPluginCommand } from "../cli/plugin-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: PluginAction[] = [
+	"install",
+	"uninstall",
+	"list",
+	"link",
+	"doctor",
+	"features",
+	"config",
+	"enable",
+	"disable",
+];
+
+export default class Plugin extends Command {
+	static description = "Manage plugins (install, uninstall, list, etc.)";
+
+	static args = {
+		action: Args.string({
+			description: "Plugin action",
+			required: false,
+			options: ACTIONS,
+		}),
+		targets: Args.string({
+			description: "Packages, paths, or plugin names",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+		fix: Flags.boolean({ description: "Attempt to fix issues (doctor)" }),
+		force: Flags.boolean({ description: "Force install" }),
+		"dry-run": Flags.boolean({ description: "Show actions without applying changes" }),
+		local: Flags.boolean({ char: "l", description: "Operate on local plugin directory" }),
+		enable: Flags.string({ description: "Enable a feature" }),
+		disable: Flags.string({ description: "Disable a feature" }),
+		set: Flags.string({ description: "Set plugin config (key=value)" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Plugin);
+		const action = (args.action ?? "list") as PluginAction;
+
+		const targets = Array.isArray(args.targets) ? args.targets : args.targets ? [args.targets] : [];
+		const cmd: PluginCommandArgs = {
+			action,
+			args: targets,
+			flags: {
+				json: flags.json,
+				fix: flags.fix,
+				force: flags.force,
+				dryRun: flags["dry-run"],
+				local: flags.local,
+				enable: flags.enable,
+				disable: flags.disable,
+				set: flags.set,
+			},
+		};
+
+		await initTheme();
+		await runPluginCommand(cmd);
+	}
+}

package/src/commands/setup.ts

@@ -0,0 +1,39 @@
+/**
+ * Install dependencies for optional features.
+ */
+import { Args, Command, Flags } from "@oclif/core";
+import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const COMPONENTS: SetupComponent[] = ["python"];
+
+export default class Setup extends Command {
+	static description = "Install dependencies for optional features";
+
+	static args = {
+		component: Args.string({
+			description: "Component to install",
+			required: true,
+			options: COMPONENTS,
+		}),
+	};
+
+	static flags = {
+		check: Flags.boolean({ char: "c", description: "Check if dependencies are installed" }),
+		json: Flags.boolean({ description: "Output status as JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Setup);
+		const cmd: SetupCommandArgs = {
+			component: args.component as SetupComponent,
+			flags: {
+				json: flags.json,
+				check: flags.check,
+			},
+		};
+
+		await initTheme();
+		await runSetupCommand(cmd);
+	}
+}

package/src/commands/shell.ts

@@ -0,0 +1,29 @@
+/**
+ * Interactive shell console.
+ */
+import { Command, Flags } from "@oclif/core";
+import { runShellCommand, type ShellCommandArgs } from "../cli/shell-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Shell extends Command {
+	static description = "Interactive shell console";
+
+	static flags = {
+		cwd: Flags.string({ char: "C", description: "Set working directory for commands" }),
+		timeout: Flags.integer({ char: "t", description: "Timeout per command in milliseconds" }),
+		"no-snapshot": Flags.boolean({ description: "Skip sourcing snapshot from user shell" }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Shell);
+
+		const cmd: ShellCommandArgs = {
+			cwd: flags.cwd,
+			timeoutMs: flags.timeout,
+			noSnapshot: flags["no-snapshot"],
+		};
+
+		await initTheme();
+		await runShellCommand(cmd);
+	}
+}

package/src/commands/stats.ts

@@ -0,0 +1,29 @@
+/**
+ * View usage statistics dashboard.
+ */
+import { Command, Flags } from "@oclif/core";
+import { runStatsCommand, type StatsCommandArgs } from "../cli/stats-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Stats extends Command {
+	static description = "View usage statistics";
+
+	static flags = {
+		port: Flags.integer({ char: "p", description: "Port for the dashboard server", default: 3847 }),
+		json: Flags.boolean({ char: "j", description: "Output stats as JSON" }),
+		summary: Flags.boolean({ char: "s", description: "Print summary to console" }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Stats);
+
+		const cmd: StatsCommandArgs = {
+			port: flags.port,
+			json: flags.json,
+			summary: flags.summary,
+		};
+
+		await initTheme();
+		await runStatsCommand(cmd);
+	}
+}

package/src/commands/update.ts

@@ -0,0 +1,21 @@
+/**
+ * Check for and install updates.
+ */
+import { Command, Flags } from "@oclif/core";
+import { runUpdateCommand } from "../cli/update-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Update extends Command {
+	static description = "Check for and install updates";
+
+	static flags = {
+		force: Flags.boolean({ char: "f", description: "Force update" }),
+		check: Flags.boolean({ char: "c", description: "Check for updates without installing" }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Update);
+		await initTheme();
+		await runUpdateCommand({ force: flags.force, check: flags.check });
+	}
+}

package/src/commands/web-search.ts

@@ -0,0 +1,50 @@
+/**
+ * Test web search providers.
+ */
+import { Args, Command, Flags } from "@oclif/core";
+import { runSearchCommand, type SearchCommandArgs } from "../cli/web-search-cli";
+import type { SearchProviderId } from "../web/search/types";
+
+const PROVIDERS: Array<SearchProviderId | "auto"> = [
+	"auto",
+	"anthropic",
+	"perplexity",
+	"exa",
+	"jina",
+	"gemini",
+	"codex",
+];
+
+const RECENCY: NonNullable<SearchCommandArgs["recency"]>[] = ["day", "week", "month", "year"];
+
+export default class Search extends Command {
+	static description = "Test web search providers";
+
+	static aliases = ["q"];
+
+	static args = {
+		query: Args.string({ description: "Search query text", required: false, multiple: true }),
+	};
+
+	static flags = {
+		provider: Flags.string({ description: "Search provider", options: PROVIDERS }),
+		recency: Flags.string({ description: "Recency filter", options: RECENCY }),
+		limit: Flags.integer({ char: "l", description: "Max results to return" }),
+		compact: Flags.boolean({ description: "Render condensed output" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Search);
+		const query = Array.isArray(args.query) ? args.query.join(" ") : (args.query ?? "");
+
+		const cmd: SearchCommandArgs = {
+			query,
+			provider: flags.provider as SearchProviderId | "auto" | undefined,
+			recency: flags.recency as SearchCommandArgs["recency"],
+			limit: flags.limit,
+			expanded: !flags.compact,
+		};
+
+		await runSearchCommand(cmd);
+	}
+}

package/src/commit/agentic/index.ts

@@ -8,9 +8,10 @@ import { ControlledGit } from "../../commit/git";
 import { formatCommitMessage } from "../../commit/message";
 import { resolvePrimaryModel, resolveSmolModel } from "../../commit/model-selection";
 import type { CommitCommandArgs, ConventionalAnalysis } from "../../commit/types";
+import { ModelRegistry } from "../../config/model-registry";
 import { renderPromptTemplate } from "../../config/prompt-templates";
 import { Settings } from "../../config/settings";
-import { discoverAuthStorage, discoverContextFiles, discoverModels } from "../../sdk";
+import { discoverAuthStorage, discoverContextFiles } from "../../sdk";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
 import splitConfirmPrompt from "./prompts/split-confirm.md" with { type: "text" };
@@ -31,7 +32,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	const settings = settingsInstance;
 
 	writeStdout("● Resolving model...");
-	const modelRegistry = discoverModels(authStorage);
+	const modelRegistry = new ModelRegistry(authStorage);
 	const stagedFilesPromise = (async () => {
 		let stagedFiles = await git.getStagedFiles();
 		if (stagedFiles.length === 0) {

package/src/commit/agentic/tools/analyze-file.ts

@@ -62,7 +62,6 @@ export function createAnalyzeFileTool(options: {
 		async execute(toolCallId, params, onUpdate, ctx, signal) {
 			const toolSession = buildToolSession(ctx, options);
 			const taskTool = await TaskTool.create(toolSession);
-			const context = "{{prompt}}";
 			const numstat = options.state.overview?.numstat ?? [];
 			const tasks = params.files.map((file, index) => {
 				const relatedFiles = formatRelatedFiles(params.files, file, numstat);
@@ -74,12 +73,11 @@ export function createAnalyzeFileTool(options: {
 				return {
 					id: `AnalyzeFile${index + 1}`,
 					description: `Analyze ${file}`,
-					args: { prompt },
+					assignment: prompt,
 				};
 			});
 			const taskParams: TaskParams = {
 				agent: "quick_task",
-				context,
 				schema: analyzeFileOutputSchema,
 				tasks,
 			};

package/src/commit/git/errors.ts

@@ -1,11 +1,9 @@
 export class GitError extends Error {
-	readonly command: string;
-	readonly stderr: string;
-
-	constructor(command: string, stderr: string) {
+	constructor(
+		readonly command: string,
+		readonly stderr: string,
+	) {
 		super(`${command} failed: ${stderr || "unknown error"}`);
-		this.command = command;
-		this.stderr = stderr;
 		this.name = "GitError";
 	}
 }

package/src/commit/pipeline.ts

@@ -1,9 +1,10 @@
 import * as path from "node:path";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
+import { ModelRegistry } from "../config/model-registry";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
-import { discoverAuthStorage, discoverModels } from "../sdk";
+import { discoverAuthStorage } from "../sdk";
 import { loadProjectContextFiles } from "../system-prompt";
 import { runAgenticCommit } from "./agentic";
 import {
@@ -41,7 +42,7 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 	const settingsInstance = await Settings.init();
 	const commitSettings = settingsInstance.getGroup("commit");
 	const authStorage = await discoverAuthStorage();
-	const modelRegistry = discoverModels(authStorage);
+	const modelRegistry = new ModelRegistry(authStorage);
 
 	const { model: primaryModel, apiKey: primaryApiKey } = await resolvePrimaryModel(
 		args.model,

package/src/config/keybindings.ts

@@ -151,11 +151,9 @@ export function formatKeyHints(keys: KeyId | KeyId[]): string {
  * Manages all keybindings (app + editor).
  */
 export class KeybindingsManager {
-	private config: KeybindingsConfig;
 	private appActionToKeys: Map<AppAction, KeyId[]>;
 
-	private constructor(config: KeybindingsConfig) {
-		this.config = config;
+	private constructor(private readonly config: KeybindingsConfig) {
 		this.appActionToKeys = new Map();
 		this.buildMaps();
 	}