coding-agent-adapters 0.1.0

package/dist/index.js

@@ -0,0 +1,795 @@
+import { BaseCLIAdapter } from 'pty-manager';
+
+// src/base-coding-adapter.ts
+var BaseCodingAdapter = class extends BaseCLIAdapter {
+  /**
+   * Get credentials from config
+   */
+  getCredentials(config) {
+    const adapterConfig = config.adapterConfig;
+    return adapterConfig || {};
+  }
+  /**
+   * Override detectExit to include installation instructions
+   */
+  detectExit(output) {
+    if (output.includes("Command not found") || output.includes("command not found")) {
+      return {
+        exited: true,
+        code: 127,
+        error: `${this.displayName} CLI not found. Install with: ${this.installation.command}
+Docs: ${this.installation.docsUrl}`
+      };
+    }
+    return super.detectExit(output);
+  }
+  /**
+   * Get formatted installation instructions
+   */
+  getInstallInstructions() {
+    const lines = [
+      `${this.displayName} Installation`,
+      `${"=".repeat(this.displayName.length + 13)}`,
+      "",
+      `Primary: ${this.installation.command}`
+    ];
+    if (this.installation.alternatives?.length) {
+      lines.push("");
+      lines.push("Alternatives:");
+      for (const alt of this.installation.alternatives) {
+        lines.push(`  - ${alt}`);
+      }
+    }
+    lines.push("");
+    lines.push(`Docs: ${this.installation.docsUrl}`);
+    if (this.installation.minVersion) {
+      lines.push(`Minimum version: ${this.installation.minVersion}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Check if response appears complete based on common patterns
+   */
+  isResponseComplete(output) {
+    const completionIndicators = [
+      /\n>\s*$/,
+      // Ends with prompt
+      /\n\s*$/,
+      // Ends with newline
+      /Done\./i,
+      // Explicit done
+      /completed/i,
+      // Task completed
+      /finished/i,
+      // Finished
+      /```\s*$/
+      // Code block ended
+    ];
+    return completionIndicators.some((pattern) => pattern.test(output));
+  }
+  /**
+   * Extract the main content from CLI output, removing common artifacts
+   */
+  extractContent(output, promptPattern) {
+    let content = output;
+    content = content.replace(promptPattern, "");
+    content = content.replace(/^(Thinking|Working|Reading|Writing|Processing|Generating)\.+$/gm, "");
+    content = content.trim();
+    return content;
+  }
+};
+
+// src/claude-adapter.ts
+var ClaudeAdapter = class extends BaseCodingAdapter {
+  adapterType = "claude";
+  displayName = "Claude Code";
+  installation = {
+    command: "npm install -g @anthropic-ai/claude-code",
+    alternatives: [
+      "npx @anthropic-ai/claude-code (run without installing)",
+      "brew install claude-code (macOS with Homebrew)"
+    ],
+    docsUrl: "https://docs.anthropic.com/en/docs/claude-code",
+    minVersion: "1.0.0"
+  };
+  /**
+   * Auto-response rules for Claude Code CLI.
+   * These handle common prompts that can be safely auto-responded.
+   */
+  autoResponseRules = [
+    {
+      pattern: /update available.*\[y\/n\]/i,
+      type: "update",
+      response: "n",
+      description: "Decline Claude Code update to continue execution",
+      safe: true
+    },
+    {
+      pattern: /new version.*available.*\[y\/n\]/i,
+      type: "update",
+      response: "n",
+      description: "Decline version upgrade prompt",
+      safe: true
+    },
+    {
+      pattern: /would you like to enable.*telemetry.*\[y\/n\]/i,
+      type: "config",
+      response: "n",
+      description: "Decline telemetry prompt",
+      safe: true
+    },
+    {
+      pattern: /send anonymous usage data.*\[y\/n\]/i,
+      type: "config",
+      response: "n",
+      description: "Decline anonymous usage data",
+      safe: true
+    },
+    {
+      pattern: /continue without.*\[y\/n\]/i,
+      type: "config",
+      response: "y",
+      description: "Continue without optional feature",
+      safe: true
+    }
+  ];
+  getCommand() {
+    return "claude";
+  }
+  getArgs(config) {
+    const args = [];
+    args.push("--print");
+    if (config.workdir) {
+      args.push("--cwd", config.workdir);
+    }
+    return args;
+  }
+  getEnv(config) {
+    const env = {};
+    const credentials = this.getCredentials(config);
+    if (credentials.anthropicKey) {
+      env.ANTHROPIC_API_KEY = credentials.anthropicKey;
+    }
+    if (config.env?.ANTHROPIC_MODEL) {
+      env.ANTHROPIC_MODEL = config.env.ANTHROPIC_MODEL;
+    }
+    env.CLAUDE_CODE_DISABLE_INTERACTIVE = "true";
+    return env;
+  }
+  detectLogin(output) {
+    const stripped = this.stripAnsi(output);
+    if (stripped.includes("API key not found") || stripped.includes("ANTHROPIC_API_KEY") || stripped.includes("authentication required") || stripped.includes("Please sign in") || stripped.includes("Invalid API key")) {
+      return {
+        required: true,
+        type: "api_key",
+        instructions: "Set ANTHROPIC_API_KEY environment variable or provide credentials in adapterConfig"
+      };
+    }
+    if (stripped.includes("Open this URL") || stripped.includes("browser to authenticate")) {
+      const urlMatch = stripped.match(/https?:\/\/[^\s]+/);
+      return {
+        required: true,
+        type: "browser",
+        url: urlMatch ? urlMatch[0] : void 0,
+        instructions: "Browser authentication required"
+      };
+    }
+    return { required: false };
+  }
+  /**
+   * Detect blocking prompts specific to Claude Code CLI
+   */
+  detectBlockingPrompt(output) {
+    const stripped = this.stripAnsi(output);
+    const loginDetection = this.detectLogin(output);
+    if (loginDetection.required) {
+      return {
+        detected: true,
+        type: "login",
+        prompt: loginDetection.instructions,
+        url: loginDetection.url,
+        canAutoRespond: false,
+        instructions: loginDetection.instructions
+      };
+    }
+    if (/choose.*model|select.*model|available models/i.test(stripped) && /\d+\)|claude-/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "model_select",
+        prompt: "Claude model selection",
+        canAutoRespond: false,
+        instructions: "Please select a Claude model or set ANTHROPIC_MODEL env var"
+      };
+    }
+    if (/which.*tier|select.*plan|api.*tier/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "config",
+        prompt: "API tier selection",
+        canAutoRespond: false,
+        instructions: "Please select an API tier"
+      };
+    }
+    if (/welcome to claude|first time setup|initial configuration/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "config",
+        prompt: "First-time setup",
+        canAutoRespond: false,
+        instructions: "Claude Code requires initial configuration"
+      };
+    }
+    if (/allow.*access|grant.*permission|access to .* files/i.test(stripped) && /\[y\/n\]/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "permission",
+        prompt: "File/directory access permission",
+        options: ["y", "n"],
+        suggestedResponse: "y",
+        canAutoRespond: true,
+        instructions: "Claude Code requesting file access permission"
+      };
+    }
+    return super.detectBlockingPrompt(output);
+  }
+  detectReady(output) {
+    const stripped = this.stripAnsi(output);
+    return stripped.includes("Claude Code") || stripped.includes("How can I help") || stripped.includes("What would you like") || // Check for the typical prompt pattern
+    />\s*$/.test(stripped) || // Or a clear ready indicator
+    stripped.includes("Ready");
+  }
+  parseOutput(output) {
+    const stripped = this.stripAnsi(output);
+    const isComplete = this.isResponseComplete(stripped);
+    if (!isComplete) {
+      return null;
+    }
+    const isQuestion = this.containsQuestion(stripped);
+    const content = this.extractContent(stripped, /^.*>\s*/gm);
+    return {
+      type: isQuestion ? "question" : "response",
+      content,
+      isComplete: true,
+      isQuestion,
+      metadata: {
+        raw: output
+      }
+    };
+  }
+  getPromptPattern() {
+    return /(?:claude|>)\s*$/i;
+  }
+  getHealthCheckCommand() {
+    return "claude --version";
+  }
+};
+
+// src/gemini-adapter.ts
+var GeminiAdapter = class extends BaseCodingAdapter {
+  adapterType = "gemini";
+  displayName = "Google Gemini";
+  installation = {
+    command: "npm install -g @anthropics/gemini-cli",
+    alternatives: [
+      "See documentation for latest installation method"
+    ],
+    docsUrl: "https://github.com/anthropics/gemini-cli#installation"
+  };
+  getCommand() {
+    return "gemini";
+  }
+  getArgs(config) {
+    const args = [];
+    args.push("--non-interactive");
+    if (config.workdir) {
+      args.push("--cwd", config.workdir);
+    }
+    args.push("--output-format", "text");
+    return args;
+  }
+  getEnv(config) {
+    const env = {};
+    const credentials = this.getCredentials(config);
+    if (credentials.googleKey) {
+      env.GOOGLE_API_KEY = credentials.googleKey;
+      env.GEMINI_API_KEY = credentials.googleKey;
+    }
+    if (config.env?.GEMINI_MODEL) {
+      env.GEMINI_MODEL = config.env.GEMINI_MODEL;
+    }
+    env.NO_COLOR = "1";
+    return env;
+  }
+  detectLogin(output) {
+    const stripped = this.stripAnsi(output);
+    if (stripped.includes("API key not found") || stripped.includes("GOOGLE_API_KEY") || stripped.includes("GEMINI_API_KEY") || stripped.includes("authentication required") || stripped.includes("Invalid API key") || stripped.includes("API key is not valid")) {
+      return {
+        required: true,
+        type: "api_key",
+        instructions: "Set GOOGLE_API_KEY or GEMINI_API_KEY environment variable"
+      };
+    }
+    if (stripped.includes("Sign in with Google") || stripped.includes("OAuth") || stripped.includes("accounts.google.com")) {
+      const urlMatch = stripped.match(/https?:\/\/[^\s]+/);
+      return {
+        required: true,
+        type: "oauth",
+        url: urlMatch ? urlMatch[0] : "https://accounts.google.com",
+        instructions: "Google OAuth authentication required"
+      };
+    }
+    if (stripped.includes("Application Default Credentials") || stripped.includes("gcloud auth")) {
+      return {
+        required: true,
+        type: "browser",
+        instructions: "Run: gcloud auth application-default login"
+      };
+    }
+    return { required: false };
+  }
+  detectBlockingPrompt(output) {
+    const stripped = this.stripAnsi(output);
+    const loginDetection = this.detectLogin(output);
+    if (loginDetection.required) {
+      return {
+        detected: true,
+        type: "login",
+        prompt: loginDetection.instructions,
+        url: loginDetection.url,
+        canAutoRespond: false,
+        instructions: loginDetection.instructions
+      };
+    }
+    if (/select.*model|choose.*model|gemini-/i.test(stripped) && /\d+\)/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "model_select",
+        prompt: "Gemini model selection",
+        canAutoRespond: false,
+        instructions: "Please select a model or set GEMINI_MODEL env var"
+      };
+    }
+    if (/select.*project|choose.*project|google cloud project/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "project_select",
+        prompt: "Google Cloud project selection",
+        canAutoRespond: false,
+        instructions: "Please select a Google Cloud project"
+      };
+    }
+    if (/safety.*filter|content.*blocked|unsafe.*content/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "unknown",
+        prompt: "Safety filter triggered",
+        canAutoRespond: false,
+        instructions: "Content was blocked by safety filters"
+      };
+    }
+    return super.detectBlockingPrompt(output);
+  }
+  detectReady(output) {
+    const stripped = this.stripAnsi(output);
+    return stripped.includes("Gemini") || stripped.includes("Ready") || stripped.includes("How can I help") || stripped.includes("What would you like") || /(?:gemini|>)\s*$/i.test(stripped);
+  }
+  parseOutput(output) {
+    const stripped = this.stripAnsi(output);
+    const isComplete = this.isResponseComplete(stripped);
+    if (!isComplete) {
+      return null;
+    }
+    const isQuestion = this.containsQuestion(stripped);
+    let content = this.extractContent(stripped, /^.*(?:gemini|>)\s*/gim);
+    content = content.replace(/^\[Safety[^\]]*\].*$/gm, "");
+    return {
+      type: isQuestion ? "question" : "response",
+      content,
+      isComplete: true,
+      isQuestion,
+      metadata: {
+        raw: output
+      }
+    };
+  }
+  getPromptPattern() {
+    return /(?:gemini|>)\s*$/i;
+  }
+  getHealthCheckCommand() {
+    return "gemini --version";
+  }
+};
+
+// src/codex-adapter.ts
+var CodexAdapter = class extends BaseCodingAdapter {
+  adapterType = "codex";
+  displayName = "OpenAI Codex";
+  installation = {
+    command: "npm install -g @openai/codex",
+    alternatives: [
+      "pip install openai (Python SDK)"
+    ],
+    docsUrl: "https://github.com/openai/codex"
+  };
+  /**
+   * Auto-response rules for OpenAI Codex CLI.
+   */
+  autoResponseRules = [
+    {
+      pattern: /update available.*\[y\/n\]/i,
+      type: "update",
+      response: "n",
+      description: "Decline Codex update to continue execution",
+      safe: true
+    },
+    {
+      pattern: /new version.*\[y\/n\]/i,
+      type: "update",
+      response: "n",
+      description: "Decline version upgrade",
+      safe: true
+    },
+    {
+      pattern: /send.*telemetry.*\[y\/n\]/i,
+      type: "config",
+      response: "n",
+      description: "Decline telemetry",
+      safe: true
+    },
+    {
+      pattern: /enable.*beta.*features.*\[y\/n\]/i,
+      type: "config",
+      response: "n",
+      description: "Decline beta features",
+      safe: true
+    }
+  ];
+  getCommand() {
+    return "codex";
+  }
+  getArgs(config) {
+    const args = [];
+    args.push("--quiet");
+    if (config.workdir) {
+      args.push("--cwd", config.workdir);
+    }
+    return args;
+  }
+  getEnv(config) {
+    const env = {};
+    const credentials = this.getCredentials(config);
+    if (credentials.openaiKey) {
+      env.OPENAI_API_KEY = credentials.openaiKey;
+    }
+    if (config.env?.OPENAI_MODEL) {
+      env.OPENAI_MODEL = config.env.OPENAI_MODEL;
+    }
+    env.NO_COLOR = "1";
+    return env;
+  }
+  detectLogin(output) {
+    const stripped = this.stripAnsi(output);
+    if (stripped.includes("API key not found") || stripped.includes("OPENAI_API_KEY") || stripped.includes("authentication required") || stripped.includes("Invalid API key") || stripped.includes("Unauthorized") || stripped.includes("API key is invalid")) {
+      return {
+        required: true,
+        type: "api_key",
+        instructions: "Set OPENAI_API_KEY environment variable or provide credentials in adapterConfig"
+      };
+    }
+    if (stripped.includes("device code") || stripped.includes("Enter the code")) {
+      const codeMatch = stripped.match(/code[:\s]+([A-Z0-9-]+)/i);
+      const urlMatch = stripped.match(/https?:\/\/[^\s]+/);
+      return {
+        required: true,
+        type: "device_code",
+        url: urlMatch ? urlMatch[0] : void 0,
+        instructions: codeMatch ? `Enter code ${codeMatch[1]} at the URL` : "Device code authentication required"
+      };
+    }
+    return { required: false };
+  }
+  /**
+   * Detect blocking prompts specific to OpenAI Codex CLI
+   */
+  detectBlockingPrompt(output) {
+    const stripped = this.stripAnsi(output);
+    const loginDetection = this.detectLogin(output);
+    if (loginDetection.required) {
+      return {
+        detected: true,
+        type: "login",
+        prompt: loginDetection.instructions,
+        url: loginDetection.url,
+        canAutoRespond: false,
+        instructions: loginDetection.instructions
+      };
+    }
+    if (/select.*model|choose.*model|gpt-4|gpt-3\.5/i.test(stripped) && /\d+\)/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "model_select",
+        prompt: "OpenAI model selection",
+        canAutoRespond: false,
+        instructions: "Please select a model or set OPENAI_MODEL env var"
+      };
+    }
+    if (/select.*organization|choose.*org|multiple organizations/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "config",
+        prompt: "Organization selection",
+        canAutoRespond: false,
+        instructions: "Please select an OpenAI organization"
+      };
+    }
+    if (/rate limit|too many requests/i.test(stripped) && /retry|wait/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "unknown",
+        prompt: "Rate limit reached",
+        canAutoRespond: false,
+        instructions: "OpenAI rate limit reached - please wait"
+      };
+    }
+    return super.detectBlockingPrompt(output);
+  }
+  detectReady(output) {
+    const stripped = this.stripAnsi(output);
+    return stripped.includes("Codex") || stripped.includes("Ready") || stripped.includes("How can I help") || /(?:codex|>)\s*$/i.test(stripped);
+  }
+  parseOutput(output) {
+    const stripped = this.stripAnsi(output);
+    const isComplete = this.isResponseComplete(stripped);
+    if (!isComplete) {
+      return null;
+    }
+    const isQuestion = this.containsQuestion(stripped);
+    const content = this.extractContent(stripped, /^.*(?:codex|>)\s*/gim);
+    return {
+      type: isQuestion ? "question" : "response",
+      content,
+      isComplete: true,
+      isQuestion,
+      metadata: {
+        raw: output
+      }
+    };
+  }
+  getPromptPattern() {
+    return /(?:codex|>)\s*$/i;
+  }
+  getHealthCheckCommand() {
+    return "codex --version";
+  }
+};
+
+// src/aider-adapter.ts
+var AiderAdapter = class extends BaseCodingAdapter {
+  adapterType = "aider";
+  displayName = "Aider";
+  installation = {
+    command: "pip install aider-chat",
+    alternatives: [
+      "pipx install aider-chat (isolated install)",
+      "brew install aider (macOS with Homebrew)"
+    ],
+    docsUrl: "https://aider.chat/docs/install.html",
+    minVersion: "0.50.0"
+  };
+  /**
+   * Auto-response rules for Aider CLI.
+   */
+  autoResponseRules = [
+    {
+      pattern: /Add .+ to the chat\?.*\[y\/n\]/i,
+      type: "permission",
+      response: "y",
+      description: "Allow Aider to add files to chat context",
+      safe: true
+    },
+    {
+      pattern: /Create new file.*\[y\/n\]/i,
+      type: "permission",
+      response: "y",
+      description: "Allow Aider to create new files",
+      safe: true
+    },
+    {
+      pattern: /Apply.*changes.*\[y\/n\]/i,
+      type: "permission",
+      response: "y",
+      description: "Apply proposed changes",
+      safe: true
+    }
+  ];
+  getCommand() {
+    return "aider";
+  }
+  getArgs(config) {
+    const args = [];
+    args.push("--auto-commits");
+    args.push("--no-pretty");
+    args.push("--no-show-diffs");
+    const credentials = this.getCredentials(config);
+    if (config.env?.AIDER_MODEL) {
+      args.push("--model", config.env.AIDER_MODEL);
+    }
+    if (credentials.anthropicKey && !config.env?.AIDER_MODEL) {
+      args.push("--model", "claude-3-5-sonnet-20241022");
+    }
+    return args;
+  }
+  getEnv(config) {
+    const env = {};
+    const credentials = this.getCredentials(config);
+    if (credentials.anthropicKey) {
+      env.ANTHROPIC_API_KEY = credentials.anthropicKey;
+    }
+    if (credentials.openaiKey) {
+      env.OPENAI_API_KEY = credentials.openaiKey;
+    }
+    if (credentials.googleKey) {
+      env.GOOGLE_API_KEY = credentials.googleKey;
+    }
+    env.NO_COLOR = "1";
+    if (config.env?.AIDER_NO_GIT === "true") {
+      env.AIDER_NO_GIT = "true";
+    }
+    return env;
+  }
+  detectLogin(output) {
+    const stripped = this.stripAnsi(output);
+    if (stripped.includes("No API key") || stripped.includes("API key not found") || stripped.includes("ANTHROPIC_API_KEY") || stripped.includes("OPENAI_API_KEY") || stripped.includes("Missing API key")) {
+      return {
+        required: true,
+        type: "api_key",
+        instructions: "Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"
+      };
+    }
+    if (stripped.includes("Invalid API key") || stripped.includes("Authentication failed") || stripped.includes("Unauthorized")) {
+      return {
+        required: true,
+        type: "api_key",
+        instructions: "API key is invalid - please check your credentials"
+      };
+    }
+    return { required: false };
+  }
+  detectBlockingPrompt(output) {
+    const stripped = this.stripAnsi(output);
+    const loginDetection = this.detectLogin(output);
+    if (loginDetection.required) {
+      return {
+        detected: true,
+        type: "login",
+        prompt: loginDetection.instructions,
+        canAutoRespond: false,
+        instructions: loginDetection.instructions
+      };
+    }
+    if (/select.*model|choose.*model|which model/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "model_select",
+        prompt: "Model selection required",
+        canAutoRespond: false,
+        instructions: "Please select a model or set AIDER_MODEL env var"
+      };
+    }
+    if (/not.*git.*repo|git.*not.*found|initialize.*git/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "config",
+        prompt: "Git repository required",
+        canAutoRespond: false,
+        instructions: "Aider requires a git repository. Run git init or use --no-git"
+      };
+    }
+    if (/delete|remove|overwrite/i.test(stripped) && /\[y\/n\]/i.test(stripped)) {
+      return {
+        detected: true,
+        type: "permission",
+        prompt: "Destructive operation confirmation",
+        options: ["y", "n"],
+        canAutoRespond: false,
+        instructions: "Aider is asking to perform a potentially destructive operation"
+      };
+    }
+    return super.detectBlockingPrompt(output);
+  }
+  detectReady(output) {
+    const stripped = this.stripAnsi(output);
+    return stripped.includes("aider>") || stripped.includes("Aider") || /aider.*ready/i.test(stripped) || // Aider shows file list when ready
+    /Added.*to the chat/i.test(stripped) || // Or the prompt
+    />\s*$/.test(stripped);
+  }
+  parseOutput(output) {
+    const stripped = this.stripAnsi(output);
+    const isComplete = this.isResponseComplete(stripped);
+    if (!isComplete) {
+      return null;
+    }
+    const isQuestion = this.containsQuestion(stripped);
+    let content = this.extractContent(stripped, /^.*aider>\s*/gim);
+    content = content.replace(/^(Added|Removed|Created|Updated) .+ (to|from) the chat\.?$/gm, "");
+    return {
+      type: isQuestion ? "question" : "response",
+      content: content.trim(),
+      isComplete: true,
+      isQuestion,
+      metadata: {
+        raw: output
+      }
+    };
+  }
+  getPromptPattern() {
+    return /(?:aider>|>)\s*$/i;
+  }
+  getHealthCheckCommand() {
+    return "aider --version";
+  }
+};
+
+// src/index.ts
+function createAllAdapters() {
+  return [
+    new ClaudeAdapter(),
+    new GeminiAdapter(),
+    new CodexAdapter(),
+    new AiderAdapter()
+  ];
+}
+var ADAPTER_TYPES = {
+  claude: ClaudeAdapter,
+  gemini: GeminiAdapter,
+  codex: CodexAdapter,
+  aider: AiderAdapter
+};
+function createAdapter(type) {
+  const AdapterClass = ADAPTER_TYPES[type];
+  if (!AdapterClass) {
+    throw new Error(`Unknown adapter type: ${type}`);
+  }
+  return new AdapterClass();
+}
+async function checkAdapters(types) {
+  const results = [];
+  for (const type of types) {
+    const adapter = createAdapter(type);
+    const validation = await adapter.validateInstallation();
+    results.push({
+      adapter: adapter.displayName,
+      installed: validation.installed,
+      version: validation.version,
+      error: validation.error,
+      installCommand: adapter.installation.command,
+      docsUrl: adapter.installation.docsUrl
+    });
+  }
+  return results;
+}
+async function checkAllAdapters() {
+  return checkAdapters(Object.keys(ADAPTER_TYPES));
+}
+async function printMissingAdapters(types) {
+  const results = types ? await checkAdapters(types) : await checkAllAdapters();
+  const missing = results.filter((r) => !r.installed);
+  if (missing.length === 0) {
+    console.log("All CLI tools are installed!");
+    return;
+  }
+  console.log("\nMissing CLI tools:\n");
+  for (const m of missing) {
+    console.log(`${m.adapter}`);
+    console.log(`  Install: ${m.installCommand}`);
+    console.log(`  Docs: ${m.docsUrl}`);
+    if (m.error) {
+      console.log(`  Error: ${m.error}`);
+    }
+    console.log();
+  }
+}
+
+export { ADAPTER_TYPES, AiderAdapter, BaseCodingAdapter, ClaudeAdapter, CodexAdapter, GeminiAdapter, checkAdapters, checkAllAdapters, createAdapter, createAllAdapters, printMissingAdapters };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map