Add Anthropic support and revamped interactive configure

✨ Add Anthropic provider and revamp configuration flow

- Add Anthropic support across the codebase: detect API keys, provide hardcoded/latest model lists for OpenAI/Anthropic, and expose fetch_models_for_provider() for dynamic model discovery.
- Revamp the interactive configure command to let users pick provider, enter or detect API keys, fetch and select models asynchronously, choose a personality, and write a new v1.3 config schema (provider, model, personality, and provider-specific API key). Support non-interactive mode behavior and improve UX (browser prompts, summaries).
- Update LanguageModelManager to understand the new config format, prefer API keys from the config file, normalize provider names, add safer validation and clearer error messaging, and change default model to gpt-5.
- Adjust CLI bootstrap to pass ANTHROPIC_API_KEY into configure when present and remove implicit environment injection of OPENAI_API_KEY.
- Increase commit command response token default to 1000.
- Add comprehensive tests for API key detection, model fetching, and new/legacy config reading.

This change modernizes multi-provider support and makes configuration interactive, extensible, and testable. 🤖

Author: Nick Sullivan

aicodebot/cli.py

@@ -26,10 +26,10 @@ def cli(ctx, debug_output):
     if not existing_config:
         if ctx.invoked_subcommand != "configure":
             console.print(f"Welcome to {AICODEBOT}. Let's set up your config file.\n", style=console.bot_style)
-            configure.callback(openai_api_key=os.getenv("OPENAI_API_KEY"), verbose=0)
+            configure.callback(
+                openai_api_key=os.getenv("OPENAI_API_KEY"), anthropic_api_key=os.getenv("ANTHROPIC_API_KEY"), verbose=0
+            )
             sys.exit(0)
-    else:
-        os.environ["OPENAI_API_KEY"] = existing_config["openai_api_key"]
 
     # Turn on langchain debug output if requested
     langchain_core.debug = debug_output

aicodebot/commands/commit.py

@@ -28,7 +28,7 @@ class CommitMessage(BaseModel):
 
 
 @click.command()
-@click.option("-t", "--response-token-size", type=int, default=250)
+@click.option("-t", "--response-token-size", type=int, default=1000)
 @click.option("-y", "--yes", is_flag=True, default=False, help="Don't ask for confirmation before committing.")
 @click.option("--skip-pre-commit", is_flag=True, help="Skip running pre-commit.")
 @click.argument("files", nargs=-1, type=click.Path(exists=True))

aicodebot/commands/configure.py

@@ -1,89 +1,224 @@
+import asyncio
+import sys
+import webbrowser
+
+import click
+import yaml
+
 from aicodebot import AICODEBOT
-from aicodebot.config import get_config_file, read_config
+from aicodebot.config import detect_api_keys, fetch_models_for_provider, get_config_file, read_config
 from aicodebot.helpers import create_and_write_file
 from aicodebot.output import get_console
 from aicodebot.prompts import DEFAULT_PERSONALITY, PERSONALITIES
-import click, os, sys, webbrowser, yaml
 
 
 @click.command()
 @click.option("-v", "--verbose", count=True)
 @click.option("--openai-api-key", envvar="OPENAI_API_KEY", help="Your OpenAI API key")
-def configure(verbose, openai_api_key):
-    """Create or update the configuration file"""
+@click.option("--anthropic-api-key", envvar="ANTHROPIC_API_KEY", help="Your Anthropic API key")
+def configure(verbose, openai_api_key, anthropic_api_key):  # noqa: ARG001 - verbose for future use
+    """Create or update the configuration file with dynamic provider and model selection"""
     console = get_console()
 
-    # --------------- Check for an existing key or set up defaults --------------- #
-
-    config_data_defaults = {
-        "version": 1.2,
-        "openai_api_key": openai_api_key,
-        "personality": DEFAULT_PERSONALITY.name,
-    }
-
-    config_data = config_data_defaults.copy()
-    config_file = get_config_file()
-
-    existing_config = read_config()
-    if existing_config:
-        console.print(f"Config file already exists at {get_config_file()}.")
-        click.confirm("Do you want to rerun configure and overwrite it?", default=False, abort=True)
-        config_data.update(
-            {
-                "openai_api_key": existing_config["openai_api_key"],
-                "personality": existing_config["personality"],
-            }
-        )
-
-    config_data = config_data_defaults.copy()
-
     def write_config_file(config_data):
