leitum 0.1.0__py3-none-any.whl

leitum/__init__.py

@@ -0,0 +1,3 @@
+"""leitum — launch Claude Code against alternative LLM routers."""
+
+__version__ = "0.1.0"

leitum/__main__.py

@@ -0,0 +1,3 @@
+from leitum.cli import app
+
+app()

leitum/cli.py

@@ -0,0 +1,238 @@
+"""Root typer application and subcommand registration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+app = typer.Typer(
+    name="leitum",
+    help="Launch Claude Code against alternative LLM routers.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+provider_app = typer.Typer(help="Manage configured providers.", no_args_is_help=True)
+app.add_typer(provider_app, name="provider")
+
+
+# Shared state passed via typer Context
+class _Opts:
+    provider: str | None = None
+    use_last_provider: bool = False
+    model: str | None = None
+    use_last_model: bool = False
+    opus: str | None = None
+    use_last_opus: bool = False
+    sonnet: str | None = None
+    use_last_sonnet: bool = False
+    haiku: str | None = None
+    use_last_haiku: bool = False
+    refresh: bool = False
+    no_project_config: bool = False
+    project_config: Path | None = None
+    dry_run: bool = False
+    verbose: bool = False
+
+
+@app.callback(invoke_without_command=True)
+def root(
+    ctx: typer.Context,
+    provider: str | None = typer.Option(None, "--provider", "-p", help="Set provider."),
+    use_last_provider: bool = typer.Option(
+        False, "--use-last-provider", "-P", help="Reuse last provider."
+    ),
+    model: str | None = typer.Option(None, "--model", "-m", help="Set START model."),
+    use_last_model: bool = typer.Option(
+        False, "--use-last-model", "-M", help="Reuse last START model."
+    ),
+    opus: str | None = typer.Option(None, "--opus", "-o", help="Set OPUS model."),
+    use_last_opus: bool = typer.Option(
+        False, "--use-last-opus", "-O", help="Reuse last OPUS model."
+    ),
+    sonnet: str | None = typer.Option(None, "--sonnet", "-s", help="Set SONNET model."),
+    use_last_sonnet: bool = typer.Option(
+        False, "--use-last-sonnet", "-S", help="Reuse last SONNET model."
+    ),
+    haiku: str | None = typer.Option(None, "--haiku", "-k", help="Set HAIKU model."),
+    use_last_haiku: bool = typer.Option(
+        False, "--use-last-haiku", "-K", help="Reuse last HAIKU model."
+    ),
+    refresh: bool = typer.Option(
+        False, "--refresh", "-r", help="Refresh model cache before selection."
+    ),
+    no_project_config: bool = typer.Option(
+        False, "--no-project-config", help="Ignore leitum.yaml."
+    ),
+    project_config: Path | None = typer.Option(
+        None, "--project-config", help="Use alternative project config."
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Print resolved env and exec line, do not launch."
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose logging on stderr."),
+    version: bool = typer.Option(False, "--version", help="Show version and exit.", is_eager=True),
+) -> None:
+    if version:
+        import importlib.metadata
+
+        ver = importlib.metadata.version("leitum")
+        typer.echo(f"leitum {ver}")
+        raise typer.Exit()
+
+    ctx.ensure_object(_Opts)
+    obj = ctx.obj
+    obj.provider = provider
+    obj.use_last_provider = use_last_provider
+    obj.model = model
+    obj.use_last_model = use_last_model
+    obj.opus = opus
+    obj.use_last_opus = use_last_opus
+    obj.sonnet = sonnet
+    obj.use_last_sonnet = use_last_sonnet
+    obj.haiku = haiku
+    obj.use_last_haiku = use_last_haiku
+    obj.refresh = refresh
+    obj.no_project_config = no_project_config
+    obj.project_config = project_config
+    obj.dry_run = dry_run
+    obj.verbose = verbose
+
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+@app.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+    help=(
+        "Launch Claude Code via the configured provider.\n\n"
+        "All arguments after 'claude' are passed through to the claude binary unchanged.\n"
+        "See 'claude --help' for Claude Code's own options."
+    ),
+)
+def claude(
+    ctx: typer.Context,
+    args: list[str] = typer.Argument(default=None),
+) -> None:
+    ctx.ensure_object(_Opts)
+    opts: _Opts = ctx.obj
+    pass_through = list(ctx.args) + (args or [])
+
+    from leitum.commands.claude import run_claude
+
+    run_claude(
+        pass_through=pass_through,
+        provider_flag=opts.provider,
+        use_last_provider=opts.use_last_provider,
+        model_flag=opts.model,
+        use_last_model=opts.use_last_model,
+        opus_flag=opts.opus,
+        use_last_opus=opts.use_last_opus,
+        sonnet_flag=opts.sonnet,
+        use_last_sonnet=opts.use_last_sonnet,
+        haiku_flag=opts.haiku,
+        use_last_haiku=opts.use_last_haiku,
+        refresh=opts.refresh,
+        no_project_config=opts.no_project_config,
+        project_config_path=opts.project_config,
+        dry_run=opts.dry_run,
+        verbose=opts.verbose,
+    )
+
+
+@app.command()
+def init(
+    force: bool = typer.Option(False, "--force", help="Overwrite existing files."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompts."),
+) -> None:
+    """Initialize leitum config directory and example providers file."""
+    from leitum.commands.init import run_init
+
+    run_init(force=force, yes=yes)
+
+
+@app.command()
+def refresh(
+    ctx: typer.Context,
+    provider_name: str | None = typer.Option(
+        None, "--provider", "-p", help="Refresh specific provider only."
+    ),
+) -> None:
+    """Delete model cache and re-fetch from providers."""
+    from leitum.commands.refresh import run_refresh
+
+    run_refresh(provider_name)
+
+
+@app.command()
+def doctor(
+    project_config: Path | None = typer.Option(
+        None, "--project-config", help="Path to project config."
+    ),
+) -> None:
+    """Run sanity checks on config, permissions, and environment."""
+    from leitum.commands.doctor import run_doctor
+
+    run_doctor(project_config)
+
+
+@app.command()
+def completions(
+    shell: str = typer.Argument(..., help="Shell: bash, zsh, or fish."),
+) -> None:
+    """Print shell completion script."""
+    import subprocess
+
+    if shell not in ("bash", "zsh", "fish"):
+        typer.echo(f"Unsupported shell '{shell}'. Choose from: bash, zsh, fish.", err=True)
+        raise typer.Exit(2)
+    result = subprocess.run(
+        ["leitum", "--show-completion", shell],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        typer.echo(result.stdout, nl=False)
+    else:
+        typer.echo(result.stderr, err=True)
+        raise typer.Exit(result.returncode)
+
+
+@provider_app.command("list")
+def provider_list() -> None:
+    """List all configured providers."""
+    from leitum.commands.provider import run_provider_list
+
+    run_provider_list()
+
+
+@provider_app.command("show")
+def provider_show(
+    name: str = typer.Argument(..., help="Provider name."),
+    reveal_token: bool = typer.Option(False, "--reveal-token", help="Show plaintext token."),
+) -> None:
+    """Show configuration for a provider (token redacted by default)."""
+    from leitum.commands.provider import run_provider_show
+
+    run_provider_show(name, reveal_token=reveal_token)
+
+
+@provider_app.command("add")
+def provider_add() -> None:
+    """Interactively add a new provider."""
+    from leitum.commands.provider import run_provider_add
+
+    run_provider_add()
+
+
+@provider_app.command("remove")
+def provider_remove(
+    name: str = typer.Argument(..., help="Provider name to remove."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    """Remove a provider (with confirmation)."""
+    from leitum.commands.provider import run_provider_remove
+
+    run_provider_remove(name, yes=yes)

leitum/commands/claude.py

@@ -0,0 +1,182 @@
+"""leitum claude subcommand — launch Claude Code via a configured provider."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from leitum.config.io import load_project_config, load_providers_config
+from leitum.config.models import ModelSlot
+from leitum.config.paths import providers_config_path
+from leitum.launch import exec_claude
+from leitum.providers.cache import clear_cache
+from leitum.providers.discovery import discover_models
+from leitum.selection.resolver import resolve_models, resolve_provider
+from leitum.state import load_state, save_state
+
+
+def run_claude(
+    pass_through: list[str],
+    *,
+    provider_flag: str | None,
+    use_last_provider: bool,
+    model_flag: str | None,
+    use_last_model: bool,
+    opus_flag: str | None,
+    use_last_opus: bool,
+    sonnet_flag: str | None,
+    use_last_sonnet: bool,
+    haiku_flag: str | None,
+    use_last_haiku: bool,
+    refresh: bool,
+    no_project_config: bool,
+    project_config_path: Path | None,
+    dry_run: bool,
+    verbose: bool,
+) -> None:
+    # Conflict checks
+    _check_conflict("--model/-m", "--use-last-model/-M", model_flag, use_last_model)
+    _check_conflict("--opus/-o", "--use-last-opus/-O", opus_flag, use_last_opus)
+    _check_conflict("--sonnet/-s", "--use-last-sonnet/-S", sonnet_flag, use_last_sonnet)
+    _check_conflict("--haiku/-k", "--use-last-haiku/-K", haiku_flag, use_last_haiku)
+    if no_project_config and project_config_path is not None:
+        print(
+            "Error: --no-project-config and --project-config are mutually exclusive.",
+            file=sys.stderr,
+        )
+        raise SystemExit(2)
+
+    # Load global config
+    cfg_path = providers_config_path()
+    if not cfg_path.exists():
+        print(
+            f"Error: providers config not found at {cfg_path}. Run 'leitum init' first.",
+            file=sys.stderr,
+        )
+        raise SystemExit(3)
+    try:
+        config = load_providers_config(cfg_path)
+    except Exception as exc:
+        print(f"Error: invalid providers config: {exc}", file=sys.stderr)
+        raise SystemExit(3) from exc
+
+    state = load_state()
+
+    # Load project config
+    project_cfg = None
+    if not no_project_config:
+        pc_path = project_config_path or Path("leitum.yaml")
+        if pc_path.exists():
+            try:
+                raw_pc = load_project_config(pc_path)
+                # Validate provider reference
+                if raw_pc.provider is not None:
+                    if config.get_provider(raw_pc.provider) is None:
+                        known = ", ".join(p.name for p in config.providers)
+                        print(
+                            f"Error: leitum.yaml references unknown provider '{raw_pc.provider}'. "
+                            f"Known providers: {known}",
+                            file=sys.stderr,
+                        )
+                        raise SystemExit(3)
+                project_cfg = raw_pc
+            except SystemExit:
+                raise
+            except Exception as exc:
+                print(f"Error: invalid leitum.yaml: {exc}", file=sys.stderr)
+                raise SystemExit(3) from exc
+
+    # Resolve provider
+    provider = resolve_provider(
+        flag=provider_flag,
+        use_last=use_last_provider,
+        project_provider=project_cfg.provider if project_cfg else None,
+        state=state,
+        config=config,
+        verbose=verbose,
+    )
+
+    # Refresh cache if requested
+    if refresh:
+        if provider.models:
+            print(
+                f"Warning: --refresh has no effect for provider '{provider.name}' "
+                "(models are pinned in YAML).",
+                file=sys.stderr,
+            )
+        else:
+            if verbose:
+                print(f"Refreshing model list for {provider.name}...", file=sys.stderr)
+            clear_cache(provider.name)
+
+    # Discover models
+    try:
+        model_infos = discover_models(provider, force=refresh and not bool(provider.models))
+    except RuntimeError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        raise SystemExit(4) from exc
+
+    # Resolve models
+    flags: dict[ModelSlot, str | None] = {
+        "start": model_flag,
+        "opus": opus_flag,
+        "sonnet": sonnet_flag,
+        "haiku": haiku_flag,
+    }
+    use_last: dict[ModelSlot, bool] = {
+        "start": use_last_model,
+        "opus": use_last_opus,
+        "sonnet": use_last_sonnet,
+        "haiku": use_last_haiku,
+    }
+
+    # Warn if model not in list
+    for slot, flag_val in flags.items():
+        if flag_val and model_infos:
+            known_ids = {m.id for m in model_infos}
+            if flag_val not in known_ids:
+                print(
+                    f"Warning: model '{flag_val}' for slot '{slot}' not in provider's model list.",
+                    file=sys.stderr,
+                )
+
+    resolved = resolve_models(
+        flags=flags,
+        use_last=use_last,
+        project_models=project_cfg.models if project_cfg else None,
+        state=state,
+        provider=provider,
+        model_infos=model_infos,
+        verbose=verbose,
+    )
+
+    # Persist state
+    state.last_provider = provider.name
+    from leitum.selection.resolver import _SLOTS
+
+    for slot in _SLOTS:
+        val = resolved.get(slot)
+        if val:
+            state.set_model(provider.name, slot, val)
+    state.touch_provider(provider.name)
+    try:
+        save_state(state)
+    except Exception as exc:
+        print(f"Warning: could not save state: {exc}", file=sys.stderr)
+
+    project_extra = project_cfg.extra_env if project_cfg else {}
+
+    exec_claude(
+        provider=provider,
+        models=resolved,
+        pass_through=pass_through,
+        project_extra_env=project_extra,
+        dry_run=dry_run,
+        verbose=verbose,
+    )
+
+
+def _check_conflict(flag_a: str, flag_b: str, val_a: str | None, use_last_b: bool) -> None:
+    if val_a is not None and use_last_b:
+        print(f"Error: {flag_a} and {flag_b} are mutually exclusive.", file=sys.stderr)
+        raise SystemExit(2)

