ai-code-switcher 0.1.4__tar.gz → 0.1.6__tar.gz

{ai_code_switcher-0.1.4 → ai_code_switcher-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-code-switcher
-Version: 0.1.4
+Version: 0.1.6
 Summary: Switch AI coding tool profiles and launch the correct CLI
 License-Expression: MIT
 Requires-Python: >=3.8

{ai_code_switcher-0.1.4 → ai_code_switcher-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ai-code-switcher"
-version = "0.1.4"
+version = "0.1.6"
 description = "Switch AI coding tool profiles and launch the correct CLI"
 license = "MIT"
 requires-python = ">=3.8"

{ai_code_switcher-0.1.4 → ai_code_switcher-0.1.6}/src/ai_code_switcher.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-code-switcher
-Version: 0.1.4
+Version: 0.1.6
 Summary: Switch AI coding tool profiles and launch the correct CLI
 License-Expression: MIT
 Requires-Python: >=3.8

{ai_code_switcher-0.1.4 → ai_code_switcher-0.1.6}/src/ai_code_switcher.egg-info/SOURCES.txt

@@ -10,4 +10,8 @@ src/code_ai/__init__.py
 src/code_ai/cli.py
 src/code_ai/config.py
 src/code_ai/launcher.py
-src/code_ai/profiles.py
+src/code_ai/models.py
+src/code_ai/profiles.py
+tests/test_integration.py
+tests/test_launcher.py
+tests/test_models.py

ai_code_switcher-0.1.6/src/code_ai/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.6"

{ai_code_switcher-0.1.4 → ai_code_switcher-0.1.6}/src/code_ai/cli.py

@@ -110,9 +110,16 @@ UPGRADE_PACKAGES = [
 
 def upgrade():
     typer.echo("Upgrading claude, codex, gemini CLI...")
-    result = subprocess.run(
-        ["npm", "install", "-g"] + UPGRADE_PACKAGES,
-    )
+
+    # On Windows, npm is a .cmd file, need to use shell=True or npm.cmd
+    if sys.platform == "win32":
+        # Use shell=True on Windows for better compatibility
+        cmd = "npm install -g " + " ".join(UPGRADE_PACKAGES)
+        result = subprocess.run(cmd, shell=True)
+    else:
+        result = subprocess.run(
+            ["npm", "install", "-g"] + UPGRADE_PACKAGES,
+        )
     sys.exit(result.returncode)
 
 

{ai_code_switcher-0.1.4 → ai_code_switcher-0.1.6}/src/code_ai/config.py

@@ -4,6 +4,8 @@ from pathlib import Path
 
 import yaml
 
+from .models import profile_from_dict, profile_to_dict, BaseProfile
+
 CONFIG_DIR = Path.home() / ".code-ai"
 CONFIG_FILE = CONFIG_DIR / "config.yaml"
 
@@ -26,3 +28,11 @@ def save_config(data):
 
 def init_config():
     save_config({"profiles": {}})
+
+
+def get_profile_object(config, name: str) -> BaseProfile:
+    """Get a profile object from config by name."""
+    if name not in config.get("profiles", {}):
+        raise ValueError(f"Profile '{name}' not found in config")
+    profile_dict = config["profiles"][name]
+    return profile_from_dict(profile_dict)

ai_code_switcher-0.1.6/src/code_ai/launcher.py

@@ -0,0 +1,95 @@
+import os
+import sys
+import shutil
+import subprocess
+from .models import profile_from_dict, ApiProfile, LoginProfile
+
+ENV_MAP = {
+    "claude": {
+        "env": {"ANTHROPIC_BASE_URL": "base_url", "ANTHROPIC_AUTH_TOKEN": "token"},
+        "cmd": "claude",
+    },
+    "gemini": {
+        "env": {"GOOGLE_GEMINI_BASE_URL": "base_url", "GEMINI_API_KEY": "api_key"},
+        "cmd": "gemini",
+    },
+    "codex": {
+        "env": {"OPENAI_API_KEY": "api_key"},
+        "cmd": "codex",
+    },
+}
+
+
+def prepare_environment(profile):
+    """Prepare environment variables based on profile type and mode"""
+    env = os.environ.copy()
+    ptype = profile.type
+
+    if ptype not in ENV_MAP:
+        raise ValueError(f"Unknown profile type '{ptype}'")
+
+    spec = ENV_MAP[ptype]
+
+    # Handle authentication based on profile type
+    if isinstance(profile, LoginProfile):
+        # Login mode: clear API environment variables and set CONFIG_DIR
+        for env_var in spec["env"]:
+            env.pop(env_var, None)
+        # Expand ~ to home directory
+        credentials_path = os.path.expanduser(profile.credentials_path)
+        # Set the appropriate CONFIG_DIR based on profile type
+        config_dir_var = f"{ptype.upper()}_CONFIG_DIR"
+        env[config_dir_var] = credentials_path
+    elif isinstance(profile, ApiProfile):
+        # API mode: set API environment variables
+        for env_var, config_key in spec["env"].items():
+            value = getattr(profile, config_key, None)
+            if value:
+                env[env_var] = value
+
+    # Handle proxy (all modes)
+    if profile.proxy:
+        env["HTTP_PROXY"] = profile.proxy
+        env["HTTPS_PROXY"] = profile.proxy
+
+    return env
+
+
+def launch(profile_dict, extra_args):
+    # Convert dict to dataclass
+    profile = profile_from_dict(profile_dict)
+    ptype = profile.type
+
+    if ptype not in ENV_MAP:
+        print(f"Error: unknown profile type '{ptype}'.")
+        sys.exit(1)
+
+    spec = ENV_MAP[ptype]
+    cmd = spec["cmd"]
+
+    # On Windows, npm global commands are .cmd files
+    if sys.platform == "win32":
+        cmd_path = shutil.which(f"{cmd}.cmd") or shutil.which(cmd)
+    else:
+        cmd_path = shutil.which(cmd)
+
+    if not cmd_path:
+        print(f"Error: '{cmd}' not found in PATH. Install it first.")
+        sys.exit(1)
+
+    # Prepare environment
+    env = prepare_environment(profile)
+
+    full_cmd = [cmd_path] + extra_args
+
+    if sys.platform == "win32":
+        # On Windows, use subprocess with full environment
+        try:
+            result = subprocess.run(full_cmd, env=env, shell=False)
+            sys.exit(result.returncode)
+        except KeyboardInterrupt:
+            sys.exit(130)
+    else:
+        # On Unix, update os.environ and use execvp
+        os.environ.update(env)
+        os.execvp(cmd, [cmd] + extra_args)

ai_code_switcher-0.1.6/src/code_ai/models.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass, asdict, field
+from typing import Optional
+
+VALID_TYPES = ("claude", "gemini", "codex")
+
+
+@dataclass
+class BaseProfile:
+    """Common fields for all profiles"""
+    name: str
+    type: str                    # "claude" | "gemini" | "codex"
+    proxy: Optional[str] = None  # e.g., "http://127.0.0.1:7890"
+
+
+@dataclass
+class ApiProfile(BaseProfile):
+    """API mode: authenticate via base_url + token/api_key"""
+    base_url: str = ""
+    token: Optional[str] = None      # Claude only
+    api_key: Optional[str] = None    # Gemini/Codex only
+
+
+@dataclass
+class LoginProfile(BaseProfile):
+    """Login mode: authenticate via OAuth credentials directory (Claude only)"""
+    credentials_path: str = ""       # Path to existing OAuth credentials
+
+
+def profile_from_dict(data: dict) -> BaseProfile:
+    """Convert dict to appropriate profile dataclass"""
+    name = data.get("name", "")
+    ptype = data.get("type", "")
+    mode = data.get("mode", "api")  # Default to api for backward compatibility
+    proxy = data.get("proxy")
+
+    if (ptype == "claude" or ptype == "codex") and mode == "login":
+        return LoginProfile(
+            name=name,
+            type=ptype,
+            credentials_path=data.get("credentials_path", ""),
+            proxy=proxy
+        )
+    else:
+        # API mode (default for all types)
+        return ApiProfile(
+            name=name,
+            type=ptype,
+            base_url=data.get("base_url", ""),
+            token=data.get("token"),
+            api_key=data.get("api_key"),
+            proxy=proxy
+        )
+
+
+def profile_to_dict(profile: BaseProfile) -> dict:
+    """Convert profile dataclass to dict"""
+    data = asdict(profile)
+
+    # Add mode field
+    if isinstance(profile, LoginProfile):
+        data["mode"] = "login"
+    else:
+        data["mode"] = "api"
+
+    # Remove None values for cleaner YAML
+    return {k: v for k, v in data.items() if v is not None}

ai_code_switcher-0.1.6/src/code_ai/profiles.py

@@ -0,0 +1,160 @@
+import sys
+
+from .models import VALID_TYPES, profile_from_dict
+
+
+def list_profiles(config):
+    from .config import save_config
+
+    profiles = config.get("profiles", {})
+
+    # Auto-migrate old profiles without mode field
+    migrated = False
+    for name, p in profiles.items():
+        if "mode" not in p:
+            p["mode"] = "api"
+            migrated = True
+
+    if migrated:
+        save_config(config)
+
+    if not profiles:
+        print("No profiles configured.")
+        return
+
+    print(f"{'Name':<20} {'Type':<10} {'Mode':<8} {'Base URL/Credentials':<42} {'Proxy':<20}")
+    print("-" * 100)
+
+    for name, p in profiles.items():
+        profile = profile_from_dict(p)
+        ptype = profile.type
+        mode = p.get("mode", "api")
+
+        # Determine what to display in the Base URL/Credentials column
+        if mode == "login":
+            url_or_creds = p.get("credentials_path", "")
+        else:  # api mode
+            url_or_creds = p.get("base_url", "")
+
+        # Truncate long strings
+        if len(url_or_creds) > 40:
+            url_or_creds = url_or_creds[:37] + "..."
+
+        # Get proxy or display "-"
+        proxy_display = profile.proxy if profile.proxy else "-"
+        if len(proxy_display) > 20:
+            proxy_display = proxy_display[:17] + "..."
+
+        print(f"{name:<20} {ptype:<10} {mode:<8} {url_or_creds:<42} {proxy_display:<20}")
+
+
+def add_profile(config):
+    name = input("Profile name: ").strip()
+    if not name:
+        print("Error: name cannot be empty.")
+        sys.exit(1)
+    if name in config.get("profiles", {}):
+        print(f"Error: profile '{name}' already exists.")
+        sys.exit(1)
+
+    ptype = input(f"Type ({'/'.join(VALID_TYPES)}): ").strip().lower()
+    if ptype not in VALID_TYPES:
+        print(f"Error: type must be one of {VALID_TYPES}.")
+        sys.exit(1)
+
+    profile_data = {
+        "type": ptype,
+    }
+
+    # Handle mode for Claude and Codex
+    if ptype in ("claude", "codex"):
+        mode = input("Mode (api/login) [api]: ").strip().lower() or "api"
+        if mode not in ("api", "login"):
+            print("Error: mode must be 'api' or 'login'.")
+            sys.exit(1)
+        profile_data["mode"] = mode
+
+        if mode == "login":
+            credentials_path = input("Credentials path (optional, auto-generate if empty): ").strip()
+            if not credentials_path:
+                credentials_path = f"~/.{ptype}-profiles/{name}"
+            profile_data["credentials_path"] = credentials_path
+        else:  # api mode
+            base_url = input("Base URL: ").strip()
+            if not base_url:
+                print("Error: base URL cannot be empty.")
+                sys.exit(1)
+            if ptype == "claude":
+                token = input("Auth token: ").strip()
+                profile_data["base_url"] = base_url
+                profile_data["token"] = token
+            else:  # codex
+                api_key = input("API key: ").strip()
+                profile_data["base_url"] = base_url
+                profile_data["api_key"] = api_key
+    else:  # gemini - API mode only
+        base_url = input("Base URL: ").strip()
+        if not base_url:
+            print("Error: base URL cannot be empty.")
+            sys.exit(1)
+        api_key = input("API key: ").strip()
+        profile_data["base_url"] = base_url
+        profile_data["api_key"] = api_key
+
+    # Optional proxy for all types
+    proxy = input("Proxy (optional, e.g., http://127.0.0.1:7890): ").strip()
+    if proxy:
+        profile_data["proxy"] = proxy
+
+    config.setdefault("profiles", {})[name] = profile_data
+    return config
+
+
+def show_profile(config, name):
+    profiles = config.get("profiles", {})
+    if name not in profiles:
+        print(f"Error: profile '{name}' not found.")
+        sys.exit(1)
+
+    profile_dict = profiles[name]
+    profile = profile_from_dict(profile_dict)
+
+    print(f"Profile: {name}")
+    print(f"Type: {profile.type}")
+
+    # Display mode for Claude and Codex types
+    if profile.type in ("claude", "codex"):
+        mode = profile_dict.get("mode", "api")
+        print(f"Mode: {mode}")
+
+        if mode == "login":
+            credentials_path = profile_dict.get("credentials_path", "N/A")
+            print(f"Credentials Path: {credentials_path}")
+        else:  # api mode
+            base_url = profile_dict.get("base_url", "N/A")
+            if profile.type == "claude":
+                token = profile_dict.get("token", "N/A")
+                print(f"Base URL: {base_url}")
+                print(f"Token: {token}")
+            else:  # codex
+                api_key = profile_dict.get("api_key", "N/A")
+                print(f"Base URL: {base_url}")
+                print(f"API Key: {api_key}")
+    else:  # gemini
+        base_url = profile_dict.get("base_url", "N/A")
+        api_key = profile_dict.get("api_key", "N/A")
+        print(f"Base URL: {base_url}")
+        print(f"API Key: {api_key}")
+
+    # Display proxy if set
+    if profile.proxy:
+        print(f"Proxy: {profile.proxy}")
+
+
+def remove_profile(config, name):
+    if name not in config.get("profiles", {}):
+        print(f"Error: profile '{name}' not found.")
+        sys.exit(1)
+    del config["profiles"][name]
+    print(f"Removed profile '{name}'.")
+    return config

ai_code_switcher-0.1.6/tests/test_integration.py

@@ -0,0 +1,311 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from src.code_ai.config import load_config, save_config
+from src.code_ai.profiles import add_profile, list_profiles, show_profile, remove_profile
+from src.code_ai.models import profile_from_dict, ApiProfile, LoginProfile
+from src.code_ai.launcher import prepare_environment
+
+
+class TestFullWorkflowApiProfile:
+    """Test complete workflow for API profile (Claude)"""
+
+    def test_full_workflow_api_profile(self, monkeypatch, tmp_path):
+        """Test full workflow: add API profile -> show -> list -> remove"""
+        # Mock config file location
+        config_file = tmp_path / "config.yaml"
+
+        with patch("src.code_ai.config.CONFIG_FILE", config_file):
+            # Step 1: Initialize config
+            config = {"profiles": {}}
+            save_config(config)
+
+            # Step 2: Add API profile interactively
+            inputs = [
+                "my-claude-api",           # Profile name
+                "claude",                  # Type
+                "api",                     # Mode
+                "https://api.anthropic.com",  # Base URL
+                "sk-ant-test-token",       # Auth token
+                "",                        # No proxy
+            ]
+
+            with patch("builtins.input", side_effect=inputs):
+                config = load_config()
+                config = add_profile(config)
+                save_config(config)
+
+            # Step 3: Verify profile was added
+            config = load_config()
+            assert "my-claude-api" in config["profiles"]
+            profile_dict = config["profiles"]["my-claude-api"]
+            assert profile_dict["type"] == "claude"
+            assert profile_dict["mode"] == "api"
+            assert profile_dict["base_url"] == "https://api.anthropic.com"
+            assert profile_dict["token"] == "sk-ant-test-token"
+
+            # Step 4: Convert to profile object and verify
+            profile = profile_from_dict(profile_dict)
+            assert isinstance(profile, ApiProfile)
+            assert profile.type == "claude"
+
+            # Step 5: Test environment preparation
+            env = prepare_environment(profile)
+            assert env["ANTHROPIC_BASE_URL"] == "https://api.anthropic.com"
+            assert env["ANTHROPIC_AUTH_TOKEN"] == "sk-ant-test-token"
+
+            # Step 6: Show profile
+            with patch("builtins.print") as mock_print:
+                show_profile(config, "my-claude-api")
+                # Verify show_profile was called and printed something
+                assert mock_print.called
+
+            # Step 7: List profiles
+            with patch("builtins.print") as mock_print:
+                list_profiles(config)
+                # Verify list_profiles was called and printed something
+                assert mock_print.called
+
+            # Step 8: Remove profile
+            config = remove_profile(config, "my-claude-api")
+            assert "my-claude-api" not in config["profiles"]
+
+
+class TestFullWorkflowLoginProfile:
+    """Test complete workflow for login profile (Claude)"""
+
+    def test_full_workflow_login_profile(self, monkeypatch, tmp_path):
+        """Test full workflow: add login profile -> show -> list -> remove"""
+        # Mock config file location
+        config_file = tmp_path / "config.yaml"
+
+        with patch("src.code_ai.config.CONFIG_FILE", config_file):
+            # Step 1: Initialize config
+            config = {"profiles": {}}
+            save_config(config)
+
+            # Step 2: Add login profile interactively
+            inputs = [
+                "my-claude-login",         # Profile name
+                "claude",                  # Type
+                "login",                   # Mode
+                "~/.claude-profiles/account-a",  # Credentials path
+                "http://127.0.0.1:7890",   # Proxy
+            ]
+
+            with patch("builtins.input", side_effect=inputs):
+                config = load_config()
+                config = add_profile(config)
+                save_config(config)
+
+            # Step 3: Verify profile was added
+            config = load_config()
+            assert "my-claude-login" in config["profiles"]
+            profile_dict = config["profiles"]["my-claude-login"]
+            assert profile_dict["type"] == "claude"
+            assert profile_dict["mode"] == "login"
+            assert profile_dict["credentials_path"] == "~/.claude-profiles/account-a"
+            assert profile_dict["proxy"] == "http://127.0.0.1:7890"
+
+            # Step 4: Convert to profile object and verify
+            profile = profile_from_dict(profile_dict)
+            assert isinstance(profile, LoginProfile)
+            assert profile.type == "claude"
+
+            # Step 5: Test environment preparation
+            env = prepare_environment(profile)
+            # Login mode should NOT have API environment variables
+            assert "ANTHROPIC_BASE_URL" not in env
+            assert "ANTHROPIC_AUTH_TOKEN" not in env
+            # Should have CLAUDE_CONFIG_DIR with expanded path
+            import os
+            expected_path = os.path.expanduser("~/.claude-profiles/account-a")
+            assert env["CLAUDE_CONFIG_DIR"] == expected_path
+            # Should have proxy
+            assert env["HTTP_PROXY"] == "http://127.0.0.1:7890"
+            assert env["HTTPS_PROXY"] == "http://127.0.0.1:7890"
+
+            # Step 6: Show profile
+            with patch("builtins.print") as mock_print:
+                show_profile(config, "my-claude-login")
+                # Verify show_profile was called and printed something
+                assert mock_print.called
+
+            # Step 7: List profiles
+            with patch("builtins.print") as mock_print:
+                list_profiles(config)
+                # Verify list_profiles was called and printed something
+                assert mock_print.called
+
+            # Step 8: Remove profile
+            config = remove_profile(config, "my-claude-login")
+            assert "my-claude-login" not in config["profiles"]
+
+
+class TestBackwardCompatibility:
+    """Test backward compatibility with legacy profiles"""
+
+    def test_backward_compatibility(self, tmp_path):
+        """Test that legacy profiles (without mode field) still work"""
+        # Mock config file location
+        config_file = tmp_path / "config.yaml"
+
+        with patch("src.code_ai.config.CONFIG_FILE", config_file):
+            # Step 1: Create a legacy profile (without mode field)
+            legacy_config = {
+                "profiles": {
+                    "legacy-claude": {
+                        "name": "legacy-claude",
+                        "type": "claude",
+                        "base_url": "https://api.anthropic.com",
+                        "token": "sk-ant-legacy-token"
+                        # Note: no "mode" field
+                    }
+                }
+            }
+            save_config(legacy_config)
+
+            # Step 2: Load config and verify it works
+            config = load_config()
+            assert "legacy-claude" in config["profiles"]
+            profile_dict = config["profiles"]["legacy-claude"]
+
+            # Step 3: Convert to profile object
+            # Should default to API mode
+            profile = profile_from_dict(profile_dict)
+            assert isinstance(profile, ApiProfile)
+            assert profile.base_url == "https://api.anthropic.com"
+            assert profile.token == "sk-ant-legacy-token"
+
+            # Step 4: Test environment preparation
+            env = prepare_environment(profile)
+            assert env["ANTHROPIC_BASE_URL"] == "https://api.anthropic.com"
+            assert env["ANTHROPIC_AUTH_TOKEN"] == "sk-ant-legacy-token"
+
+            # Step 5: Show profile should work
+            with patch("builtins.print") as mock_print:
+                show_profile(config, "legacy-claude")
+                assert mock_print.called
+
+            # Step 6: List profiles should work
+            with patch("builtins.print") as mock_print:
+                list_profiles(config)
+                assert mock_print.called
+
+            # Step 7: Test with other profile types (gemini, codex)
+            gemini_config = {
+                "profiles": {
+                    "legacy-gemini": {
+                        "name": "legacy-gemini",
+                        "type": "gemini",
+                        "base_url": "https://generativelanguage.googleapis.com",
+                        "api_key": "AIza-test-key"
+                        # Note: no "mode" field
+                    }
+                }
+            }
+            save_config(gemini_config)
+
+            config = load_config()
+            profile_dict = config["profiles"]["legacy-gemini"]
+            profile = profile_from_dict(profile_dict)
+
+            # Should default to API mode
+            assert isinstance(profile, ApiProfile)
+            assert profile.type == "gemini"
+            assert profile.api_key == "AIza-test-key"
+
+            # Test environment preparation
+            env = prepare_environment(profile)
+            assert env["GOOGLE_GEMINI_BASE_URL"] == "https://generativelanguage.googleapis.com"
+            assert env["GEMINI_API_KEY"] == "AIza-test-key"
+
+
+class TestCodexProfiles:
+    """Test codex profile workflows"""
+
+    def test_codex_api_profile(self, tmp_path):
+        """Test codex API mode profile"""
+        config_file = tmp_path / "config.yaml"
+
+        with patch("src.code_ai.config.CONFIG_FILE", config_file):
+            # Initialize config
+            config = {"profiles": {}}
+            save_config(config)
+
+            # Add codex API profile
+            inputs = [
+                "my-codex-api",            # Profile name
+                "codex",                   # Type
+                "api",                     # Mode
+                "https://api.openai.com/v1",  # Base URL
+                "sk-test-key",             # API key
+                "",                        # No proxy
+            ]
+
+            with patch("builtins.input", side_effect=inputs):
+                config = load_config()
+                config = add_profile(config)
+                save_config(config)
+
+            # Verify profile was added
+            config = load_config()
+            assert "my-codex-api" in config["profiles"]
+            profile_dict = config["profiles"]["my-codex-api"]
+            assert profile_dict["type"] == "codex"
+            assert profile_dict["mode"] == "api"
+
+            # Convert to profile object
+            profile = profile_from_dict(profile_dict)
+            assert isinstance(profile, ApiProfile)
+            assert profile.type == "codex"
+
+            # Test environment preparation
+            env = prepare_environment(profile)
+            # Should only have OPENAI_API_KEY, not OPENAI_BASE_URL
+            assert env["OPENAI_API_KEY"] == "sk-test-key"
+            assert "OPENAI_BASE_URL" not in env
+
+    def test_codex_login_profile(self, tmp_path):
+        """Test codex login mode profile"""
+        config_file = tmp_path / "config.yaml"
+
+        with patch("src.code_ai.config.CONFIG_FILE", config_file):
+            # Initialize config
+            config = {"profiles": {}}
+            save_config(config)
+
+            # Add codex login profile
+            inputs = [
+                "my-codex-login",          # Profile name
+                "codex",                   # Type
+                "login",                   # Mode
+                "~/.codex-profiles/account-a",  # Credentials path
+                "",                        # No proxy
+            ]
+
+            with patch("builtins.input", side_effect=inputs):
+                config = load_config()
+                config = add_profile(config)
+                save_config(config)
+
+            # Verify profile was added
+            config = load_config()
+            assert "my-codex-login" in config["profiles"]
+            profile_dict = config["profiles"]["my-codex-login"]
+            assert profile_dict["type"] == "codex"
+            assert profile_dict["mode"] == "login"
+            assert profile_dict["credentials_path"] == "~/.codex-profiles/account-a"
+
+            # Convert to profile object
+            profile = profile_from_dict(profile_dict)
+            assert isinstance(profile, LoginProfile)
+            assert profile.type == "codex"
+
+            # Test environment preparation
+            env = prepare_environment(profile)
+            # Login mode should NOT have API environment variables
+            assert "OPENAI_API_KEY" not in env
+            # Should have CODEX_CONFIG_DIR with expanded path
+            import os
+            expected_path = os.path.expanduser("~/.codex-profiles/account-a")
+            assert env["CODEX_CONFIG_DIR"] == expected_path

ai_code_switcher-0.1.6/tests/test_launcher.py

@@ -0,0 +1,107 @@
+import os
+import pytest
+from unittest.mock import patch, MagicMock
+from src.code_ai.models import ApiProfile, LoginProfile
+from src.code_ai.launcher import prepare_environment
+
+
+def test_prepare_env_api_mode():
+    """Test environment preparation for API mode"""
+    profile = ApiProfile(
+        name="test-api",
+        type="claude",
+        base_url="https://api.anthropic.com",
+        token="sk-ant-test"
+    )
+
+    env = prepare_environment(profile)
+
+    assert env["ANTHROPIC_BASE_URL"] == "https://api.anthropic.com"
+    assert env["ANTHROPIC_AUTH_TOKEN"] == "sk-ant-test"
+
+
+def test_prepare_env_login_mode():
+    """Test environment preparation for login mode"""
+    profile = LoginProfile(
+        name="test-login",
+        type="claude",
+        credentials_path="~/.claude-profiles/account-a"
+    )
+
+    env = prepare_environment(profile)
+
+    # Should NOT have API environment variables
+    assert "ANTHROPIC_BASE_URL" not in env
+    assert "ANTHROPIC_AUTH_TOKEN" not in env
+    # Should have CLAUDE_CONFIG_DIR with expanded path
+    expected_path = os.path.expanduser("~/.claude-profiles/account-a")
+    assert env["CLAUDE_CONFIG_DIR"] == expected_path
+
+
+def test_prepare_env_with_proxy():
+    """Test environment preparation with proxy"""
+    profile = ApiProfile(
+        name="test-proxy",
+        type="gemini",
+        base_url="https://generativelanguage.googleapis.com",
+        api_key="AIza-test",
+        proxy="http://127.0.0.1:7890"
+    )
+
+    env = prepare_environment(profile)
+
+    assert env["HTTP_PROXY"] == "http://127.0.0.1:7890"
+    assert env["HTTPS_PROXY"] == "http://127.0.0.1:7890"
+
+
+def test_prepare_env_login_clears_api_vars():
+    """Test that login mode clears API environment variables"""
+    # Set up environment with existing API variables
+    with patch.dict(os.environ, {
+        "ANTHROPIC_BASE_URL": "https://old.url",
+        "ANTHROPIC_AUTH_TOKEN": "old-token"
+    }):
+        profile = LoginProfile(
+            name="test-login",
+            type="claude",
+            credentials_path="~/.claude-profiles/account-a"
+        )
+
+        env = prepare_environment(profile)
+
+        # Should be cleared
+        assert "ANTHROPIC_BASE_URL" not in env
+        assert "ANTHROPIC_AUTH_TOKEN" not in env
+
+
+def test_prepare_env_codex_api_mode():
+    """Test environment preparation for codex API mode"""
+    profile = ApiProfile(
+        name="test-codex-api",
+        type="codex",
+        base_url="https://api.openai.com/v1",
+        api_key="sk-test"
+    )
+
+    env = prepare_environment(profile)
+
+    # Should only have OPENAI_API_KEY, not OPENAI_BASE_URL
+    assert env["OPENAI_API_KEY"] == "sk-test"
+    assert "OPENAI_BASE_URL" not in env
+
+
+def test_prepare_env_codex_login_mode():
+    """Test environment preparation for codex login mode"""
+    profile = LoginProfile(
+        name="test-codex-login",
+        type="codex",
+        credentials_path="~/.codex-profiles/account-a"
+    )
+
+    env = prepare_environment(profile)
+
+    # Should NOT have API environment variables
+    assert "OPENAI_API_KEY" not in env
+    # Should have CODEX_CONFIG_DIR with expanded path
+    expected_path = os.path.expanduser("~/.codex-profiles/account-a")
+    assert env["CODEX_CONFIG_DIR"] == expected_path

ai_code_switcher-0.1.6/tests/test_models.py

@@ -0,0 +1,115 @@
+import pytest
+from src.code_ai.models import (
+    ApiProfile, LoginProfile, profile_from_dict, profile_to_dict, VALID_TYPES
+)
+
+def test_api_profile_creation():
+    """Test creating an API profile"""
+    profile = ApiProfile(
+        name="test-api",
+        type="claude",
+        base_url="https://api.anthropic.com",
+        token="sk-ant-test"
+    )
+    assert profile.name == "test-api"
+    assert profile.type == "claude"
+    assert profile.base_url == "https://api.anthropic.com"
+    assert profile.token == "sk-ant-test"
+    assert profile.proxy is None
+
+def test_login_profile_creation():
+    """Test creating a login profile"""
+    profile = LoginProfile(
+        name="test-login",
+        type="claude",
+        credentials_path="~/.claude-profiles/account-a"
+    )
+    assert profile.name == "test-login"
+    assert profile.type == "claude"
+    assert profile.credentials_path == "~/.claude-profiles/account-a"
+    assert profile.proxy is None
+
+def test_profile_with_proxy():
+    """Test profile with proxy"""
+    profile = ApiProfile(
+        name="test-proxy",
+        type="gemini",
+        base_url="https://generativelanguage.googleapis.com",
+        api_key="AIza-test",
+        proxy="http://127.0.0.1:7890"
+    )
+    assert profile.proxy == "http://127.0.0.1:7890"
+
+def test_profile_from_dict_api_mode():
+    """Test converting dict to API profile"""
+    data = {
+        "name": "my-api",
+        "type": "claude",
+        "mode": "api",
+        "base_url": "https://api.anthropic.com",
+        "token": "sk-ant-test",
+        "proxy": None
+    }
+    profile = profile_from_dict(data)
+    assert isinstance(profile, ApiProfile)
+    assert profile.name == "my-api"
+    assert profile.base_url == "https://api.anthropic.com"
+
+def test_profile_from_dict_login_mode():
+    """Test converting dict to login profile"""
+    data = {
+        "name": "my-login",
+        "type": "claude",
+        "mode": "login",
+        "credentials_path": "~/.claude-profiles/account-a",
+        "proxy": "http://127.0.0.1:7890"
+    }
+    profile = profile_from_dict(data)
+    assert isinstance(profile, LoginProfile)
+    assert profile.credentials_path == "~/.claude-profiles/account-a"
+    assert profile.proxy == "http://127.0.0.1:7890"
+
+def test_profile_from_dict_defaults_to_api():
+    """Test that missing mode defaults to api"""
+    data = {
+        "name": "legacy",
+        "type": "claude",
+        "base_url": "https://api.anthropic.com",
+        "token": "sk-ant-test"
+    }
+    profile = profile_from_dict(data)
+    assert isinstance(profile, ApiProfile)
+
+def test_profile_to_dict_api():
+    """Test converting API profile to dict"""
+    profile = ApiProfile(
+        name="my-api",
+        type="claude",
+        base_url="https://api.anthropic.com",
+        token="sk-ant-test"
+    )
+    data = profile_to_dict(profile)
+    assert data["name"] == "my-api"
+    assert data["type"] == "claude"
+    assert data["mode"] == "api"
+    assert data["base_url"] == "https://api.anthropic.com"
+    assert data["token"] == "sk-ant-test"
+
+def test_profile_to_dict_login():
+    """Test converting login profile to dict"""
+    profile = LoginProfile(
+        name="my-login",
+        type="claude",
+        credentials_path="~/.claude-profiles/account-a",
+        proxy="http://127.0.0.1:7890"
+    )
+    data = profile_to_dict(profile)
+    assert data["name"] == "my-login"
+    assert data["type"] == "claude"
+    assert data["mode"] == "login"
+    assert data["credentials_path"] == "~/.claude-profiles/account-a"
+    assert data["proxy"] == "http://127.0.0.1:7890"
+
+def test_valid_types():
+    """Test VALID_TYPES constant"""
+    assert VALID_TYPES == ("claude", "gemini", "codex")

ai_code_switcher-0.1.4/src/code_ai/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.3"

ai_code_switcher-0.1.4/src/code_ai/launcher.py

@@ -1,58 +0,0 @@
-import os
-import sys
-import shutil
-import subprocess
-
-ENV_MAP = {
-    "claude": {
-        "env": {"ANTHROPIC_BASE_URL": "base_url", "ANTHROPIC_AUTH_TOKEN": "token"},
-        "cmd": "claude",
-    },
-    "gemini": {
-        "env": {"GOOGLE_GEMINI_BASE_URL": "base_url", "GEMINI_API_KEY": "api_key"},
-        "cmd": "gemini",
-    },
-    "codex": {
-        "env": {"OPENAI_BASE_URL": "base_url", "OPENAI_API_KEY": "api_key"},
-        "cmd": "codex",
-    },
-}
-
-
-def launch(profile, extra_args):
-    ptype = profile["type"]
-    if ptype not in ENV_MAP:
-        print(f"Error: unknown profile type '{ptype}'.")
-        sys.exit(1)
-
-    spec = ENV_MAP[ptype]
-    cmd = spec["cmd"]
-
-    # On Windows, npm global commands are .cmd files
-    if sys.platform == "win32":
-        cmd_path = shutil.which(f"{cmd}.cmd") or shutil.which(cmd)
-    else:
-        cmd_path = shutil.which(cmd)
-
-    if not cmd_path:
-        print(f"Error: '{cmd}' not found in PATH. Install it first.")
-        sys.exit(1)
-
-    env = os.environ.copy()
-    for env_var, config_key in spec["env"].items():
-        value = profile.get(config_key)
-        if value:
-            env[env_var] = value
-
-    full_cmd = [cmd_path] + extra_args
-
-    if sys.platform == "win32":
-        # On Windows, use subprocess with shell=False for better compatibility
-        try:
-            result = subprocess.run(full_cmd, env=env, shell=False)
-            sys.exit(result.returncode)
-        except KeyboardInterrupt:
-            sys.exit(130)
-    else:
-        os.environ.update(env)
-        os.execvp(cmd, [cmd] + extra_args)

ai_code_switcher-0.1.4/src/code_ai/profiles.py

@@ -1,80 +0,0 @@
-import sys
-
-
-VALID_TYPES = ("claude", "gemini", "codex")
-
-
-def list_profiles(config):
-    profiles = config.get("profiles", {})
-    if not profiles:
-        print("No profiles configured.")
-        return
-    print(f"{'Name':<20} {'Type':<10} {'Base URL'}")
-    print("-" * 60)
-    for name, p in profiles.items():
-        print(f"{name:<20} {p['type']:<10} {p.get('base_url', '')}")
-
-
-def add_profile(config):
-    name = input("Profile name: ").strip()
-    if not name:
-        print("Error: name cannot be empty.")
-        sys.exit(1)
-    if name in config.get("profiles", {}):
-        print(f"Error: profile '{name}' already exists.")
-        sys.exit(1)
-
-    ptype = input(f"Type ({'/'.join(VALID_TYPES)}): ").strip().lower()
-    if ptype not in VALID_TYPES:
-        print(f"Error: type must be one of {VALID_TYPES}.")
-        sys.exit(1)
-
-    base_url = input("Base URL: ").strip()
-    if not base_url:
-        print("Error: base URL cannot be empty.")
-        sys.exit(1)
-
-    if ptype == "claude":
-        token = input("Auth token: ").strip()
-        config.setdefault("profiles", {})[name] = {
-            "type": ptype,
-            "base_url": base_url,
-            "token": token,
-        }
-    else:
-        api_key = input("API key: ").strip()
-        config.setdefault("profiles", {})[name] = {
-            "type": ptype,
-            "base_url": base_url,
-            "api_key": api_key,
-        }
-
-    return config
-
-
-def show_profile(config, name):
-    profiles = config.get("profiles", {})
-    if name not in profiles:
-        print(f"Error: profile '{name}' not found.")
-        sys.exit(1)
-
-    profile = profiles[name]
-    print(f"Profile: {name}")
-    print(f"Type: {profile['type']}")
-    print(f"Base URL: {profile.get('base_url', 'N/A')}")
-
-    if profile['type'] == 'claude':
-        token = profile.get('token', 'N/A')
-        print(f"Token: {token}")
-    else:
-        api_key = profile.get('api_key', 'N/A')
-        print(f"API Key: {api_key}")
-
-
-def remove_profile(config, name):
-    if name not in config.get("profiles", {}):
-        print(f"Error: profile '{name}' not found.")
-        sys.exit(1)
-    del config["profiles"][name]
-    print(f"Removed profile '{name}'.")
-    return config