sync: band-provider from Gitea BAND

band-provider

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""
+band-provider — BAND Provider Switch Tool
+Toggle Claude Code endpoint between providers (manual or auto BAND tier mode).
+
+Protocol: just 2 env vars in ~/.claude/settings.json
+  ANTHROPIC_BASE_URL   → endpoint
+  ANTHROPIC_API_KEY    → key (for OpenClaude, LiteLLM)
+  ANTHROPIC_AUTH_TOKEN → key (for Claudible)
+
+Usage:
+  band-provider status                 # Show current provider + mode
+  band-provider list                   # List all providers
+  band-provider use <provider>         # Switch to provider (manual mode)
+  band-provider off                    # Back to native Anthropic
+  band-provider auto                   # Enable auto mode (BAND tier based)
+  band-provider manual                 # Disable auto mode
+  band-provider tier <T0|T1|T2|T3|T4> # Force specific tier (manual override)
+  band-provider add <name> <url> <key> # Add new provider
+"""
+
+import json
+import os
+import sys
+import shutil
+from pathlib import Path
+from datetime import datetime
+
+# Paths
+CLAUDE_DIR = Path.home() / ".claude"
+SETTINGS = CLAUDE_DIR / "settings.json"
+REGISTRY = CLAUDE_DIR / "providers.json"
+
+# ANSI colors
+R = "\033[0;31m"; G = "\033[0;32m"; Y = "\033[1;33m"
+B = "\033[0;34m"; C = "\033[0;36m"; W = "\033[1;37m"; N = "\033[0m"
+
+BAND_TIERS = {
+    "T0": {"label": "T0 — Local micro (phi3/gemma2)",     "default": "local"},
+    "T1": {"label": "T1 — Local standard (llama3.1/qwen)", "default": "local"},
+    "T2": {"label": "T2 — Free cloud (Groq/Cerebras)",    "default": "local"},
+    "T3": {"label": "T3 — Premium free (Gemini Pro)",     "default": "local"},
+    "T4": {"label": "T4 — Premium paid (Claude Sonnet)",  "default": "claudible"},
+}
+
+def load_registry():
+    if not REGISTRY.exists():
+        print(f"{R}Error: {REGISTRY} not found.{N}")
+        sys.exit(1)
+    with open(REGISTRY) as f:
+        return json.load(f)
+
+def save_registry(reg):
+    with open(REGISTRY, "w") as f:
+        json.dump(reg, f, indent=2)
+
+def load_settings():
+    if not SETTINGS.exists():
+        return {}
+    with open(SETTINGS) as f:
+        try:
+            return json.load(f)
+        except:
+            return {}
+
+def save_settings(s):
+    CLAUDE_DIR.mkdir(exist_ok=True)
+    # Backup
+    if SETTINGS.exists():
+        shutil.copy(SETTINGS, SETTINGS.with_suffix(".json.bak"))
+    with open(SETTINGS, "w") as f:
+        json.dump(s, f, indent=2)
+
+def apply_provider(name, reg):
+    """Write provider credentials into ~/.claude/settings.json"""
+    providers = reg.get("providers", {})
+    if name not in providers and name != "native":
+        print(f"{R}Unknown provider: {name}{N}")
+        print(f"Available: {', '.join(providers.keys())}")
+        sys.exit(1)
+
+    p = providers.get(name, {}) if name != "native" else {}
+    s = load_settings()
+    s.setdefault("env", {})
+
+    # Clear all provider env vars first
+    for k in ["ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN",
+              "ANTHROPIC_DEFAULT_HAIKU_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL",
+              "ANTHROPIC_DEFAULT_OPUS_MODEL"]:
+        s["env"].pop(k, None)
+
+    # Apply new provider
+    if name == "native" or not p.get("base_url"):
+        # Native: just remove custom settings, Claude Code uses default
+        pass
+    else:
+        s["env"]["ANTHROPIC_BASE_URL"] = p["base_url"]
+        if p.get("auth_token"):
+            s["env"]["ANTHROPIC_AUTH_TOKEN"] = p["auth_token"]
+        elif p.get("api_key"):
+            s["env"]["ANTHROPIC_API_KEY"] = p["api_key"]
+
+    # Preserve other settings (permissions, etc.)
+    save_settings(s)
+
+    # Update registry state
+    reg["active"] = name
+    save_registry(reg)
+
+def cmd_status(reg):
+    active = reg.get("active", "native")
+    mode   = reg.get("mode", "manual")
+    p      = reg["providers"].get(active, {})
+
+    print(f"\n{W}BAND Provider Status{N}")
+    print(f"  Mode:     {C}{'AUTO' if mode == 'auto' else 'MANUAL'}{N}")
+    print(f"  Active:   {G}{p.get('label', active)}{N}")
+    if p.get("base_url"):
+        print(f"  Endpoint: {B}{p['base_url']}{N}")
+    else:
+        print(f"  Endpoint: {B}(Anthropic default){N}")
+    if mode == "auto":
+        tm = reg.get("band_tier_auto", {})
+        print(f"\n  BAND Tier → Provider map:")
+        for tier, prov in tm.items():
+            if tier.startswith("_"):
+                continue
+            tp = reg["providers"].get(prov, {})
+            print(f"    {Y}{tier}{N} → {tp.get('label', prov)}")
+    print()
+
+def cmd_list(reg):
+    active = reg.get("active", "native")
+    print(f"\n{W}BAND Providers{N}")
+    for name, p in reg["providers"].items():
+        indicator = f"{G}● ON {N}" if name == active else f"  OFF"
+        print(f"  {indicator}  {W}{name:<12}{N} {p.get('label','')}")
+        if p.get("base_url"):
+            print(f"              {B}{p['base_url']}{N}")
+        print(f"              {p.get('description','')}")
+        print()
+
+def cmd_use(reg, name):
+    apply_provider(name, reg)
+    p = reg["providers"].get(name, {})
+    reg["mode"] = "manual"
+    save_registry(reg)
+    print(f"{G}✓ Switched to: {p.get('label', name)}{N}")
+    if p.get("base_url"):
+        print(f"  Endpoint: {B}{p['base_url']}{N}")
+    print(f"  {Y}Restart claude for changes to take effect.{N}")
+
+def cmd_off(reg):
+    apply_provider("native", reg)
+    reg["mode"] = "manual"
+    save_registry(reg)
+    print(f"{G}✓ Switched to native Anthropic (default){N}")
+    print(f"  {Y}Restart claude for changes to take effect.{N}")
+
+def cmd_auto(reg):
+    reg["mode"] = "auto"
+    save_registry(reg)
+    print(f"{G}✓ Auto mode enabled{N}")
+    print(f"  Tier routing:")
+    tm = reg.get("band_tier_auto", {})
+    for tier, prov in tm.items():
+        if tier.startswith("_"):
+            continue
+        tp = reg["providers"].get(prov, {})
+        info = BAND_TIERS.get(tier, {})
+        print(f"    {Y}{tier}{N}  {info.get('label',''):<40} → {G}{tp.get('label', prov)}{N}")
+    print()
+    # Apply current default (T1/T2 = local)
+    default_prov = tm.get("T2", "local")
+    apply_provider(default_prov, reg)
+    print(f"  Applied default provider: {G}{default_prov}{N}")
+
+def cmd_manual(reg):
+    reg["mode"] = "manual"
+    save_registry(reg)
+    print(f"{G}✓ Manual mode enabled{N}")
+    print(f"  Use: band-provider use <provider>")
+
+def cmd_tier(reg, tier):
+    tier = tier.upper()
+    if tier not in BAND_TIERS:
+        print(f"{R}Unknown tier: {tier}. Valid: T0 T1 T2 T3 T4{N}")
+        sys.exit(1)
+    tm = reg.get("band_tier_auto", {})
+    prov = tm.get(tier, "local")
+    apply_provider(prov, reg)
+    p = reg["providers"].get(prov, {})
+    print(f"{G}✓ Tier {tier} → {p.get('label', prov)}{N}")
+    print(f"  {Y}Restart claude for changes to take effect.{N}")
+
+def cmd_add(reg, name, url, key):
+    reg["providers"][name] = {
+        "label": name,
+        "base_url": url,
+        "api_key": key if not key.startswith("sk-") else None,
+        "auth_token": key if key.startswith("sk-") else None,
+        "description": f"Added {datetime.now().strftime('%Y-%m-%d')}"
+    }
+    save_registry(reg)
+    print(f"{G}✓ Provider '{name}' added{N}")
+    print(f"  Use: band-provider use {name}")
+
+def cmd_help():
+    print(f"""
+{W}band-provider{N} — BAND Provider Switch
+
+{Y}Commands:{N}
+  {G}band-provider status{N}                 Show current provider + mode
+  {G}band-provider list{N}                   List all providers (ON/OFF)
+  {G}band-provider use{N} <provider>         Switch provider (manual mode)
+  {G}band-provider off{N}                    Back to native Anthropic
+  {G}band-provider auto{N}                   Enable auto mode (BAND tier)
+  {G}band-provider manual{N}                 Disable auto mode
+  {G}band-provider tier{N} <T0-T4>           Force tier for this session
+  {G}band-provider add{N} <n> <url> <key>    Register new provider
+
+{Y}Providers:{N}
+  native          Direct Anthropic API (default, login/subscription)
+  native-anthropic  Direct Anthropic API (API key mode)
+  claudible       Claudible.io — Claude proxy
+  openclaude      OpenClaude.com — Claude proxy
+  local           LiteLLM local — all BAND members, soul.md enforced
+
+{Y}Auto mode — BAND tier routing:{N}
+  T0/T1/T2/T3  → local  (free: Groq/Cerebras/HF Spaces)
+  T4           → claudible (paid-quality, alternative billing)
+
+{Y}Protocol:{N}
+  All switching = 2 env vars in ~/.claude/settings.json
+    ANTHROPIC_BASE_URL   → endpoint URL
+    ANTHROPIC_API_KEY    → API key (LiteLLM/OpenClaude/native-anthropic)
+    ANTHROPIC_AUTH_TOKEN → auth token (Claudible)
+""")
+
+def main():
+    args = sys.argv[1:]
+    reg  = load_registry()
+
+    if not args or args[0] in ("-h", "--help", "help"):
+        cmd_help()
+    elif args[0] == "status":
+        cmd_status(reg)
+    elif args[0] == "list":
+        cmd_list(reg)
+    elif args[0] == "use" and len(args) >= 2:
+        cmd_use(reg, args[1])
+    elif args[0] == "off":
+        cmd_off(reg)
+    elif args[0] == "auto":
+        cmd_auto(reg)
+    elif args[0] == "manual":
+        cmd_manual(reg)
+    elif args[0] == "tier" and len(args) >= 2:
+        cmd_tier(reg, args[1])
+    elif args[0] == "add" and len(args) >= 4:
+        cmd_add(reg, args[1], args[2], args[3])
+    else:
+        print(f"{R}Unknown command: {' '.join(args)}{N}")
+        cmd_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()