leitum/commands/doctor.py

@@ -0,0 +1,185 @@
+"""leitum doctor command — sanity check suite."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import stat
+import subprocess
+from pathlib import Path
+
+from leitum.config.paths import get_config_dir, model_cache_path, providers_config_path, state_path
+
+_SECRET_RE = re.compile(r"^[A-Za-z0-9+/=_\-]{24,}$")
+
+
+def _ok(msg: str) -> None:
+    print(f"[ ok ] {msg}")
+
+
+def _warn(msg: str) -> None:
+    print(f"[warn] {msg}")
+
+
+def _fail(msg: str) -> None:
+    print(f"[fail] {msg}")
+
+
+def run_doctor(project_config_path: Path | None = None) -> None:
+    failures = 0
+    warnings = 0
+
+    # 1. Paths & permissions
+    print("--- Paths & Permissions ---")
+    config_dir = get_config_dir()
+    if config_dir.exists():
+        mode = config_dir.stat().st_mode
+        if stat.S_IMODE(mode) == 0o700:
+            _ok(f"Config dir {config_dir} has mode 0700")
+        else:
+            _warn(f"Config dir {config_dir} has mode {oct(stat.S_IMODE(mode))} (expected 0700)")
+            warnings += 1
+    else:
+        _fail(f"Config dir {config_dir} does not exist. Run 'leitum init'.")
+        failures += 1
+
+    cfg_path = providers_config_path()
+    if cfg_path.exists():
+        mode = cfg_path.stat().st_mode
+        if stat.S_IMODE(mode) <= 0o600:
+            _ok(f"api-providers.yaml has mode {oct(stat.S_IMODE(mode))}")
+        else:
+            _warn(
+                f"api-providers.yaml has mode {oct(stat.S_IMODE(mode))}"
+                f" (recommend chmod 600 {cfg_path})"
+            )
+            warnings += 1
+    else:
+        _fail(f"api-providers.yaml not found at {cfg_path}. Run 'leitum init'.")
+        failures += 1
+
+    # 2. Config validation
+    print("\n--- Config Validation ---")
+    config = None
+    if cfg_path.exists():
+        try:
+            from leitum.config.io import load_providers_config
+
+            config = load_providers_config(cfg_path)
+            _ok(f"api-providers.yaml is valid ({len(config.providers)} provider(s))")
+        except Exception as exc:
+            _fail(f"api-providers.yaml parse error: {exc}")
+            failures += 1
+
+    pc_path = project_config_path or Path("leitum.yaml")
+    if pc_path.exists():
+        try:
+            from leitum.config.io import load_project_config
+
+            pc = load_project_config(pc_path)
+            _ok("leitum.yaml is valid")
+            if pc.provider and config:
+                if config.get_provider(pc.provider) is None:
+                    _fail(f"leitum.yaml references unknown provider '{pc.provider}'")
+                    failures += 1
+                else:
+                    _ok(f"leitum.yaml provider '{pc.provider}' found in config")
+            # Heuristic secret check in extra_env
+            for k, v in (pc.extra_env or {}).items():
+                if _SECRET_RE.match(v) and "${" not in v:
+                    _warn(
+                        f"leitum.yaml extra_env['{k}'] looks like a secret"
+                        f" (length {len(v)}, no interpolation)."
+                        " Do not commit secrets to version control."
+                    )
+                    warnings += 1
+        except Exception as exc:
+            _fail(f"leitum.yaml parse error: {exc}")
+            failures += 1
+
+    # 3. State file
+    print("\n--- State File ---")
+    st_path = state_path()
+    if st_path.exists():
+        try:
+            from leitum.state import load_state
+
+            state = load_state()
+            _ok("state.yaml is valid")
+            if state.last_provider:
+                if config and config.get_provider(state.last_provider) is None:
+                    _warn(f"last_provider '{state.last_provider}' not in current config")
+                    warnings += 1
+                else:
+                    _ok(f"last_provider '{state.last_provider}' exists")
+        except Exception as exc:
+            _warn(f"state.yaml could not be read: {exc}")
+            warnings += 1
+    else:
+        _warn("state.yaml not found (will be created on first run)")
+        warnings += 1
+
+    # 4. ENV variables
+    print("\n--- Environment Variables ---")
+    if config:
+        import os
+
+        from leitum.config.env import _INTERPOLATION_RE
+
+        for p in config.providers:
+            for match in _INTERPOLATION_RE.finditer(p.auth.token):
+                expr = match.group(1)
+                var_name = expr.split(":-")[0].strip()
+                if var_name in os.environ:
+                    _ok(f"Provider '{p.name}': {var_name} is set")
+                else:
+                    _fail(f"Provider '{p.name}': {var_name} is NOT set")
+                    failures += 1
+
+    # 5. Model discovery
+    print("\n--- Model Discovery ---")
+    if config:
+        import httpx
+
+        for p in config.providers:
+            if p.models:
+                _ok(f"Provider '{p.name}': {len(p.models)} models from YAML")
+            else:
+                cache_p = model_cache_path(p.name)
+                if cache_p.exists():
+                    _ok(f"Provider '{p.name}': cache exists at {cache_p}")
+                else:
+                    # Lightweight reachability check
+                    try:
+                        url = p.base_url.rstrip("/")
+                        with httpx.Client(timeout=5) as client:
+                            client.head(url)
+                        _ok(f"Provider '{p.name}': reachable (no cache yet; run 'leitum refresh')")
+                    except Exception as exc:
+                        _warn(f"Provider '{p.name}': no cache and unreachable ({exc})")
+                        warnings += 1
+
+    # 6. Claude binary
+    print("\n--- Claude Binary ---")
+    claude_path = shutil.which("claude")
+    if claude_path is None:
+        _fail(
+            "'claude' not found in PATH. Install from https://docs.claude.com/en/docs/claude-code/quickstart"
+        )
+        failures += 1
+    else:
+        _ok(f"'claude' found at {claude_path}")
+        try:
+            result = subprocess.run(
+                ["claude", "--version"], capture_output=True, text=True, timeout=5
+            )
+            version = (result.stdout or result.stderr).strip()
+            _ok(f"claude version: {version}")
+        except Exception as exc:
+            _warn(f"Could not determine claude version: {exc}")
+            warnings += 1
+
+    # Summary
+    print(f"\n--- Summary: {failures} failure(s), {warnings} warning(s) ---")
+    if failures > 0:
+        raise SystemExit(1)

leitum/commands/init.py

@@ -0,0 +1,30 @@
+"""leitum init command."""
+
+from leitum.config.io import write_empty_state, write_example_providers_config
+from leitum.config.paths import ensure_dirs, providers_config_path, state_path
+
+
+def run_init(force: bool = False, yes: bool = False) -> None:
+    ensure_dirs()
+
+    cfg_path = providers_config_path()
+    if cfg_path.exists() and not force:
+        print(f"Config already exists at {cfg_path}. Use --force to overwrite.")
+    elif cfg_path.exists() and force:
+        if not yes:
+            answer = input(f"Overwrite {cfg_path}? [y/N] ").strip().lower()
+            if answer != "y":
+                print("Aborted.")
+                raise SystemExit(0)
+        write_example_providers_config(cfg_path)
+        print(f"Created {cfg_path}")
+    else:
+        write_example_providers_config(cfg_path)
+        print(f"Created {cfg_path}")
+
+    st_path = state_path()
+    if not st_path.exists():
+        write_empty_state(st_path)
+        print(f"Created {st_path}")
+
+    print("\nSet REQUESTY_API_KEY in your shell and run `leitum claude` to start.")