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

package/docs/sdk.md

@@ -272,7 +272,7 @@ const { session } = await createAgentSession({
 `agentDir` is used for:
 
 - Global settings (`config.yml` + `agent.db`)
-- Primary auth/models locations (`auth.json`, `models.yml`, `models.json`)
+ - Primary auth/models locations (`agent.db`, `models.yml`, `models.json`)
 - Prompt templates (`prompts/`)
 - Custom TS commands (`commands/`)
 
@@ -328,12 +328,13 @@ API key resolution priority (handled by AuthStorage):
 3. Environment variables (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, etc.)
 4. Fallback resolver (for custom provider keys from `models.yml`)
 
-`discoverAuthStorage` also migrates legacy `auth.json` from user config directories (`.pi`, `.claude`, `.codex`, `.gemini`) into `agent.db`.
+
+ `discoverAuthStorage` opens the `agent.db` SQLite database in the agent directory.
 
 ```typescript
 import { AuthStorage, ModelRegistry, discoverAuthStorage, discoverModels } from "@oh-my-pi/pi-coding-agent";
 
-// Default: uses agentDir/auth.json → agent.db and agentDir/models.yml (with legacy fallbacks)
+ // Default: uses agentDir/agent.db and agentDir/models.yml
 const authStorage = await discoverAuthStorage();
 const modelRegistry = discoverModels(authStorage);
 
@@ -347,7 +348,7 @@ const { session } = await createAgentSession({
 authStorage.setRuntimeApiKey("anthropic", "sk-my-temp-key");
 
 // Custom auth storage location (use create(), constructor is private)
-const customAuth = await AuthStorage.create("/my/app/auth.json");
+const customAuth = await AuthStorage.create("/my/app/agent.db");
 const customRegistry = new ModelRegistry(customAuth, "/my/app/models.yml");
 
 const { session } = await createAgentSession({
@@ -788,7 +789,7 @@ import {
 } from "@oh-my-pi/pi-coding-agent";
 
 // Auth and Models
-const authStorage = await discoverAuthStorage(); // <agentDir>/auth.json → agent.db (with fallbacks)
+const authStorage = await discoverAuthStorage(); // <agentDir>/agent.db
 const modelRegistry = discoverModels(authStorage); // + <agentDir>/models.yml (or models.json)
 const allModels = modelRegistry.getAll(); // All models (built-in + custom)
 const available = modelRegistry.getAvailable(); // Only models with API keys

package/examples/sdk/09-api-keys-and-oauth.ts

@@ -12,7 +12,7 @@ import {
 	SessionManager,
 } from "@oh-my-pi/pi-coding-agent";
 
-// Default: discoverAuthStorage() uses ~/.omp/agent/auth.json
+// Default: discoverAuthStorage() uses ~/.omp/agent/agent.db
 // discoverModels() loads built-in + custom models from ~/.omp/agent/models.json
 const authStorage = await discoverAuthStorage();
 const modelRegistry = await discoverModels(authStorage);
@@ -25,7 +25,7 @@ await createAgentSession({
 console.log("Session with default auth storage and model registry");
 
 // Custom auth storage location
-const customAuthStorage = new AuthStorage("/tmp/my-app/auth.json");
+const customAuthStorage = await AuthStorage.create("/tmp/my-app/agent.db");
 const customModelRegistry = new ModelRegistry(customAuthStorage, "/tmp/my-app/models.json");
 
 await createAgentSession({

package/examples/sdk/README.md

@@ -77,7 +77,7 @@ const { session } = await createAgentSession({
 });
 
 // Full control
-const customAuth = new AuthStorage("/my/app/auth.json");
+const customAuth = await AuthStorage.create("/my/app/agent.db");
 customAuth.setRuntimeApiKey("anthropic", Bun.env.MY_KEY!);
 const customRegistry = new ModelRegistry(customAuth);
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "11.0.3",
+	"version": "11.2.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -10,6 +10,14 @@
 	"bin": {
 		"omp": "src/cli.ts"
 	},
+	"oclif": {
+		"bin": "omp",
+		"commands": "./src/commands",
+		"helpClass": "./src/cli/oclif-help.ts",
+		"plugins": [
+			"@oclif/plugin-autocomplete"
+		]
+	},
 	"main": "./src/index.ts",
 	"types": "./src/index.ts",
 	"exports": {
@@ -79,14 +87,15 @@
 		"test": "bun test"
 	},
 	"dependencies": {
+		"@oclif/core": "^4.5.6",
+		"@oclif/plugin-autocomplete": "^3.2.23",
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "11.0.3",
-		"@oh-my-pi/pi-agent-core": "11.0.3",
-		"@oh-my-pi/pi-ai": "11.0.3",
-		"@oh-my-pi/pi-natives": "11.0.3",
-		"@oh-my-pi/pi-tui": "11.0.3",
-		"@oh-my-pi/pi-utils": "11.0.3",
-		"@openai/agents": "^0.4.5",
+		"@oh-my-pi/omp-stats": "11.2.0",
+		"@oh-my-pi/pi-agent-core": "11.2.0",
+		"@oh-my-pi/pi-ai": "11.2.0",
+		"@oh-my-pi/pi-natives": "11.2.0",
+		"@oh-my-pi/pi-tui": "11.2.0",
+		"@oh-my-pi/pi-utils": "11.2.0",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
 		"chalk": "^5.6.2",
@@ -104,11 +113,10 @@
 	},
 	"devDependencies": {
 		"@types/diff": "^7.0.2",
-		"@types/jsdom": "27.0.0",
-		"bun-types": "^1.3.8",
 		"@types/ms": "^2.1.0",
 		"@types/bun": "^1.3.8",
-		"ms": "^2.1.3"
+		"ms": "^2.1.3",
+		"@types/jsdom": "27.0.0"
 	},
 	"keywords": [
 		"coding-agent",

package/src/cli/args.ts

@@ -180,99 +180,8 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 	return result;
 }
 
-export function printHelp(): void {
-	console.log(`${chalk.bold(APP_NAME)} - AI coding assistant
-
-${chalk.bold("Usage:")}
-  ${APP_NAME} [options] [@files...] [messages...]
-
-${chalk.bold("Subcommands:")}
-  plugin    Manage plugins (install, uninstall, list, etc.)
-  update    Check for and install updates
-  config    Manage configuration settings
-  setup     Install dependencies for optional features
-  commit    AI-assisted git commits
-  stats     AI usage statistics dashboard
-  jupyter   Manage the shared Jupyter gateway
-  shell     Interactive shell console (brush-core test)
-  grep      Test grep tool
-
-${chalk.bold("Options:")}
-  --model <pattern>              Model to use (fuzzy match: "opus", "gpt-5.2", or "p-openai/gpt-5.2")
-   --smol <id>                    Smol/fast model for lightweight tasks (or PI_SMOL_MODEL env)
-   --slow <id>                    Slow/reasoning model for thorough analysis (or PI_SLOW_MODEL env)
-   --plan <id>                    Plan model for architectural planning (or PI_PLAN_MODEL env)
-  --api-key <key>                API key (defaults to env vars)
-  --system-prompt <text>         System prompt (default: coding assistant prompt)
-  --append-system-prompt <text>  Append text or file contents to the system prompt
-  --allow-home                   Allow starting in ~ without auto-switching to a temp dir
-  --mode <mode>                  Output mode: text (default), json, or rpc
-  --print, -p                    Non-interactive mode: process prompt and exit
-  --continue, -c                 Continue previous session
-  --resume, -r                   Select a session to resume
-  --session <path>               Use specific session file
-  --session-dir <dir>            Directory for session storage and lookup
-  --no-session                   Don't save session (ephemeral)
-  --models <patterns>            Comma-separated model patterns for Ctrl+P cycling
-                                 Supports globs (anthropic/*, *sonnet*) and fuzzy matching
-  --no-tools                     Disable all built-in tools
-  --no-lsp                       Disable LSP tools, formatting, and diagnostics
-  --tools <tools>                Comma-separated list of tools to enable (default: all)
-                                 Available: read, bash, edit, write, grep, find, lsp,
-                                 python, notebook, task, fetch, web_search, browser, ask
-  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
-  --hook <path>                  Load a hook/extension file (can be used multiple times)
-  --extension, -e <path>         Load an extension file (can be used multiple times)
-  --no-extensions                Disable extension discovery (explicit -e paths still work)
-  --no-skills                    Disable skills discovery and loading
-  --skills <patterns>            Comma-separated glob patterns to filter skills (e.g., git-*,docker)
-  --export <file>                Export session file to HTML and exit
-  --list-models [search]         List available models (with optional fuzzy search)
-  --help, -h                     Show this help
-  --version, -v                  Show version number
-
-${chalk.bold("Examples:")}
-  # Interactive mode
-  ${APP_NAME}
-
-  # Interactive mode with initial prompt
-  ${APP_NAME} "List all .ts files in src/"
-
-  # Include files in initial message
-  ${APP_NAME} @prompt.md @image.png "What color is the sky?"
-
-  # Non-interactive mode (process and exit)
-  ${APP_NAME} -p "List all .ts files in src/"
-
-  # Multiple messages (interactive)
-  ${APP_NAME} "Read package.json" "What dependencies do we have?"
-
-  # Continue previous session
-  ${APP_NAME} --continue "What did we discuss?"
-
-  # Use different model (fuzzy matching)
-  ${APP_NAME} --model opus "Help me refactor this code"
-
-  # Limit model cycling to specific models
-  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o
-
-  # Limit to a specific provider with glob pattern
-  ${APP_NAME} --models "github-copilot/*"
-
-  # Cycle models with fixed thinking levels
-  ${APP_NAME} --models sonnet:high,haiku:low
-
-  # Start with a specific thinking level
-  ${APP_NAME} --thinking high "Solve this complex problem"
-
-  # Read-only mode (no file modifications possible)
-  ${APP_NAME} --tools read,grep,find -p "Review the code in src/"
-
-  # Export a session file to HTML
-  ${APP_NAME} --export ~/${CONFIG_DIR_NAME}/agent/sessions/--path--/session.jsonl
-  ${APP_NAME} --export session.jsonl output.html
-
-${chalk.bold("Environment Variables:")}
+export function getExtraHelpText(): string {
+	return `${chalk.bold("Environment Variables:")}
   ${chalk.dim("# Core Providers")}
   ANTHROPIC_API_KEY          - Anthropic Claude models
   ANTHROPIC_OAUTH_TOKEN      - Anthropic OAuth (takes precedence over API key)
@@ -327,5 +236,13 @@ ${chalk.bold("Available Tools (all enabled by default):")}
   fetch      - Fetch and process URLs
   web_search - Search the web
   ask        - Ask user questions (interactive mode only)
-`);
+`;
+}
+
+export function printHelp(): void {
+	process.stdout.write(
+		`${chalk.bold(APP_NAME)} - AI coding assistant\n\n` +
+			`Run ${APP_NAME} --help for full command and option details.\n\n` +
+			`${getExtraHelpText()}\n`,
+	);
 }

package/src/cli/config-cli.ts

@@ -48,7 +48,7 @@ function getSettingValues(def: SettingDef): readonly string[] | undefined {
 		return def.values;
 	}
 	if (def.type === "submenu") {
-		const options = def.getOptions();
+		const options = def.options;
 		if (options.length > 0) {
 			return options.map(o => o.value);
 		}

package/src/cli/file-processor.ts

@@ -22,7 +22,7 @@ export interface ProcessFileOptions {
 
 /** Process @file arguments into text content and image attachments */
 export async function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles> {
-	const _autoResizeImages = options?.autoResizeImages ?? true;
+	const autoResizeImages = options?.autoResizeImages ?? true;
 	let text = "";
 	const images: ImageContent[] = [];
 
@@ -49,11 +49,11 @@ export async function processFileArguments(fileArgs: string[], options?: Process
 
 		if (mimeType) {
 			// Handle image file
-			const base64Content = buffer.toString("base64");
+			const base64Content = buffer.toBase64();
 			let attachment: ImageContent;
 			let dimensionNote: string | undefined;
 
-			if (_autoResizeImages) {
+			if (autoResizeImages) {
 				try {
 					const resized = await resizeImage({ type: "image", data: base64Content, mimeType });
 					dimensionNote = formatDimensionNote(resized);

package/src/cli/oclif-help.ts

@@ -0,0 +1,26 @@
+/**
+ * Custom help renderer for the coding agent CLI.
+ */
+import { CommandHelp, Help } from "@oclif/core";
+import { getExtraHelpText } from "./args";
+
+export default class OclifHelp extends Help {
+	protected async showRootHelp(): Promise<void> {
+		await super.showRootHelp();
+		const rootCommand = this.config.findCommand("index");
+		if (rootCommand) {
+			const rootHelp = new CommandHelp(rootCommand, this.config, {
+				...this.opts,
+				sections: ["arguments", "flags", "examples"],
+			});
+			const output = rootHelp.generate();
+			if (output.trim().length > 0) {
+				process.stdout.write(`\n${output}\n`);
+			}
+		}
+		const extra = getExtraHelpText();
+		if (extra.trim().length > 0) {
+			process.stdout.write(`\n${extra}\n`);
+		}
+	}
+}

package/src/cli/web-search-cli.ts

@@ -0,0 +1,148 @@
+/**
+ * Web search CLI command handlers.
+ *
+ * Handles `omp q`/`omp web-search` subcommands for testing web search providers.
+ */
+import chalk from "chalk";
+import { APP_NAME } from "../config";
+import { initTheme, theme } from "../modes/theme/theme";
+import { runSearchQuery, type SearchParams } from "../web/search/index";
+import { renderSearchResult } from "../web/search/render";
+import type { SearchProviderId } from "../web/search/types";
+
+export interface SearchCommandArgs {
+	query: string;
+	provider?: SearchProviderId | "auto";
+	recency?: "day" | "week" | "month" | "year";
+	limit?: number;
+	expanded: boolean;
+}
+
+const PROVIDERS: Array<SearchProviderId | "auto"> = [
+	"auto",
+	"anthropic",
+	"perplexity",
+	"exa",
+	"jina",
+	"gemini",
+	"codex",
+];
+
+const RECENCY_OPTIONS: SearchCommandArgs["recency"][] = ["day", "week", "month", "year"];
+
+/**
+ * Parse web search subcommand arguments.
+ * Returns undefined if not a web search command.
+ */
+export function parseSearchArgs(args: string[]): SearchCommandArgs | undefined {
+	if (args.length === 0 || (args[0] !== "q" && args[0] !== "web-search")) {
+		return undefined;
+	}
+
+	const result: SearchCommandArgs = {
+		query: "",
+		expanded: true,
+	};
+
+	const positional: string[] = [];
+
+	for (let i = 1; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--provider") {
+			result.provider = args[++i] as SearchCommandArgs["provider"];
+		} else if (arg === "--recency") {
+			result.recency = args[++i] as SearchCommandArgs["recency"];
+		} else if (arg === "--limit" || arg === "-l") {
+			result.limit = Number.parseInt(args[++i], 10);
+		} else if (arg === "--compact") {
+			result.expanded = false;
+		} else if (!arg.startsWith("-")) {
+			positional.push(arg);
+		}
+	}
+
+	if (positional.length > 0) {
+		result.query = positional.join(" ");
+	}
+
+	return result;
+}
+
+export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
+	if (!cmd.query) {
+		writeStderr(chalk.red("Error: Query is required"));
+		process.exit(1);
+	}
+
+	if (cmd.provider && !PROVIDERS.includes(cmd.provider)) {
+		writeStderr(chalk.red(`Error: Unknown provider "${cmd.provider}"`));
+		writeStderr(chalk.dim(`Valid providers: ${PROVIDERS.join(", ")}`));
+		process.exit(1);
+	}
+
+	if (cmd.recency && !RECENCY_OPTIONS.includes(cmd.recency)) {
+		writeStderr(chalk.red(`Error: Invalid recency "${cmd.recency}"`));
+		writeStderr(chalk.dim(`Valid recency values: ${RECENCY_OPTIONS.join(", ")}`));
+		process.exit(1);
+	}
+
+	if (cmd.limit !== undefined && Number.isNaN(cmd.limit)) {
+		writeStderr(chalk.red("Error: --limit must be a number"));
+		process.exit(1);
+	}
+
+	await initTheme();
+
+	const params: SearchParams = {
+		query: cmd.query,
+		provider: cmd.provider,
+		recency: cmd.recency,
+		limit: cmd.limit,
+	};
+
+	const result = await runSearchQuery(params);
+	const component = renderSearchResult(result, { expanded: cmd.expanded, isPartial: false }, theme, {
+		query: cmd.query,
+		provider: cmd.provider,
+		allowLongAnswer: true,
+		maxAnswerLines: cmd.expanded ? undefined : 6,
+	});
+
+	const width = Math.max(60, process.stdout.columns ?? 100);
+	writeStdout(component.render(width).join("\n"));
+
+	if (result.details?.error) {
+		process.exitCode = 1;
+	}
+}
+
+export function printSearchHelp(): void {
+	writeStdout(`${chalk.bold(`${APP_NAME} q`)} - Test web search providers
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} q [options] <query>
+  ${APP_NAME} web-search [options] <query>
+
+${chalk.bold("Arguments:")}
+  query      Search query text
+
+${chalk.bold("Options:")}
+  --provider <name>   Provider: ${PROVIDERS.join(", ")}
+  --recency <value>   Recency filter (Perplexity only): ${RECENCY_OPTIONS.join(", ")}
+  -l, --limit <n>     Max results to return
+  --compact           Render condensed output
+  -h, --help          Show this help
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} q --provider=exa "what's the color of the sky"
+  ${APP_NAME} q --provider=perplexity --recency=week "latest TypeScript 5.7 changes"
+`);
+}
+
+function writeStdout(message: string): void {
+	process.stdout.write(`${message}\n`);
+}
+
+function writeStderr(message: string): void {
+	process.stderr.write(`${message}\n`);
+}

package/src/cli.ts

@@ -5,8 +5,14 @@
  *
  * Test with: npx tsx src/cli-new.ts [args...]
  */
+import { run } from "@oclif/core";
 import { APP_NAME } from "./config";
-import { main } from "./main";
 
 process.title = APP_NAME;
-main(process.argv.slice(2));
+const argv = process.argv.slice(2);
+const runArgv = argv.length === 0 ? ["index"] : argv;
+run(runArgv, import.meta.url).catch((error: unknown) => {
+	const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+	process.stderr.write(`${message}\n`);
+	process.exit(1);
+});

package/src/commands/commit.ts

@@ -0,0 +1,36 @@
+/**
+ * Generate and optionally push a commit with changelog updates.
+ */
+import { Command, Flags } from "@oclif/core";
+import { runCommitCommand } from "../commit";
+import type { CommitCommandArgs } from "../commit/types";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Commit extends Command {
+	static description = "Generate a commit message and update changelogs";
+
+	static flags = {
+		push: Flags.boolean({ description: "Push after committing" }),
+		"dry-run": Flags.boolean({ description: "Preview without committing" }),
+		"no-changelog": Flags.boolean({ description: "Skip changelog updates" }),
+		legacy: Flags.boolean({ description: "Use legacy deterministic pipeline" }),
+		context: Flags.string({ char: "c", description: "Additional context for the model" }),
+		model: Flags.string({ char: "m", description: "Override model selection" }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Commit);
+
+		const cmd: CommitCommandArgs = {
+			push: flags.push ?? false,
+			dryRun: flags["dry-run"] ?? false,
+			noChangelog: flags["no-changelog"] ?? false,
+			legacy: flags.legacy,
+			context: flags.context,
+			model: flags.model,
+		};
+
+		await initTheme();
+		await runCommitCommand(cmd);
+	}
+}

package/src/commands/config.ts

@@ -0,0 +1,51 @@
+/**
+ * Manage configuration settings.
+ */
+import { Args, Command, Flags } from "@oclif/core";
+import { type ConfigAction, type ConfigCommandArgs, runConfigCommand } from "../cli/config-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path"];
+
+export default class Config extends Command {
+	static description = "Manage configuration settings";
+
+	static args = {
+		action: Args.string({
+			description: "Config action",
+			required: false,
+			options: ACTIONS,
+		}),
+		key: Args.string({
+			description: "Setting key",
+			required: false,
+		}),
+		value: Args.string({
+			description: "Value (for set/reset)",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Config);
+		const action = (args.action ?? "list") as ConfigAction;
+		const value = Array.isArray(args.value) ? args.value.join(" ") : args.value;
+
+		const cmd: ConfigCommandArgs = {
+			action,
+			key: args.key,
+			value,
+			flags: {
+				json: flags.json,
+			},
+		};
+
+		await initTheme();
+		await runConfigCommand(cmd);
+	}
+}

package/src/commands/grep.ts

@@ -0,0 +1,41 @@
+/**
+ * Test grep tool.
+ */
+import { Args, Command, Flags } from "@oclif/core";
+import { type GrepCommandArgs, runGrepCommand } from "../cli/grep-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Grep extends Command {
+	static description = "Test grep tool";
+
+	static args = {
+		pattern: Args.string({ description: "Regex pattern to search for", required: false }),
+		path: Args.string({ description: "Directory or file to search", required: false }),
+	};
+
+	static flags = {
+		glob: Flags.string({ char: "g", description: "Filter files by glob pattern" }),
+		limit: Flags.integer({ char: "l", description: "Max matches", default: 20 }),
+		context: Flags.integer({ char: "C", description: "Context lines", default: 2 }),
+		files: Flags.boolean({ char: "f", description: "Output file names only" }),
+		count: Flags.boolean({ char: "c", description: "Output match counts per file" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Grep);
+
+		const mode: GrepCommandArgs["mode"] = flags.count ? "count" : flags.files ? "filesWithMatches" : "content";
+
+		const cmd: GrepCommandArgs = {
+			pattern: args.pattern ?? "",
+			path: args.path ?? ".",
+			glob: flags.glob,
+			limit: flags.limit,
+			context: flags.context,
+			mode,
+		};
+
+		await initTheme();
+		await runGrepCommand(cmd);
+	}
+}