-        create_and_write_file(config_file, yaml.dump(config_data))
-        console.print(f"✅ Created config file at {config_file}")
+        create_and_write_file(get_config_file(), yaml.dump(config_data), overwrite=True)
+        console.print(f"✅ Updated config file at {get_config_file()}")
 
+    # Check if we're in a terminal for interactive mode
     is_terminal = sys.stdout.isatty()
-    openai_api_key = openai_api_key or config_data["openai_api_key"] or os.getenv("OPENAI_API_KEY")
     if not is_terminal:
-        if openai_api_key is None:
-            raise click.ClickException(
-                "🛑 No OpenAI API key found.\n"
-                "Please set the OPENAI_API_KEY environment variable or call configure with --openai-api-key set."
-            )
-        else:
-            # If we are not in a terminal, then we can't ask for input, so just use the defaults and write the file
-            write_config_file(config_data)
+        # Non-interactive mode - create config with detected API keys and defaults
+        detected_keys = detect_api_keys()
+
+        # Also check command-line arguments for API keys
+        api_key = None
+        selected_provider = None
+
+        if openai_api_key:
+            api_key = openai_api_key
+            selected_provider = "openai"
+        elif anthropic_api_key:
+            api_key = anthropic_api_key
+            selected_provider = "anthropic"
+        elif "openai" in detected_keys:
+            api_key = detected_keys["openai"]["key"]
+            selected_provider = "openai"
+        elif "anthropic" in detected_keys:
+            api_key = detected_keys["anthropic"]["key"]
+            selected_provider = "anthropic"
+
+        if not api_key:
+            console.print("Non-interactive mode detected. Use --openai-api-key or --anthropic-api-key to set keys.")
             return
 
