codefreedom 0.1.0__py3-none-any.whl

codefreedom/cli/main.py

@@ -0,0 +1,325 @@
+"""Top-level CLI entry point — parses args and dispatches to subcommands.
+
+Entry point: codefreedom | cf
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+_CODEFREEDOM_DIR = Path.home() / ".codefreedom"
+
+
+def _find_project_root() -> Path:
+    """Find the project root directory (where profiles.examples/ and litellm.examples/ live)."""
+    return Path(__file__).resolve().parent.parent.parent.parent
+
+
+def _find_bundled_examples() -> Path:
+    """Find the bundled examples directory inside the installed package."""
+    return Path(__file__).resolve().parent.parent / "examples"
+
+
+def _init_codefreedom(
+    force: bool = False,
+    project_root: Path | None = None,
+    cf_dir: Path | None = None,
+) -> int:
+    """Initialize ~/.codefreedom/ with default profiles and proxy configs.
+
+    Copies from the project's examples directories (profiles.examples/
+    and litellm.examples/) or from the bundled package examples into
+    ~/.codefreedom/.
+
+    Args:
+        force: Overwrite existing files.
+        project_root: Override the project root (for testing).
+        cf_dir: Override the ~/.codefreedom directory (for testing).
+    """
+    if project_root is None:
+        project_root = _find_project_root()
+    if cf_dir is None:
+        cf_dir = _CODEFREEDOM_DIR
+
+    bundled = _find_bundled_examples()
+
+    profiles_src = project_root / "profiles.examples" / "claude-code-profiles.json"
+    schema_src = project_root / "profiles.examples" / "claude-code-profiles.schema.json"
+    proxy_src = project_root / "litellm.examples"
+
+    # Fall back to bundled examples if project-root sources don't exist
+    if not profiles_src.exists():
+        profiles_src = bundled / "profiles" / "claude-code-profiles.json"
+    if not schema_src.exists():
+        schema_src = bundled / "profiles" / "claude-code-profiles.schema.json"
+    if not proxy_src.exists():
+        proxy_src = bundled / "proxy"
+
+    profiles_dst_dir = cf_dir / "profiles"
+    profiles_dst = profiles_dst_dir / "claude-code.json"
+    schema_dst = profiles_dst_dir / "claude-code-profiles.schema.json"
+    proxy_dst = cf_dir / "proxy"
+
+    created_any = False
+    skipped_any = False
+
+    # ── Profiles ───────────────────────────────────────────────────────────
+    if not force and profiles_dst.exists():
+        print(f"[init] Profiles already exist: {profiles_dst}")
+        print("       Use --init --force to overwrite.")
+        skipped_any = True
+    elif profiles_src.exists():
+        profiles_dst_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(profiles_src, profiles_dst)
+        print(f"[init] ✓ Created {profiles_dst}")
+        created_any = True
+    else:
+        print(f"[init] ✖ Profiles example not found: {profiles_src}")
+        print("       Make sure profiles.examples/claude-code-profiles.json exists.")
+
+    # ── Schema ─────────────────────────────────────────────────────────────
+    if not force and schema_dst.exists():
+        print(f"[init] Schema already exists: {schema_dst}")
+        skipped_any = True
+    elif schema_src.exists():
+        profiles_dst_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(schema_src, schema_dst)
+        print(f"[init] ✓ Created {schema_dst}")
+        created_any = True
+    else:
+        print(f"[init] ✖ Schema example not found: {schema_src}")
+        print(
+            "       Make sure profiles.examples/claude-code-profiles.schema.json exists."
+        )
+
+    # ── Proxy configs (litellm) ─────────────────────────────────────────────
+    if not force and proxy_dst.exists():
+        print(f"[init] Proxy configs already exist: {proxy_dst}")
+        print("       Use --init --force to overwrite.")
+        skipped_any = True
+    elif proxy_src.exists():
+        if proxy_dst.exists() and force:
+            shutil.rmtree(proxy_dst)
+
+        # Source layout (litellm.examples/ or bundled proxy/):
+        #   config.yaml          → proxy/config/config.yaml
+        #   docker-compose.yml   → proxy/docker-compose.yml
+        #   providers/           → proxy/config/providers/
+        proxy_config_dir = proxy_dst / "config"
+        proxy_config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy config.yaml into config/ subdirectory
+        src_config = proxy_src / "config.yaml"
+        if src_config.exists():
+            shutil.copy2(src_config, proxy_config_dir / "config.yaml")
+
+        # Copy docker-compose.yml to proxy root
+        src_compose = proxy_src / "docker-compose.yml"
+        if src_compose.exists():
+            shutil.copy2(src_compose, proxy_dst / "docker-compose.yml")
+
+        # Copy providers into config/providers/
+        src_providers = proxy_src / "providers"
+        if src_providers.exists():
+            dst_providers = proxy_config_dir / "providers"
+            if dst_providers.exists() and force:
+                shutil.rmtree(dst_providers)
+            shutil.copytree(src_providers, dst_providers, dirs_exist_ok=True)
+
+        print(f"[init] ✓ Created {proxy_dst}")
+        created_any = True
+    else:
+        print(f"[init] ✖ Proxy examples not found: {proxy_src}")
+        print("       Make sure litellm.examples/ exists.")
+
+    # ── Environment files (.env / .env.secrets) ────────────────────────────
+    # Copy fully-commented templates from project root or bundled examples.
+    # These are only created if the destination file doesn't already exist
+    # (never overwritten — user edits them manually).
+    env_src = project_root / ".env.example"
+    secrets_src = project_root / ".env.secrets.example"
+
+    if not env_src.exists():
+        env_src = bundled / ".env.example"
+    if not secrets_src.exists():
+        secrets_src = bundled / ".env.secrets.example"
+
+    env_dst = cf_dir / ".env"
+    secrets_dst = cf_dir / ".env.secrets"
+
+    if env_dst.exists():
+        print(f"[init] .env already exists: {env_dst} (skipping — edit it manually)")
+        skipped_any = True
+    elif env_src.exists():
+        cf_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(env_src, env_dst)
+        print(
+            f"[init] ✓ Created {env_dst} (fully commented — uncomment variables you need)"
+        )
+        created_any = True
+    else:
+        print(f"[init] ✖ .env.example not found: {env_src}")
+
+    # .env.secrets is optional — only copy if source exists and dest doesn't
+    if secrets_dst.exists():
+        print(f"[init] .env.secrets already exists: {secrets_dst} (skipping)")
+    elif secrets_src.exists():
+        cf_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(secrets_src, secrets_dst)
+        print(f"[init] ✓ Created {secrets_dst} (fully commented — add your API keys)")
+        created_any = True
+
+    if created_any:
+        print()
+        print("[init] CodeFreedom is initialized!")
+        print(f"       Profiles: {profiles_dst_dir}")
+        print(f"         - claude-code.json")
+        print(f"         - claude-code-profiles.schema.json")
+        print(f"       Proxy:    {proxy_dst}")
+        print(f"       Env:      {cf_dir}")
+        print(f"         - .env (fully commented)")
+        print(f"         - .env.secrets (fully commented)")
+        print("       Edit these files to customize your setup.")
+    elif skipped_any:
+        print()
+        print("[init] Nothing to do — all files already exist.")
+    else:
+        print()
+        print("[init] No source files found to copy.")
+
+    return 0
+
+
+def main() -> None:
+    """Top-level CLI entry point: codefreedom | cf."""
+    parser = argparse.ArgumentParser(
+        prog="codefreedom",
+        description="CodeFreedom — Claude Code launcher and LiteLLM proxy management.",
+    )
+    parser.add_argument(
+        "--init",
+        action="store_true",
+        help="Initialize ~/.codefreedom/ with default profiles and proxy configs",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force overwrite existing configs (use with --init)",
+    )
+    subparsers = parser.add_subparsers(dest="command", title="commands")
+
+    # ── claude subcommand ──────────────────────────────────────────────────
+    claude_parser = subparsers.add_parser(
+        "claude",
+        aliases=["cc"],
+        help="Launch Claude Code with profile-based model routing",
+        description="Run Claude Code natively (default) or in a sandboxed Docker container.",
+    )
+    claude_parser.add_argument(
+        "--sandbox",
+        action="store_true",
+        help="Run Claude Code inside a sandboxed Docker container (default: native)",
+    )
+    claude_parser.add_argument(
+        "--native-models",
+        action="store_true",
+        help="Use native Anthropic models/auth (/login) — strips ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN",
+    )
+    claude_parser.add_argument(
+        "--profile",
+        type=str,
+        default="default",
+        metavar="NAME",
+        help="Load a named profile (default: 'default')",
+    )
+    claude_parser.add_argument(
+        "--stop",
+        action="store_true",
+        help="Stop and remove the persistent Docker container",
+    )
+    claude_parser.add_argument(
+        "--status",
+        action="store_true",
+        help="Show persistent container status and exit",
+    )
+    claude_parser.add_argument(
+        "--list-profiles",
+        action="store_true",
+        help="List available profiles and exit",
+    )
+    claude_parser.add_argument(
+        "claude_args",
+        nargs=argparse.REMAINDER,
+        help="Arguments forwarded to the 'claude' CLI",
+    )
+
+    # ── proxy subcommand ───────────────────────────────────────────────────
+    proxy_parser = subparsers.add_parser(
+        "proxy",
+        aliases=["px"],
+        help="Manage the LiteLLM proxy (start, stop, validate, status)",
+        description="Manage the LiteLLM proxy lifecycle.",
+    )
+    proxy_parser.add_argument(
+        "--up",
+        action="store_true",
+        help="Start the LiteLLM proxy (native by default; use --docker for Compose)",
+    )
+    proxy_parser.add_argument(
+        "--down",
+        action="store_true",
+        help="Stop the LiteLLM proxy",
+    )
+    proxy_parser.add_argument(
+        "--status",
+        action="store_true",
+        help="Show LiteLLM proxy status",
+    )
+    proxy_parser.add_argument(
+        "--validate",
+        action="store_true",
+        help="Validate the LiteLLM configuration",
+    )
+    proxy_parser.add_argument(
+        "--docker",
+        action="store_true",
+        help="Run via Docker Compose instead of native Python",
+    )
+    proxy_parser.add_argument(
+        "--port",
+        type=int,
+        default=4000,
+        help="Port for proxy (default: 4000)",
+    )
+    proxy_parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Bind host for proxy (default: 0.0.0.0)",
+    )
+
+    args = parser.parse_args()
+
+    # ── --init: bootstrap ~/.codefreedom/ ───────────────────────────────────
+    if args.init:
+        sys.exit(_init_codefreedom(force=args.force))
+
+    if args.command in ("claude", "cc"):
+        # Lazy import to keep CLI startup fast
+        from codefreedom.cli.claude import run as claude_run
+
+        sys.exit(claude_run(args))
+    elif args.command in ("proxy", "px"):
+        from codefreedom.cli.proxy import run as proxy_run
+
+        sys.exit(proxy_run(args))
+    else:
+        parser.print_help()
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

codefreedom/cli/proxy.py

@@ -0,0 +1,332 @@
+"""Proxy subcommand — manage the LiteLLM proxy.
+
+Usage:
+    codefreedom proxy --up         Start the LiteLLM proxy (native, default)
+    codefreedom proxy --up --docker  Start via Docker Compose
+    codefreedom proxy --down       Stop the LiteLLM proxy
+    codefreedom proxy --status     Show proxy status
+    codefreedom proxy --validate   Validate LiteLLM configuration
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from codefreedom.env_loader import eprint
+
+# ── Path resolution ──────────────────────────────────────────────────────────
+
+_CODEFREEDOM_DIR = Path.home() / ".codefreedom"
+
+
+def _find_compose_file() -> Optional[Path]:
+    """Find the LiteLLM docker-compose file in ~/.codefreedom/proxy/."""
+    candidate = _CODEFREEDOM_DIR / "proxy" / "docker-compose.yml"
+    if candidate.exists():
+        return candidate
+    return None
+
+
+def _find_config_file() -> Optional[Path]:
+    """Find the LiteLLM config.yaml in ~/.codefreedom/proxy/config/."""
+    candidate = _CODEFREEDOM_DIR / "proxy" / "config" / "config.yaml"
+    if candidate.exists():
+        return candidate
+    return None
+
+
+# ── Entry point ──────────────────────────────────────────────────────────────
+
+
+def run(args: argparse.Namespace) -> int:
+    """Execute the proxy subcommand. Returns exit code."""
+
+    if args.up:
+        return _start(args)
+    elif args.down:
+        return _stop()
+    elif args.status:
+        return _status()
+    elif args.validate:
+        return _validate()
+    else:
+        eprint(
+            "[proxy] No action specified. Use --up, --down, --status, or --validate."
+        )
+        return 1
+
+
+# ── Start ────────────────────────────────────────────────────────────────────
+
+
+def _start(args: argparse.Namespace) -> int:
+    """Start the LiteLLM proxy. Defaults to native; --docker uses Compose."""
+    if args.docker:
+        return _start_compose()
+    else:
+        return _start_native(args)
+
+
+def _start_compose() -> int:
+    """Start LiteLLM via docker compose."""
+    compose_file = _find_compose_file()
+    if not compose_file:
+        eprint("[ERROR] Could not find ~/.codefreedom/proxy/docker-compose.yml")
+        eprint("   Run: codefreedom --init")
+        return 1
+
+    eprint(f"[proxy] Starting LiteLLM via Docker Compose ({compose_file})...")
+    result = subprocess.run(
+        [
+            "docker",
+            "compose",
+            "-f",
+            str(compose_file),
+            "--profile",
+            "litellm",
+            "up",
+            "-d",
+        ],
+        capture_output=False,
+        check=False,
+    )
+    if result.returncode == 0:
+        eprint("[proxy] ✓ Proxy started at http://localhost:4000")
+    else:
+        eprint("[proxy] ✖ Failed to start. Check docker logs.")
+    return result.returncode
+
+
+def _start_native(args: argparse.Namespace) -> int:
+    """Start LiteLLM directly as a Python process."""
+    try:
+        __import__("litellm")
+    except ImportError:
+        eprint("[ERROR] litellm package not installed.")
+        eprint("   Install: pip install codefreedom[litellm]")
+        eprint("   This installs litellm with proxy extras (websockets, etc.).")
+        eprint("   Or run without --native to use Docker Compose.")
+        return 1
+
+    litellm_bin = shutil.which("litellm")
+    if not litellm_bin:
+        eprint("[ERROR] litellm CLI not found on PATH.")
+        eprint("   Ensure litellm is installed: pip install codefreedom[litellm]")
+        return 1
+
+    config_file = _find_config_file()
+    if not config_file:
+        eprint("[ERROR] Could not find ~/.codefreedom/proxy/config/config.yaml")
+        eprint("   Run: codefreedom --init")
+        return 1
+
+    port = args.port or 4000
+    host = args.host or "0.0.0.0"
+
+    eprint(f"[proxy] Starting natively on {host}:{port}...")
+    eprint(f"[proxy] Config: {config_file}")
+
+    cmd = [
+        litellm_bin,
+        "--config",
+        str(config_file),
+        "--port",
+        str(port),
+        "--host",
+        host,
+    ]
+
+    try:
+        proc = subprocess.Popen(cmd)
+        eprint(f"[proxy] ✓ Proxy starting (PID: {proc.pid})")
+        eprint("[proxy]   Press Ctrl+C to stop.")
+        proc.wait()
+        return proc.returncode
+    except KeyboardInterrupt:
+        eprint("\n[proxy] Proxy stopped.")
+        return 0
+    except FileNotFoundError:
+        eprint("[ERROR] Could not find litellm executable.")
+        return 1
+
+
+# ── Stop ─────────────────────────────────────────────────────────────────────
+
+
+def _stop() -> int:
+    """Stop the LiteLLM proxy."""
+    compose_file = _find_compose_file()
+    if not compose_file:
+        eprint("[ERROR] Could not find ~/.codefreedom/proxy/docker-compose.yml")
+        eprint("   Run: codefreedom --init")
+        return 1
+
+    eprint("[proxy] Stopping LiteLLM proxy...")
+    result = subprocess.run(
+        ["docker", "compose", "-f", str(compose_file), "--profile", "litellm", "down"],
+        capture_output=False,
+        check=False,
+    )
+    if result.returncode == 0:
+        eprint("[proxy] ✓ Proxy stopped.")
+    return result.returncode
+
+
+# ── Status ───────────────────────────────────────────────────────────────────
+
+
+def _status() -> int:
+    """Show LiteLLM proxy status."""
+    compose_file = _find_compose_file()
+    if not compose_file:
+        eprint("[ERROR] Could not find ~/.codefreedom/proxy/docker-compose.yml")
+        eprint("   Run: codefreedom --init")
+        return 1
+
+    result = subprocess.run(
+        ["docker", "compose", "-f", str(compose_file), "--profile", "litellm", "ps"],
+        capture_output=False,
+        check=False,
+    )
+    return result.returncode
+
+
+# ── Validate ─────────────────────────────────────────────────────────────────
+
+
+def _validate() -> int:
+    """Validate the LiteLLM configuration."""
+    config_file = _find_config_file()
+    if not config_file:
+        eprint("[ERROR] Could not find ~/.codefreedom/proxy/config/config.yaml")
+        eprint("   Run: codefreedom --init")
+        return 1
+
+    errors: List[str] = []
+
+    eprint(f"[proxy] Validating {config_file}...")
+    eprint()
+
+    try:
+        import yaml
+    except ImportError:
+        eprint("[WARN] PyYAML not installed. Using basic validation only.")
+        eprint("   Install: pip install pyyaml")
+        _validate_basic(config_file, errors)
+        _print_validation_result(errors)
+        return 0 if not errors else 1
+
+    try:
+        with open(config_file, encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        eprint(f"  ✖  YAML parse error: {e}")
+        return 1
+    except FileNotFoundError:
+        eprint(f"  ✖  File not found: {config_file}")
+        return 1
+
+    if not isinstance(config, dict):
+        eprint("  ✖  Config must be a YAML dictionary.")
+        return 1
+
+    includes = config.get("include", [])
+    if not includes:
+        eprint("  ⚠  No provider includes found in config.yaml")
+    else:
+        config_dir = config_file.parent
+        for inc in includes:
+            provider_file = config_dir / inc
+            if provider_file.exists():
+                eprint(f"  ✓  {inc}")
+                try:
+                    with open(provider_file, encoding="utf-8") as f:
+                        provider_config = yaml.safe_load(f)
+                    models = provider_config.get("model_list", [])
+                    for m in models:
+                        name = m.get("model_name", "?")
+                        params = m.get("litellm_params", {})
+                        api_key_ref = params.get("api_key", "")
+                        if api_key_ref.startswith("os.environ/"):
+                            env_var = api_key_ref[len("os.environ/") :]
+                            if not _env_is_set(env_var):
+                                eprint(f"    ⚠  {name}: env var {env_var} is not set")
+                            else:
+                                eprint(f"    ✓  {name} (auth: {env_var} ✓)")
+                        else:
+                            eprint(f"    ✓  {name}")
+                except yaml.YAMLError as e:
+                    eprint(f"    ✖  {inc}: YAML error — {e}")
+                    errors.append(f"YAML error in {inc}: {e}")
+            else:
+                eprint(f"  ✖  {inc} — file not found")
+                errors.append(f"Missing provider file: {inc}")
+
+    general = config.get("general_settings", {})
+    if not general.get("database_url"):
+        eprint("  ⚠  database_url not set (stateless mode)")
+
+    router = config.get("router_settings", {})
+    aliases = router.get("model_group_alias", {})
+    if aliases:
+        eprint(f"  ✓  Model aliases: {len(aliases)} defined")
+        for alias, model in aliases.items():
+            eprint(f"       {alias} → {model}")
+    else:
+        eprint("  ⚠  No model_group_alias defined")
+
+    eprint()
+    _print_validation_result(errors)
+    return 0 if not errors else 1
+
+
+def _validate_basic(config_file: Path, errors: List[str]) -> None:
+    """Basic validation without PyYAML."""
+    content = config_file.read_text()
+    checks = [
+        ("include:", "provider includes"),
+        ("general_settings:", "general_settings section"),
+        ("router_settings:", "router_settings section"),
+        ("litellm_settings:", "litellm_settings section"),
+        ("model_group_alias:", "model aliases"),
+    ]
+    for marker, label in checks:
+        if marker in content:
+            eprint(f"  ✓  {label} found")
+        else:
+            eprint(f"  ✖  {label} missing")
+            errors.append(f"Missing: {label}")
+
+    config_dir = config_file.parent
+    for line in content.split("\n"):
+        line = line.strip()
+        if line.startswith("- providers/"):
+            provider_file = line[2:].strip()
+            full = config_dir / provider_file
+            if full.exists():
+                eprint(f"  ✓  {provider_file}")
+            else:
+                eprint(f"  ✖  {provider_file} — not found")
+                errors.append(f"Missing: {provider_file}")
+
+
+def _env_is_set(var_name: str) -> bool:
+    """Check if an environment variable is set and non-empty."""
+    import os
+
+    return bool(os.environ.get(var_name))
+
+
+def _print_validation_result(errors: List[str]) -> None:
+    """Print validation summary."""
+    if errors:
+        eprint(f"  ✖  {len(errors)} issue(s) found.")
+        for e in errors:
+            eprint(f"       - {e}")
+    else:
+        eprint("  ✓  Configuration looks good!")