ai-cli-mcp 2.19.0 → 2.20.1

package/src/cli-builder.ts

@@ -1,274 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve as pathResolve, isAbsolute } from 'node:path';
-import type { CliPaths } from './cli-utils.js';
-import { MODEL_ALIASES } from './model-catalog.js';
-
-export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
-const CLAUDE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
-const OPENCODE_MODEL_ERROR = 'Invalid OpenCode model. Expected exact syntax oc-<provider/model>.';
-
-type Agent = 'codex' | 'claude' | 'gemini' | 'forge' | 'opencode';
-
-interface ModelSelection {
-  agent: Agent;
-  resolvedModel: string;
-  openCodeModel: string | null;
-}
-
-function getStandardAgentForModel(model: string): Exclude<Agent, 'opencode'> {
-  if (model === 'forge') {
-    return 'forge';
-  }
-  if (model.startsWith('gpt-')) {
-    return 'codex';
-  }
-  if (model.startsWith('gemini')) {
-    return 'gemini';
-  }
-  return 'claude';
-}
-
-function isPotentialOpenCodeExplicitModel(rawModel: string): boolean {
-  return rawModel.startsWith('oc-') || rawModel.trim().startsWith('oc-');
-}
-
-function extractOpenCodeModel(rawModel: string): string {
-  if (rawModel !== rawModel.trim()) {
-    throw new Error(OPENCODE_MODEL_ERROR);
-  }
-
-  if (!rawModel.startsWith('oc-')) {
-    throw new Error(OPENCODE_MODEL_ERROR);
-  }
-
-  const remainder = rawModel.slice(3);
-  const slashIndex = remainder.indexOf('/');
-  if (slashIndex === -1) {
-    throw new Error(OPENCODE_MODEL_ERROR);
-  }
-
-  const provider = remainder.slice(0, slashIndex);
-  const model = remainder.slice(slashIndex + 1);
-  if (!provider || !model) {
-    throw new Error(OPENCODE_MODEL_ERROR);
-  }
-
-  return remainder;
-}
-
-function resolveModelSelection(rawModel: string): ModelSelection {
-  if (rawModel === 'opencode') {
-    return {
-      agent: 'opencode',
-      resolvedModel: rawModel,
-      openCodeModel: null,
-    };
-  }
-
-  if (isPotentialOpenCodeExplicitModel(rawModel)) {
-    return {
-      agent: 'opencode',
-      resolvedModel: rawModel,
-      openCodeModel: extractOpenCodeModel(rawModel),
-    };
-  }
-
-  const resolvedModel = resolveModelAlias(rawModel);
-  return {
-    agent: getStandardAgentForModel(resolvedModel),
-    resolvedModel,
-    openCodeModel: null,
-  };
-}
-
-export function resolveModelAlias(model: string): string {
-  return MODEL_ALIASES[model] || model;
-}
-
-export function getReasoningEffort(model: string, rawValue: unknown): string {
-  if (typeof rawValue !== 'string') {
-    return '';
-  }
-  const trimmed = rawValue.trim();
-  if (!trimmed) {
-    return '';
-  }
-
-  if (model === 'opencode' || model.startsWith('oc-')) {
-    throw new Error('reasoning_effort is not supported for opencode.');
-  }
-
-  const normalized = trimmed.toLowerCase();
-  if (!ALLOWED_REASONING_EFFORTS.has(normalized)) {
-    throw new Error(
-      `Invalid reasoning_effort: ${rawValue}. Allowed values: low, medium, high, xhigh.`
-    );
-  }
-  const agent = getStandardAgentForModel(model);
-  if (agent === 'forge') {
-    throw new Error('reasoning_effort is not supported for forge.');
-  }
-  if (agent === 'gemini') {
-    throw new Error(
-      'reasoning_effort is only supported for Claude and Codex models.'
-    );
-  }
-  if (agent === 'claude' && !CLAUDE_REASONING_EFFORTS.has(normalized)) {
-    throw new Error(
-      'Claude reasoning_effort supports only low, medium, high.'
-    );
-  }
-  return normalized;
-}
-
-export interface CliCommand {
-  cliPath: string;
-  args: string[];
-  cwd: string;
-  agent: Agent;
-  prompt: string;
-  resolvedModel: string;
-}
-
-export interface BuildCliCommandOptions {
-  prompt?: string;
-  prompt_file?: string;
-  workFolder: string;
-  model?: string;
-  session_id?: string;
-  reasoning_effort?: string;
-  cliPaths: CliPaths;
-}
-
-export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
-  if (!options.workFolder || typeof options.workFolder !== 'string') {
-    throw new Error('Missing or invalid required parameter: workFolder');
-  }
-
-  const hasPrompt = !!options.prompt && typeof options.prompt === 'string' && options.prompt.trim() !== '';
-  const hasPromptFile = !!options.prompt_file && typeof options.prompt_file === 'string' && options.prompt_file.trim() !== '';
-
-  if (!hasPrompt && !hasPromptFile) {
-    throw new Error('Either prompt or prompt_file must be provided');
-  }
-
-  if (hasPrompt && hasPromptFile) {
-    throw new Error('Cannot specify both prompt and prompt_file. Please use only one.');
-  }
-
-  let prompt: string;
-  if (hasPrompt) {
-    prompt = options.prompt!;
-  } else {
-    const promptFilePath = isAbsolute(options.prompt_file!)
-      ? options.prompt_file!
-      : pathResolve(options.workFolder, options.prompt_file!);
-
-    if (!existsSync(promptFilePath)) {
-      throw new Error(`Prompt file does not exist: ${promptFilePath}`);
-    }
-
-    try {
-      prompt = readFileSync(promptFilePath, 'utf-8');
-    } catch (error: any) {
-      throw new Error(`Failed to read prompt file: ${error.message}`);
-    }
-  }
-
-  const cwd = pathResolve(options.workFolder);
-  if (!existsSync(cwd)) {
-    throw new Error(`Working folder does not exist: ${options.workFolder}`);
-  }
-
-  const rawModel = options.model || '';
-  const { agent, resolvedModel, openCodeModel } = resolveModelSelection(rawModel);
-
-  let reasoningEffortArg: string | undefined = options.reasoning_effort;
-  if (!reasoningEffortArg) {
-    if (rawModel === 'codex-ultra') {
-      reasoningEffortArg = 'xhigh';
-    } else if (rawModel === 'claude-ultra') {
-      reasoningEffortArg = 'high';
-    }
-  }
-
-  const reasoningTargetModel = rawModel === 'opencode' || rawModel.startsWith('oc-')
-    ? rawModel
-    : (resolvedModel || rawModel);
-  const reasoningEffort = getReasoningEffort(reasoningTargetModel, reasoningEffortArg);
-
-  let cliPath: string;
-  let args: string[];
-
-  if (agent === 'codex') {
-    cliPath = options.cliPaths.codex;
-
-    if (options.session_id && typeof options.session_id === 'string') {
-      args = ['exec', 'resume', options.session_id];
-    } else {
-      args = ['exec'];
-    }
-
-    if (reasoningEffort) {
-      args.push('-c', `model_reasoning_effort=${reasoningEffort}`);
-    }
-    if (resolvedModel) {
-      args.push('--model', resolvedModel);
-    }
-
-    args.push('--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', '--json', prompt);
-  } else if (agent === 'gemini') {
-    cliPath = options.cliPaths.gemini;
-    args = ['-y', '--output-format', 'stream-json'];
-
-    if (options.session_id && typeof options.session_id === 'string') {
-      args.push('-r', options.session_id);
-    }
-
-    if (resolvedModel) {
-      args.push('--model', resolvedModel);
-    }
-
-    args.push(prompt);
-  } else if (agent === 'forge') {
-    cliPath = options.cliPaths.forge;
-    args = ['-C', cwd];
-
-    if (options.session_id && typeof options.session_id === 'string') {
-      args.push('--conversation-id', options.session_id);
-    }
-
-    args.push('-p', prompt);
-  } else if (agent === 'opencode') {
-    cliPath = options.cliPaths.opencode;
-    args = ['run', '--format', 'json', '--dir', cwd];
-
-    if (options.session_id && typeof options.session_id === 'string') {
-      args.push('--session', options.session_id);
-    }
-
-    if (openCodeModel) {
-      args.push('--model', openCodeModel);
-    }
-
-    args.push(prompt);
-  } else {
-    cliPath = options.cliPaths.claude;
-    args = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];
-
-    if (options.session_id && typeof options.session_id === 'string') {
-      args.push('-r', options.session_id, '--fork-session');
-    }
-
-    if (reasoningEffort) {
-      args.push('--effort', reasoningEffort);
-    }
-
-    args.push('-p', prompt);
-    if (resolvedModel) {
-      args.push('--model', resolvedModel);
-    }
-  }
-
-  return { cliPath, args, cwd, agent, prompt, resolvedModel };
-}