-    # ---------------- Collect the OPENAI_API_KEY and validate it ---------------- #
-
-    if config_data["openai_api_key"] is None:
-        console.print(
-            f"You need an OpenAI API Key for {AICODEBOT}. You can get one on the OpenAI website.",
-            style=console.bot_style,
-        )
-        openai_api_key_url = "https://platform.openai.com/account/api-keys"
-        if click.confirm("Open the api keys page in a browser?", default=False):
-            webbrowser.open(openai_api_key_url)
+        # Select default model for provider
+        if selected_provider == "openai":
+            selected_model = {"id": "gpt-5", "name": "gpt-5"}
+        else:
+            selected_model = {"id": "claude-opus-4-1", "name": "claude-opus-4-1"}
+
+        # Create config with defaults
+        config_data = {
+            "version": 1.3,
+            "provider": selected_provider,
+            "model": selected_model["id"],
+            "personality": DEFAULT_PERSONALITY.name,
+        }
+
+        # Always store API key in non-interactive mode (needed for tests)
+        if selected_provider == "openai":
+            config_data["openai_api_key"] = api_key
+        else:
+            config_data["anthropic_api_key"] = api_key
+
+        write_config_file(config_data)
+        console.print(f"✅ Created config file in non-interactive mode with {selected_provider}")
+        return
+
+    # Check for existing configuration
+    existing_config = read_config() or {}
+    if existing_config and not click.confirm("Config file already exists. Do you want to reconfigure?", default=True):
+        return
+
+    console.print(f"\n🔧 Welcome to {AICODEBOT} Configuration!\n", style=console.bot_style)
+
+    # Step 1: Detect existing API keys
+    detected_keys = detect_api_keys()
+
+    console.print("🔍 Scanning for existing API keys...", style=console.bot_style)
+    if detected_keys:
+        console.print("✅ Found the following API keys:", style="green")
+        for provider, key_info in detected_keys.items():
+            console.print(f"  • {provider.title()}: {'*' * 8 + key_info['key'][-8:]} (from {key_info['source']})")
+    else:
+        console.print("ℹ️ No API keys found in environment variables", style="yellow")
+
+    # Step 2: Provider selection
+    console.print("\n🤖 Choose your AI provider:", style=console.bot_style)
+
+    available_providers = []
+    if detected_keys.get("openai") or openai_api_key:
+        available_providers.append(("OpenAI", "openai"))
+    if detected_keys.get("anthropic") or anthropic_api_key:
+        available_providers.append(("Anthropic", "anthropic"))
+
+    # Always allow manual entry
+    if not available_providers:
+        console.print("No API keys detected. You'll need to enter one manually.")
+
+    all_providers = [("OpenAI", "openai"), ("Anthropic", "anthropic")]
+    for i, (display_name, provider_id) in enumerate(all_providers, 1):
+        status = "✅ Available" if any(p[1] == provider_id for p in available_providers) else "❌ Needs API key"
+        console.print(f"{i}. {display_name} - {status}")
+
+    provider_choice = click.prompt("Select provider (1-2)", type=click.IntRange(1, 2), default=1)
+
+    selected_provider_display, selected_provider = all_providers[provider_choice - 1]
+    console.print(f"Selected: {selected_provider_display}")
+
+    # Step 3: Handle API key
+    api_key = None
+    if selected_provider == "openai":
+        api_key = detected_keys.get("openai", {}).get("key") or openai_api_key
+        env_var = "OPENAI_API_KEY"
+        api_url = "https://platform.openai.com/account/api-keys"
+    else:  # anthropic
+        api_key = detected_keys.get("anthropic", {}).get("key") or anthropic_api_key
+        env_var = "ANTHROPIC_API_KEY"
+        api_url = "https://console.anthropic.com/account/keys"
+
+    if not api_key:
+        console.print(f"\n🔑 You need a {selected_provider_display} API key.", style=console.bot_style)
+        if click.confirm(f"Open {selected_provider_display} API keys page in browser?", default=True):
+            webbrowser.open(api_url)
+
+        api_key = click.prompt(f"Enter your {selected_provider_display} API key").strip()
+        console.print("💡 Consider setting this as an environment variable:", style="dim")
+        console.print(f"   export {env_var}={api_key}", style="dim")
+
+    # Step 4: Fetch and select model
+    console.print(f"\n🧠 Fetching available models from {selected_provider_display}...", style=console.bot_style)
+
+    models = asyncio.run(fetch_models_for_provider(selected_provider, api_key))
+
+    if not models:
+        raise ValueError(f"No models returned from {selected_provider_display}")
+
+    console.print(f"✅ Found {len(models)} available models:")
+
+    for i, model in enumerate(models[:10], 1):  # Show first 10 models
+        console.print(f"{i:2}. {model['name']} - {model['description']}")
+
+    if len(models) > 10:
+        console.print(f"... and {len(models) - 10} more models")
+
+    # Add option for custom model
+    console.print(f"{len(models) + 1:2}. [Custom] Enter your own model name")
+
+    max_choice = min(len(models), 10) + 1
+    model_choice = click.prompt(f"Select model (1-{max_choice})", type=click.IntRange(1, max_choice), default=1)
+
+    if model_choice <= len(models):
+        # User selected from the list
+        selected_model = models[model_choice - 1]
+        console.print(f"Selected: {selected_model['name']}")
+    else:
+        # User wants to enter custom model
+        console.print("\n💡 You can enter any model ID (e.g., claude-opus-4-1, gpt-4o, claude-3-5-sonnet-20241022)")
+        console.print("This allows you to use newer models that aren't in our list yet.")
+
+        custom_model_id = click.prompt("Enter model ID").strip()
+        selected_model = {
+            "id": custom_model_id,
+            "name": custom_model_id,
+            "description": f"Custom model: {custom_model_id}",
+        }
+        console.print(f"Selected: {selected_model['name']} (custom)")
+
+    # Step 5: Personality selection
+    console.print("\n🎭 Choose your AI personality:", style=console.bot_style)
+
+    personality_list = list(PERSONALITIES.items())
+    for i, (key, personality) in enumerate(personality_list, 1):
+        console.print(f"{i}. {key} - {personality.description}")
+
+    personality_choice = click.prompt(
+        f"Select personality (1-{len(personality_list)})", type=click.IntRange(1, len(personality_list)), default=1
+    )
 
-        config_data["openai_api_key"] = click.prompt("Please enter your OpenAI API key").strip()
+    selected_personality = personality_list[personality_choice - 1][0]
 
-    # ---------------------- Collect the personality choice ---------------------- #
+    # Step 6: Build and save configuration
+    config_data = {
+        "version": 1.3,  # Updated version for new format
+        "provider": selected_provider,
+        "model": selected_model["id"],
+        "personality": selected_personality,
+    }
 
