can1357
35dbf43670
- Added Brave web search provider with support for query, result count, and recency filtering. - Added BRAVE_API_KEY environment variable configuration for Brave search authentication. - Updated web search provider priority order to include Brave as second-highest priority after Exa. - Extended recency filter support to Brave search provider alongside Perplexity. - Implemented BraveProvider class with API integration, response mapping, and parameter validation. - Added helper functions for recency mapping, result clamping, and snippet building in Brave provider.
257 lines
9.1 KiB
TypeScript
257 lines
9.1 KiB
TypeScript
/**
|
|
* CLI argument parsing and help display
|
|
*/
|
|
import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
|
|
import { logger } from "@oh-my-pi/pi-utils";
|
|
import { APP_NAME, CONFIG_DIR_NAME } from "@oh-my-pi/pi-utils/dirs";
|
|
import chalk from "chalk";
|
|
import { BUILTIN_TOOLS } from "../tools";
|
|
|
|
export type Mode = "text" | "json" | "rpc";
|
|
|
|
export interface Args {
|
|
cwd?: string;
|
|
allowHome?: boolean;
|
|
provider?: string;
|
|
model?: string;
|
|
smol?: string;
|
|
slow?: string;
|
|
plan?: string;
|
|
apiKey?: string;
|
|
systemPrompt?: string;
|
|
appendSystemPrompt?: string;
|
|
thinking?: ThinkingLevel;
|
|
continue?: boolean;
|
|
resume?: string | true;
|
|
help?: boolean;
|
|
version?: boolean;
|
|
mode?: Mode;
|
|
noSession?: boolean;
|
|
sessionDir?: string;
|
|
models?: string[];
|
|
tools?: string[];
|
|
noTools?: boolean;
|
|
noLsp?: boolean;
|
|
noPty?: boolean;
|
|
hooks?: string[];
|
|
extensions?: string[];
|
|
noExtensions?: boolean;
|
|
print?: boolean;
|
|
export?: string;
|
|
noSkills?: boolean;
|
|
skills?: string[];
|
|
listModels?: string | true;
|
|
noTitle?: boolean;
|
|
messages: string[];
|
|
fileArgs: string[];
|
|
/** Unknown flags (potentially extension flags) - map of flag name to value */
|
|
unknownFlags: Map<string, boolean | string>;
|
|
}
|
|
|
|
const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
|
|
|
|
export function isValidThinkingLevel(level: string): level is ThinkingLevel {
|
|
return VALID_THINKING_LEVELS.includes(level as ThinkingLevel);
|
|
}
|
|
|
|
export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
|
|
const result: Args = {
|
|
messages: [],
|
|
fileArgs: [],
|
|
unknownFlags: new Map(),
|
|
};
|
|
|
|
for (let i = 0; i < args.length; i++) {
|
|
const arg = args[i];
|
|
|
|
if (arg === "--help" || arg === "-h") {
|
|
result.help = true;
|
|
} else if (arg === "--version" || arg === "-v") {
|
|
result.version = true;
|
|
} else if (arg === "--allow-home") {
|
|
result.allowHome = true;
|
|
} else if (arg === "--mode" && i + 1 < args.length) {
|
|
const mode = args[++i];
|
|
if (mode === "text" || mode === "json" || mode === "rpc") {
|
|
result.mode = mode;
|
|
}
|
|
} else if (arg === "--continue" || arg === "-c") {
|
|
result.continue = true;
|
|
} else if (arg === "--resume" || arg === "-r" || arg === "--session") {
|
|
const next = args[i + 1];
|
|
if (next && !next.startsWith("-")) {
|
|
result.resume = args[++i];
|
|
} else {
|
|
result.resume = true;
|
|
}
|
|
} else if (arg === "--provider" && i + 1 < args.length) {
|
|
result.provider = args[++i];
|
|
} else if (arg === "--model" && i + 1 < args.length) {
|
|
result.model = args[++i];
|
|
} else if (arg === "--smol" && i + 1 < args.length) {
|
|
result.smol = args[++i];
|
|
} else if (arg === "--slow" && i + 1 < args.length) {
|
|
result.slow = args[++i];
|
|
} else if (arg === "--plan" && i + 1 < args.length) {
|
|
result.plan = args[++i];
|
|
} else if (arg === "--api-key" && i + 1 < args.length) {
|
|
result.apiKey = args[++i];
|
|
} else if (arg === "--system-prompt" && i + 1 < args.length) {
|
|
result.systemPrompt = args[++i];
|
|
} else if (arg === "--append-system-prompt" && i + 1 < args.length) {
|
|
result.appendSystemPrompt = args[++i];
|
|
} else if (arg === "--no-session") {
|
|
result.noSession = true;
|
|
} else if (arg === "--session-dir" && i + 1 < args.length) {
|
|
result.sessionDir = args[++i];
|
|
} else if (arg === "--models" && i + 1 < args.length) {
|
|
result.models = args[++i].split(",").map(s => s.trim());
|
|
} else if (arg === "--no-tools") {
|
|
result.noTools = true;
|
|
} else if (arg === "--no-lsp") {
|
|
result.noLsp = true;
|
|
} else if (arg === "--no-pty") {
|
|
result.noPty = true;
|
|
} else if (arg === "--tools" && i + 1 < args.length) {
|
|
const toolNames = args[++i].split(",").map(s => s.trim());
|
|
const validTools: string[] = [];
|
|
for (const name of toolNames) {
|
|
if (name in BUILTIN_TOOLS) {
|
|
validTools.push(name);
|
|
} else {
|
|
logger.warn("Unknown tool passed to --tools", {
|
|
tool: name,
|
|
validTools: Object.keys(BUILTIN_TOOLS),
|
|
});
|
|
}
|
|
}
|
|
result.tools = validTools;
|
|
} else if (arg === "--thinking" && i + 1 < args.length) {
|
|
const level = args[++i];
|
|
if (isValidThinkingLevel(level)) {
|
|
result.thinking = level;
|
|
} else {
|
|
logger.warn("Invalid thinking level passed to --thinking", {
|
|
level,
|
|
validThinkingLevels: [...VALID_THINKING_LEVELS],
|
|
});
|
|
}
|
|
} else if (arg === "--print" || arg === "-p") {
|
|
result.print = true;
|
|
} else if (arg === "--export" && i + 1 < args.length) {
|
|
result.export = args[++i];
|
|
} else if (arg === "--hook" && i + 1 < args.length) {
|
|
result.hooks = result.hooks ?? [];
|
|
result.hooks.push(args[++i]);
|
|
} else if ((arg === "--extension" || arg === "-e") && i + 1 < args.length) {
|
|
result.extensions = result.extensions ?? [];
|
|
result.extensions.push(args[++i]);
|
|
} else if (arg === "--no-extensions") {
|
|
result.noExtensions = true;
|
|
} else if (arg === "--no-skills") {
|
|
result.noSkills = true;
|
|
} else if (arg === "--no-title") {
|
|
result.noTitle = true;
|
|
} else if (arg === "--skills" && i + 1 < args.length) {
|
|
// Comma-separated glob patterns for skill filtering
|
|
result.skills = args[++i].split(",").map(s => s.trim());
|
|
} else if (arg === "--list-models") {
|
|
// Check if next arg is a search pattern (not a flag or file arg)
|
|
if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
|
|
result.listModels = args[++i];
|
|
} else {
|
|
result.listModels = true;
|
|
}
|
|
} else if (arg.startsWith("@")) {
|
|
result.fileArgs.push(arg.slice(1)); // Remove @ prefix
|
|
} else if (arg.startsWith("--") && extensionFlags) {
|
|
// Check if it's an extension-registered flag
|
|
const flagName = arg.slice(2);
|
|
const extFlag = extensionFlags.get(flagName);
|
|
if (extFlag) {
|
|
if (extFlag.type === "boolean") {
|
|
result.unknownFlags.set(flagName, true);
|
|
} else if (extFlag.type === "string" && i + 1 < args.length) {
|
|
result.unknownFlags.set(flagName, args[++i]);
|
|
}
|
|
}
|
|
// Unknown flags without extensionFlags are silently ignored (first pass)
|
|
} else if (!arg.startsWith("-")) {
|
|
result.messages.push(arg);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
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)
|
|
OPENAI_API_KEY - OpenAI GPT models
|
|
GEMINI_API_KEY - Google Gemini models
|
|
GITHUB_TOKEN - GitHub Copilot (or GH_TOKEN, COPILOT_GITHUB_TOKEN)
|
|
|
|
${chalk.dim("# Additional LLM Providers")}
|
|
AZURE_OPENAI_API_KEY - Azure OpenAI models
|
|
GROQ_API_KEY - Groq models
|
|
CEREBRAS_API_KEY - Cerebras models
|
|
XAI_API_KEY - xAI Grok models
|
|
OPENROUTER_API_KEY - OpenRouter aggregated models
|
|
MISTRAL_API_KEY - Mistral models
|
|
ZAI_API_KEY - z.ai models (ZhipuAI/GLM)
|
|
MINIMAX_API_KEY - MiniMax models
|
|
OPENCODE_API_KEY - OpenCode models
|
|
CURSOR_ACCESS_TOKEN - Cursor AI models
|
|
AI_GATEWAY_API_KEY - Vercel AI Gateway
|
|
|
|
${chalk.dim("# Cloud Providers")}
|
|
AWS_PROFILE - AWS Bedrock (or AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY)
|
|
GOOGLE_CLOUD_PROJECT - Google Vertex AI (requires GOOGLE_CLOUD_LOCATION)
|
|
GOOGLE_APPLICATION_CREDENTIALS - Service account for Vertex AI
|
|
|
|
${chalk.dim("# Search & Tools")}
|
|
EXA_API_KEY - Exa web search
|
|
BRAVE_API_KEY - Brave web search
|
|
PERPLEXITY_API_KEY - Perplexity web search
|
|
ANTHROPIC_SEARCH_API_KEY - Anthropic search provider
|
|
|
|
${chalk.dim("# Configuration")}
|
|
PI_CODING_AGENT_DIR - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
|
|
PI_PACKAGE_DIR - Override package directory (for Nix/Guix store paths)
|
|
PI_SMOL_MODEL - Override smol/fast model (see --smol)
|
|
PI_SLOW_MODEL - Override slow/reasoning model (see --slow)
|
|
PI_PLAN_MODEL - Override planning model (see --plan)
|
|
PI_NO_PTY - Disable PTY-based interactive bash execution
|
|
|
|
For complete environment variable reference, see:
|
|
${chalk.dim("docs/environment-variables.md")}
|
|
${chalk.bold("Available Tools (all enabled by default):")}
|
|
read - Read file contents
|
|
bash - Execute bash commands
|
|
edit - Edit files with find/replace
|
|
write - Write files (creates/overwrites)
|
|
grep - Search file contents
|
|
find - Find files by glob pattern
|
|
lsp - Language server protocol (code intelligence)
|
|
python - Execute Python code (requires: ${APP_NAME} setup python)
|
|
notebook - Edit Jupyter notebooks
|
|
browser - Browser automation (Puppeteer)
|
|
task - Launch sub-agents for parallel tasks
|
|
todo_write - Manage todo/task lists
|
|
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` +
|
|
`Run ${APP_NAME} <command> --help for command-specific help.\n\n` +
|
|
`${getExtraHelpText()}\n`,
|
|
);
|
|
}
|