package/src/cli-parse.ts

@@ -1,105 +0,0 @@
-#!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
-
-const AGENTS = ['claude', 'codex', 'gemini', 'forge', 'opencode'] as const;
-type Agent = typeof AGENTS[number];
-
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge|opencode>
-
-Reads raw CLI output from stdin and outputs parsed JSON to stdout.
-
-Options:
-  --agent   Agent type: claude, codex, gemini, forge, or opencode (required)
-  --help    Show this help message
-
-Examples:
-  npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" > raw.txt
-  npm run -s cli.run.parse -- --agent claude < raw.txt
-
-  npm run -s cli.run -- --model opencode --workFolder /tmp --prompt "hi" > raw.txt
-  npm run -s cli.run.parse -- --agent opencode < raw.txt
-
-  # Or pipe directly
-  npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" | npm run -s cli.run.parse -- --agent claude
-`;
-
-function parseArgs(argv: string[]): Record<string, string> {
-  const result: Record<string, string> = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg.startsWith('--')) continue;
-
-    const eqIdx = arg.indexOf('=');
-    if (eqIdx !== -1) {
-      result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
-    } else {
-      const key = arg.slice(2);
-      const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith('--')) {
-        result[key] = next;
-        i++;
-      } else {
-        result[key] = '';
-      }
-    }
-  }
-  return result;
-}
-
-function readStdin(): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    process.stdin.on('data', (chunk) => chunks.push(chunk));
-    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-    process.stdin.on('error', reject);
-  });
-}
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2));
-
-  if ('help' in args) {
-    process.stdout.write(USAGE);
-    process.exit(0);
-  }
-
-  const agent = args.agent as Agent;
-  if (!agent || !AGENTS.includes(agent)) {
-    process.stderr.write(`Error: --agent is required (claude, codex, gemini, forge, or opencode)\n\n`);
-    process.stderr.write(USAGE);
-    process.exit(1);
-  }
-
-  const input = await readStdin();
-
-  if (!input.trim()) {
-    process.stderr.write('Error: no input received from stdin\n');
-    process.exit(1);
-  }
-
-  let parsed: any = null;
-  switch (agent) {
-    case 'claude':
-      parsed = parseClaudeOutput(input);
-      break;
-    case 'codex':
-      parsed = parseCodexOutput(input);
-      break;
-    case 'gemini':
-      parsed = parseGeminiOutput(input);
-      break;
-    case 'forge':
-      parsed = parseForgeOutput(input);
-      break;
-    case 'opencode':
-      parsed = parseOpenCodeOutput(input);
-      break;
-  }
-
-  process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
-}
-
-main().catch((err) => {
-  process.stderr.write(`Fatal error: ${err.message}\n`);
-  process.exit(1);
-});