-    # Pull the choices from the name from each of the PERSONALITIES
-    console.print(
-        "\nHow would you like your AI to act? You can choose from the following personalities:\n",
-        style=console.bot_style,
-    )
-    personality_choices = ""
-    for key, personality in PERSONALITIES.items():
-        personality_choices += f"\t[b]{key}[/b] - {personality.description}\n"
-    console.print(personality_choices)
-
-    config_data["personality"] = click.prompt(
-        "Please choose a personality",
-        type=click.Choice(PERSONALITIES.keys(), case_sensitive=False),
-        default=DEFAULT_PERSONALITY.name,
-    )
+    # Always store API key in config file
+    if selected_provider == "openai":
+        config_data["openai_api_key"] = api_key
+    else:
+        config_data["anthropic_api_key"] = api_key
 
     write_config_file(config_data)
-    console.print(f"✅ Configuration complete, you're ready to run {AICODEBOT}!\n")
+
+    # Summary
+    console.print("\n🎉 Configuration complete!", style="green bold")
+    console.print(f"Provider: {selected_provider_display}")
+    console.print(f"Model: {selected_model['name']}")
+    console.print(f"Personality: {selected_personality}")
+    console.print(f"\nYou're ready to use {AICODEBOT}! 🚀")
+
+
+# Helper function for async execution in click context
+def run_async(coro):
+    """Run an async coroutine in a click command context."""
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    return loop.run_until_complete(coro)

aicodebot/config.py

@@ -1,7 +1,6 @@
 import os
 from pathlib import Path
 
-import httpx
 import yaml
 
 from aicodebot.helpers import create_and_write_file, logger
@@ -41,6 +40,73 @@ def read_config():
         return None
 
 
+def detect_api_keys():
+    """Detect existing API keys from environment variables."""
+    detected_keys = {}
+
+    # Check for OpenAI API key
+    openai_key = os.getenv("OPENAI_API_KEY")
+    if openai_key and openai_key.startswith("sk-"):
+        detected_keys["openai"] = {"key": openai_key, "source": "environment"}
+
+    # Check for Anthropic API key
+    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
+    if anthropic_key and anthropic_key.startswith("sk-ant-"):
+        detected_keys["anthropic"] = {"key": anthropic_key, "source": "environment"}
+
+    return detected_keys
+
+
+async def fetch_openai_models(api_key):  # noqa: ARG001 - api_key needed for interface consistency
+    """Return latest OpenAI models."""
+    # Return the latest/upcoming OpenAI models (hardcoded list for cutting-edge access)
+    return [
+        {"id": "gpt-5", "name": "gpt-5", "description": "GPT-5 (Next-generation flagship model)"},
+        {"id": "gpt-5-mini", "name": "gpt-5-mini", "description": "GPT-5 Mini (Fast and efficient next-gen)"},
+        {"id": "gpt-oss-120b", "name": "gpt-oss-120b", "description": "GPT-OSS 120B (Open source model)"},
+        {"id": "o3-pro", "name": "o3-pro", "description": "O3 Pro (Advanced reasoning model)"},
+    ]
+
+
+async def fetch_anthropic_models(api_key):  # noqa: ARG001 - api_key needed for interface consistency
+    """Fetch available models from Anthropic API."""
+    # Note: Anthropic doesn't have a public models API endpoint like OpenAI
+    # Return the latest available models from official docs (January 2025)
+    # Source: https://docs.anthropic.com/en/docs/about-claude/models/overview
+    return [
+        {
+            "id": "claude-opus-4-1",
+            "name": "claude-opus-4-1",
+            "description": "Claude Opus 4.1 (Most capable and intelligent - Latest flagship)",
+        },
+        {
+            "id": "claude-sonnet-4-0",
+            "name": "claude-sonnet-4-0",
+            "description": "Claude Sonnet 4 (High-performance with exceptional reasoning)",
+        },
+        {
+            "id": "claude-3-7-sonnet-latest",
+            "name": "claude-3-7-sonnet-latest",
+            "description": "Claude Sonnet 3.7 (High-performance with extended thinking)",
+        },
+        {
+            "id": "claude-3-5-haiku-latest",
+            "name": "claude-3-5-haiku-latest",
+            "description": "Claude Haiku 3.5 (Fastest model with intelligence)",
+        },
+    ]
+
+
+async def fetch_models_for_provider(provider, api_key):
+    """Fetch models for a specific provider."""
+    if provider.lower() == "openai":
+        return await fetch_openai_models(api_key)
+    elif provider.lower() == "anthropic":
+        return await fetch_anthropic_models(api_key)
+    else:
+        raise ValueError(f"Unknown provider: {provider}")
+
+
 class Session:
     """Read and write local session data"""