ai-cli-mcp 2.19.0 → 2.20.1

package/src/cli-utils.ts

@@ -1,258 +0,0 @@
-import { accessSync, constants } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import * as path from 'path';
-
-const debugMode = process.env.MCP_CLAUDE_DEBUG === 'true';
-
-export function debugLog(message?: any, ...optionalParams: any[]): void {
-  if (debugMode) {
-    console.error(message, ...optionalParams);
-  }
-}
-
-export interface CliBinaryStatus {
-  configuredCommand: string;
-  resolvedPath: string | null;
-  available: boolean;
-  lookup: 'env' | 'local' | 'path';
-  error?: string;
-}
-
-export type CliBinaryName = 'claude' | 'codex' | 'gemini' | 'forge' | 'opencode';
-
-export interface CliPaths {
-  claude: string;
-  codex: string;
-  gemini: string;
-  forge: string;
-  opencode: string;
-}
-
-export interface CliDoctorStatus {
-  claude: CliBinaryStatus;
-  codex: CliBinaryStatus;
-  gemini: CliBinaryStatus;
-  forge: CliBinaryStatus;
-  opencode: CliBinaryStatus;
-}
-
-function getPathDelimiter(): string {
-  return process.platform === 'win32' ? ';' : ':';
-}
-
-function getPathExtensions(): string[] {
-  if (process.platform !== 'win32') {
-    return [''];
-  }
-
-  const rawPathext = process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM';
-  return ['', ...rawPathext.split(';').filter(Boolean)];
-}
-
-function findExecutableOnPath(commandName: string): string | null {
-  const rawPath = process.env.PATH || '';
-  if (!rawPath) {
-    return null;
-  }
-
-  const pathEntries = rawPath.split(getPathDelimiter()).filter(Boolean);
-  const extensions = getPathExtensions();
-
-  for (const entry of pathEntries) {
-    for (const extension of extensions) {
-      const candidate = join(entry, `${commandName}${extension}`);
-      if (isExecutableFile(candidate)) {
-        return candidate;
-      }
-    }
-  }
-
-  return null;
-}
-
-function validateCustomCliName(envVarName: string, customCliName: string): string | null {
-  if (path.isAbsolute(customCliName)) {
-    return null;
-  }
-
-  if (
-    customCliName.startsWith('./') ||
-    customCliName.startsWith('../') ||
-    customCliName.includes('/')
-  ) {
-    return `Invalid ${envVarName}: Relative paths are not allowed. Use either a simple name (e.g., '${customCliName.split('/').pop() || 'cli'}') or an absolute path (e.g., '/tmp/${customCliName.split('/').pop() || 'cli'}-test')`;
-  }
-
-  return null;
-}
-
-function inspectCliBinary(options: {
-  envVarName: string;
-  customCliName: string | undefined;
-  defaultCliName: string;
-  localInstallPath?: string;
-}): CliBinaryStatus {
-  const configuredCommand = options.customCliName || options.defaultCliName;
-
-  if (options.customCliName) {
-    const validationError = validateCustomCliName(options.envVarName, options.customCliName);
-    if (validationError) {
-      return {
-        configuredCommand,
-        resolvedPath: null,
-        available: false,
-        lookup: 'env',
-        error: validationError,
-      };
-    }
-
-    if (path.isAbsolute(options.customCliName)) {
-      return {
-        configuredCommand,
-        resolvedPath: options.customCliName,
-        available: isExecutableFile(options.customCliName),
-        lookup: 'env',
-      };
-    }
-
-    const resolvedPath = findExecutableOnPath(configuredCommand);
-    return {
-      configuredCommand,
-      resolvedPath,
-      available: resolvedPath !== null,
-      lookup: 'env',
-    };
-  }
-
-  if (options.localInstallPath && isExecutableFile(options.localInstallPath)) {
-    return {
-      configuredCommand,
-      resolvedPath: options.localInstallPath,
-      available: true,
-      lookup: 'local',
-    };
-  }
-
-  const resolvedPath = findExecutableOnPath(configuredCommand);
-  return {
-    configuredCommand,
-    resolvedPath,
-    available: resolvedPath !== null,
-    lookup: 'path',
-  };
-}
-
-function getCliCommandOrThrow(status: CliBinaryStatus): string {
-  if (status.error) {
-    throw new Error(status.error);
-  }
-
-  if (status.lookup === 'env' && !path.isAbsolute(status.configuredCommand)) {
-    return status.configuredCommand;
-  }
-
-  return status.resolvedPath || status.configuredCommand;
-}
-
-function isExecutableFile(filePath: string): boolean {
-  try {
-    accessSync(filePath, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function getCliBinaryConfig(name: CliBinaryName): {
-  envVarName: string;
-  customCliName: string | undefined;
-  defaultCliName: string;
-  localInstallPath?: string;
-} {
-  if (name === 'claude') {
-    return {
-      envVarName: 'CLAUDE_CLI_NAME',
-      customCliName: process.env.CLAUDE_CLI_NAME,
-      defaultCliName: 'claude',
-      localInstallPath: join(homedir(), '.claude', 'local', 'claude'),
-    };
-  }
-
-  if (name === 'codex') {
-    return {
-      envVarName: 'CODEX_CLI_NAME',
-      customCliName: process.env.CODEX_CLI_NAME,
-      defaultCliName: 'codex',
-      localInstallPath: join(homedir(), '.codex', 'local', 'codex'),
-    };
-  }
-
-  if (name === 'forge') {
-    return {
-      envVarName: 'FORGE_CLI_NAME',
-      customCliName: process.env.FORGE_CLI_NAME,
-      defaultCliName: 'forge',
-      localInstallPath: join(homedir(), '.forge', 'local', 'forge'),
-    };
-  }
-
-  if (name === 'opencode') {
-    return {
-      envVarName: 'OPENCODE_CLI_NAME',
-      customCliName: process.env.OPENCODE_CLI_NAME,
-      defaultCliName: 'opencode',
-    };
-  }
-
-  return {
-    envVarName: 'GEMINI_CLI_NAME',
-    customCliName: process.env.GEMINI_CLI_NAME,
-    defaultCliName: 'gemini',
-    localInstallPath: join(homedir(), '.gemini', 'local', 'gemini'),
-  };
-}
-
-function getCliBinaryStatus(name: CliBinaryName): CliBinaryStatus {
-  return inspectCliBinary(getCliBinaryConfig(name));
-}
-
-export function getCliDoctorStatus(): CliDoctorStatus {
-  return {
-    claude: getCliBinaryStatus('claude'),
-    codex: getCliBinaryStatus('codex'),
-    gemini: getCliBinaryStatus('gemini'),
-    forge: getCliBinaryStatus('forge'),
-    opencode: getCliBinaryStatus('opencode'),
-  };
-}
-
-export function findGeminiCli(): string {
-  debugLog('[Debug] Attempting to find Gemini CLI...');
-  const status = getCliBinaryStatus('gemini');
-  return getCliCommandOrThrow(status);
-}
-
-export function findCodexCli(): string {
-  debugLog('[Debug] Attempting to find Codex CLI...');
-  const status = getCliBinaryStatus('codex');
-  return getCliCommandOrThrow(status);
-}
-
-export function findForgeCli(): string {
-  debugLog('[Debug] Attempting to find Forge CLI...');
-  const status = getCliBinaryStatus('forge');
-  return getCliCommandOrThrow(status);
-}
-
-export function findOpencodeCli(): string {
-  debugLog('[Debug] Attempting to find OpenCode CLI...');
-  const status = getCliBinaryStatus('opencode');
-  return getCliCommandOrThrow(status);
-}
-
-export function findClaudeCli(): string {
-  debugLog('[Debug] Attempting to find Claude CLI...');
-  const status = getCliBinaryStatus('claude');
-  return getCliCommandOrThrow(status);
-}

package/src/cli.ts

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import { buildCliCommand } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
-
-/**
- * Minimal argv parser. No external dependencies.
- * Supports: --key value, --key=value
- */
-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) {
-      // --key=value
-      result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
-    } else {
-      // --key value
-      const key = arg.slice(2);
-      const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith('--')) {
-        result[key] = next;
-        i++;
-      } else {
-        result[key] = '';
-      }
-    }
-  }
-  return result;
-}
-
-const USAGE = `Usage: npm run -s cli.run -- --model <model> --workFolder <path> --prompt "..." [options]
-
-Options:
-  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro, forge, opencode, oc-openai/gpt-5.4)
-  --workFolder         Working directory (absolute path)
-  --prompt             Prompt string (mutually exclusive with --prompt_file)
-  --prompt_file        Path to a file containing the prompt
-  --session_id         Session ID to resume, including OpenCode in-place resumes
-  --reasoning_effort   Claude/Codex only: Claude=low|medium|high, Codex=low|medium|high|xhigh; unsupported for Gemini, Forge, and OpenCode
-  --help               Show this help message
-
-Raw CLI output goes to stdout. Use cli.run.parse to parse the output:
-  npm run -s cli.run -- ... > raw.txt
-  npm run -s cli.run.parse -- --agent claude < raw.txt
-  npm run -s cli.run.parse -- --agent opencode < raw.txt
-`;
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2));
-
-  if ('help' in args) {
-    process.stdout.write(USAGE);
-    process.exit(0);
-  }
-
-  if (!args.workFolder) {
-    process.stderr.write('Error: --workFolder is required\n\n');
-    process.stderr.write(USAGE);
-    process.exit(1);
-  }
-
-  if (!args.prompt && !args.prompt_file) {
-    process.stderr.write('Error: --prompt or --prompt_file is required\n\n');
-    process.stderr.write(USAGE);
-    process.exit(1);
-  }
-
-  // Resolve CLI paths
-  const cliPaths = {
-    claude: findClaudeCli(),
-    codex: findCodexCli(),
-    gemini: findGeminiCli(),
-    forge: findForgeCli(),
-    opencode: findOpencodeCli(),
-  };
-
-  // Build command
-  let cmd;
-  try {
-    cmd = buildCliCommand({
-      prompt: args.prompt || undefined,
-      prompt_file: args.prompt_file || undefined,
-      workFolder: args.workFolder,
-      model: args.model || undefined,
-      session_id: args.session_id || undefined,
-      reasoning_effort: args.reasoning_effort || undefined,
-      cliPaths,
-    });
-  } catch (error: any) {
-    process.stderr.write(`Error: ${error.message}\n`);
-    process.exit(1);
-  }
-
-  // Log agent info to stderr (does not pollute stdout)
-  process.stderr.write(`[cli.run] agent=${cmd.agent} model=${cmd.resolvedModel || '(default)'}\n`);
-
-  // Spawn foreground process — raw output passthrough
-  const child = spawn(cmd.cliPath, cmd.args, {
-    cwd: cmd.cwd,
-    stdio: 'inherit',
-    detached: false,
-  });
-
-  const exitCode = await new Promise<number>((resolve) => {
-    child.on('close', (code) => {
-      resolve(code ?? 1);
-    });
-    child.on('error', (err) => {
-      process.stderr.write(`Process error: ${err.message}\n`);
-      resolve(1);
-    });
-  });
-
-  process.exit(exitCode);
-}
-
-main().catch((err) => {
-  process.stderr.write(`Fatal error: ${err.message}\n`);
-  process.exit(1);
-});

package/src/model-catalog.ts

@@ -1,87 +0,0 @@
-export const CLAUDE_MODELS = ['sonnet', 'sonnet[1m]', 'opus', 'opusplan', 'haiku'] as const;
-export const CODEX_MODELS = [
-  'gpt-5.4',
-  'gpt-5.3-codex',
-  'gpt-5.2-codex',
-  'gpt-5.1-codex-mini',
-  'gpt-5.1-codex-max',
-  'gpt-5.2',
-  'gpt-5.1',
-  'gpt-5.1-codex',
-  'gpt-5-codex',
-  'gpt-5-codex-mini',
-  'gpt-5',
-] as const;
-export const GEMINI_MODELS = [
-  'gemini-2.5-pro',
-  'gemini-2.5-flash',
-  'gemini-3.1-pro-preview',
-  'gemini-3-pro-preview',
-  'gemini-3-flash-preview',
-] as const;
-export const FORGE_MODELS = ['forge'] as const;
-export const OPENCODE_MODELS = ['opencode'] as const;
-
-export const MODEL_ALIASES: Record<string, string> = {
-  'claude-ultra': 'opus',
-  'codex-ultra': 'gpt-5.4',
-  'gemini-ultra': 'gemini-3.1-pro-preview',
-};
-
-export const MODEL_ALIAS_DETAILS = [
-  { name: 'claude-ultra', resolvesTo: 'opus', agent: 'claude', defaultReasoningEffort: 'high' },
-  { name: 'codex-ultra', resolvesTo: 'gpt-5.4', agent: 'codex', defaultReasoningEffort: 'xhigh' },
-  { name: 'gemini-ultra', resolvesTo: 'gemini-3.1-pro-preview', agent: 'gemini' },
-] as const;
-
-export interface DynamicModelBackendDescription {
-  explicitPrefix: string;
-  explicitPattern: string;
-  discoveryCommand: string;
-  modelsAreDynamic: boolean;
-}
-
-export function getSupportedModelsDescription(): string {
-  return [
-    '"claude-ultra", "codex-ultra", "gemini-ultra"',
-    ...CLAUDE_MODELS.map((model) => `"${model}"`),
-    ...CODEX_MODELS.map((model) => `"${model}"`),
-    ...GEMINI_MODELS.map((model) => `"${model}"`),
-    ...FORGE_MODELS.map((model) => `"${model}"`),
-    ...OPENCODE_MODELS.map((model) => `"${model}"`),
-    '"oc-<provider/model>"',
-  ].join(', ');
-}
-
-export function getModelParameterDescription(): string {
-  return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS, ...OPENCODE_MODELS].map((model) => `"${model}"`).join(', ')}. OpenCode also accepts explicit dynamic models using "oc-<provider/model>". "forge" is a provider key, not a Forge model family selector.`;
-}
-
-export function getModelsPayload(): {
-  aliases: ReadonlyArray<(typeof MODEL_ALIAS_DETAILS)[number]>;
-  claude: ReadonlyArray<string>;
-  codex: ReadonlyArray<string>;
-  gemini: ReadonlyArray<string>;
-  forge: ReadonlyArray<string>;
-  opencode: ReadonlyArray<string>;
-  dynamicModelBackends: {
-    opencode: DynamicModelBackendDescription;
-  };
-} {
-  return {
-    aliases: MODEL_ALIAS_DETAILS,
-    claude: CLAUDE_MODELS,
-    codex: CODEX_MODELS,
-    gemini: GEMINI_MODELS,
-    forge: FORGE_MODELS,
-    opencode: OPENCODE_MODELS,
-    dynamicModelBackends: {
-      opencode: {
-        explicitPrefix: 'oc-',
-        explicitPattern: 'oc-<provider/model>',
-        discoveryCommand: 'opencode models',
-        modelsAreDynamic: true,
-      },
-    },
-  };
-}