localcoder 0.1.0__py3-none-any.whl

localcoder/setup.py

@@ -0,0 +1,321 @@
+"""Interactive setup wizard — runs on first launch or `localcoder --setup`."""
+import json, os, sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from localcoder.backends import (
+    BACKENDS, MODELS, CONFIG_DIR, discover_all, get_system_ram_gb,
+    check_backend_installed, install_backend, download_model_hf,
+    download_model_ollama, find_model_file, start_llama_server,
+    start_ollama_serve, check_backend_running,
+)
+
+console = Console()
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def load_config():
+    if CONFIG_FILE.exists():
+        return json.loads(CONFIG_FILE.read_text())
+    return {}
+
+
+def save_config(cfg):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(cfg, indent=2))
+
+
+def wizard():
+    """Interactive first-run setup wizard."""
+    console.print()
+    title = Text()
+    title.append("◆ ", style="bold magenta")
+    title.append("localcoder setup", style="bold white")
+    console.print(Panel(
+        "[bold]Welcome! Let's get your local AI coding agent running.[/]\n"
+        "[dim]This wizard will install a backend, download a model, and start serving.[/]",
+        title=title, title_align="left",
+        border_style="magenta", padding=(1, 2),
+    ))
+
+    ram = get_system_ram_gb()
+    console.print(f"\n  [dim]System RAM:[/] [bold]{ram} GB[/]")
+
+    # ── Step 1: Detect backends ──
+    console.print(f"\n  [bold magenta]Step 1:[/] Checking backends...\n")
+    discovery = discover_all()
+
+    table = Table(show_header=True, header_style="bold cyan", padding=(0, 2))
+    table.add_column("Backend")
+    table.add_column("Installed")
+    table.add_column("Running")
+    table.add_column("Models")
+
+    for d in discovery:
+        installed = "[green]✓[/]" if d["installed"] else "[red]✗[/]"
+        running = f"[green]:{d['port']}[/]" if d["running"] else "[dim]—[/]"
+        models = ", ".join(d["models"][:3]) if d["models"] else "[dim]none[/]"
+        table.add_row(d["name"], installed, running, models)
+
+    console.print(table)
+
+    # ── Step 2: Install backend if needed ──
+    any_installed = any(d["installed"] for d in discovery)
+    if not any_installed:
+        console.print(f"\n  [bold magenta]Step 2:[/] No backend found. Install one:\n")
+        console.print(f"    [bold]1.[/] llama.cpp via Unsloth [dim](recommended for 26B, best speed)[/]")
+        console.print(f"    [bold]2.[/] Ollama [dim](easiest, good for E4B/E2B)[/]")
+        console.print(f"    [bold]3.[/] Both")
+        console.print()
+
+        try:
+            choice = input("  Choose (1/2/3): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            return None
+
+        if choice in ("1", "3"):
+            install_backend("llamacpp")
+        if choice in ("2", "3"):
+            install_backend("ollama")
+
+        # Re-discover
+        discovery = discover_all()
+
+    # ── Step 3: Choose model ──
+    console.print(f"\n  [bold magenta]Step 3:[/] Choose a model:\n")
+
+    recommended = []
+    for mid, m in MODELS.items():
+        fits = ram >= m["ram_required"]
+        rec = " [green](recommended)[/]" if fits and mid == "gemma4-26b" and ram >= 24 else ""
+        if not fits:
+            rec = " [red](needs {m['ram_required']}GB+)[/]"
+        recommended.append((mid, m, fits, rec))
+
+    for i, (mid, m, fits, rec) in enumerate(recommended):
+        style = "bold" if fits else "dim"
+        console.print(f"    [{style}]{i+1}. {m['name']}[/{style}] [dim]({m['size_gb']}GB, {m['description']})[/]{rec}")
+
+    console.print()
+    try:
+        choice = input("  Choose model (1-4): ").strip()
+    except (EOFError, KeyboardInterrupt):
+        return None
+
+    idx = int(choice) - 1 if choice.isdigit() else 0
+    if idx < 0 or idx >= len(recommended):
+        idx = 0
+
+    model_id, model_info, _, _ = recommended[idx]
+    console.print(f"\n  [green]Selected: {model_info['name']}[/]")
+
+    # ── Step 4: Download model ──
+    console.print(f"\n  [bold magenta]Step 4:[/] Downloading model...\n")
+
+    model_file = find_model_file(model_id)
+    if model_file:
+        console.print(f"  [green]✓ Model already downloaded: {os.path.basename(model_file)}[/]")
+    else:
+        if model_info.get("backend") == "llamacpp" and model_info.get("hf_repo"):
+            download_model_hf(model_id)
+        elif model_info.get("ollama_tag"):
+            # Ensure Ollama is running
+            if not check_backend_running("ollama"):
+                start_ollama_serve()
+            download_model_ollama(model_id)
+
+    # ── Step 5: Determine backend + API URL ──
+    backend_id = model_info.get("backend", "ollama")
+    port = BACKENDS[backend_id]["default_port"]
+    api_url = f"http://127.0.0.1:{port}/v1"
+
+    # For llama.cpp models, start the server
+    if backend_id == "llamacpp":
+        if not check_backend_running("llamacpp"):
+            console.print(f"\n  [bold magenta]Step 5:[/] Starting llama-server...\n")
+            proc = start_llama_server(model_id, port)
+            if not proc:
+                console.print(f"  [yellow]Falling back to Ollama...[/]")
+                backend_id = "ollama"
+                port = 11434
+                api_url = f"http://127.0.0.1:{port}/v1"
+                if model_info.get("ollama_tag"):
+                    start_ollama_serve()
+                    download_model_ollama(model_id)
+        else:
+            console.print(f"\n  [green]✓ llama-server already running on :{port}[/]")
+    else:
+        if not check_backend_running("ollama"):
+            console.print(f"\n  [bold magenta]Step 5:[/] Starting Ollama...\n")
+            start_ollama_serve()
+
+    # ── Step 6: Save config ──
+    model_name = model_info.get("ollama_tag", model_id)
+    if backend_id == "llamacpp":
+        # Get actual model name from server
+        from localcoder.backends import get_running_models
+        running = get_running_models("llamacpp")
+        if running:
+            model_name = running[0]
+
+    cfg = {
+        "model": model_name,
+        "api_base": api_url,
+        "backend": backend_id,
+        "model_id": model_id,
+        "setup_complete": True,
+    }
+    save_config(cfg)
+
+    console.print(f"\n  [bold magenta]Step 6:[/] Configuration saved.\n")
+
+    # ── Step 7: Configure OpenCode / OpenClaw (optional) ──
+    console.print(f"  [bold magenta]Step 7:[/] Configure other tools?\n")
+
+    import shutil
+    has_opencode = shutil.which("opencode")
+    has_openclaw = shutil.which("openclaw")
+
+    if has_opencode or has_openclaw:
+        tools_found = []
+        if has_opencode:
+            tools_found.append("OpenCode")
+        if has_openclaw:
+            tools_found.append("OpenClaw")
+        console.print(f"  [green]Found:[/] {', '.join(tools_found)}")
+        console.print(f"  [dim]Auto-configure them to use your local model?[/]")
+        console.print(f"    [bold]1.[/] Yes — configure all [dim](recommended)[/]")
+        console.print(f"    [bold]2.[/] No — skip")
+
+        try:
+            ans = input("\n  Choose (1/2): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            ans = "2"
+
+        if ans == "1":
+            _configure_opencode(api_url, model_name, model_id, model_info)
+            _configure_openclaw(api_url, model_name, model_id, model_info)
+    else:
+        console.print(f"  [dim]No OpenCode or OpenClaw found. Install with:[/]")
+        console.print(f"    [dim]curl -fsSL https://opencode.ai/install | bash[/]")
+        console.print(f"    [dim]brew install openclaw[/]")
+
+    # ── Done ──
+    console.print()
+    console.print(Panel(
+        Text.assemble(
+            ("Setup complete! ", "bold green"),
+            ("Run ", "dim"), ("localcoder", "bold cyan"), (" to start.\n\n", "dim"),
+            ("Model:   ", "dim"), (f"{model_info['name']}\n", "bold cyan"),
+            ("Backend: ", "dim"), (f"{BACKENDS[backend_id]['name']} (:{port})\n", "green"),
+            ("API:     ", "dim"), (f"{api_url}\n", "dim"),
+        ),
+        border_style="green", padding=(1, 2),
+    ))
+
+    return cfg
+
+
+def _configure_opencode(api_url, model_name, model_id, model_info):
+    """Auto-configure OpenCode to use the local model."""
+    import shutil
+    if not shutil.which("opencode"):
+        return
+
+    config_path = Path.home() / ".config/opencode/opencode.json"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Load existing or create new
+    existing = {}
+    if config_path.exists():
+        try:
+            existing = json.loads(config_path.read_text())
+        except:
+            pass
+
+    # Add/update llamacpp provider
+    if "provider" not in existing:
+        existing["provider"] = {}
+
+    existing["provider"]["llamacpp"] = {
+        "name": "llama.cpp (local)",
+        "npm": "@ai-sdk/openai-compatible",
+        "options": {"baseURL": api_url},
+        "models": {
+            model_id: {
+                "name": model_info.get("name", model_name),
+                "tool_call": True,
+                "reasoning": False,
+                "modalities": {"input": ["text", "image"], "output": ["text"]},
+                "limit": {"context": 131072, "output": 8192},
+            }
+        },
+    }
+    existing["$schema"] = "https://opencode.ai/config.json"
+    existing["model"] = f"llamacpp/{model_id}"
+
+    config_path.write_text(json.dumps(existing, indent=2))
+    console.print(f"  [green]✓ OpenCode configured[/] [dim]({config_path})[/]")
+    console.print(f"    [dim]Model: llamacpp/{model_id} → {api_url}[/]")
+
+
+def _configure_openclaw(api_url, model_name, model_id, model_info):
+    """Auto-configure OpenClaw to use the local model."""
+    import shutil
+    if not shutil.which("openclaw"):
+        return
+
+    config_path = Path.home() / ".openclaw/openclaw.json"
+    if not config_path.exists():
+        console.print(f"  [dim]OpenClaw config not found — run 'openclaw' first to initialize[/]")
+        return
+
+    try:
+        cfg = json.loads(config_path.read_text())
+    except:
+        console.print(f"  [yellow]Could not parse OpenClaw config[/]")
+        return
+
+    # Add/update llamacpp provider
+    if "models" not in cfg:
+        cfg["models"] = {"mode": "merge", "providers": {}}
+    if "providers" not in cfg["models"]:
+        cfg["models"]["providers"] = {}
+
+    cfg["models"]["providers"]["llamacpp"] = {
+        "api": "openai-completions",
+        "baseUrl": api_url,
+        "apiKey": "dummy",
+        "models": [{
+            "id": model_name,
+            "name": model_info.get("name", model_name),
+            "reasoning": False,
+            "contextWindow": 131072,
+            "maxTokens": 8192,
+        }],
+    }
+
+    # Set as default model
+    if "agents" not in cfg:
+        cfg["agents"] = {"defaults": {}}
+    if "defaults" not in cfg["agents"]:
+        cfg["agents"]["defaults"] = {}
+    if "model" not in cfg["agents"]["defaults"]:
+        cfg["agents"]["defaults"]["model"] = {}
+    cfg["agents"]["defaults"]["model"]["primary"] = f"llamacpp/{model_name}"
+
+    config_path.write_text(json.dumps(cfg, indent=2))
+    console.print(f"  [green]✓ OpenClaw configured[/] [dim]({config_path})[/]")
+    console.print(f"    [dim]Model: llamacpp/{model_name} → {api_url}[/]")
+
+
+def ensure_setup():
+    """Check if setup is done, run wizard if not."""
+    cfg = load_config()
+    if cfg.get("setup_complete"):
+        return cfg
+    return wizard()

localcoder/tui.py

@@ -0,0 +1,276 @@
+"""localcoder TUI — Textual-based fixed-layout GPU health dashboard."""
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical, Container
+from textual.widgets import Static, Footer, Header, DataTable, LoadingIndicator
+from textual.reactive import reactive
+from textual import work
+
+
+class StatusIndicator(Static):
+    """Top status bar: HEALTHY / DEGRADED / CRITICAL."""
+    status = reactive("scanning")
+
+    def render(self):
+        colors = {
+            "healthy": "green", "degraded": "yellow",
+            "critical": "red", "scanning": "cyan",
+        }
+        c = colors.get(self.status, "dim")
+        return f"[bold {c}] {self.status.upper()} [/]"
+
+
+class GpuBar(Static):
+    """Visual VRAM usage bar."""
+    gpu_alloc = reactive(0)
+    gpu_total = reactive(16384)
+
+    def render(self):
+        pct = min(1.0, self.gpu_alloc / max(1, self.gpu_total))
+        w = 40
+        filled = int(pct * w)
+        color = "green" if pct < 0.7 else "yellow" if pct < 0.9 else "red"
+        bar = f"[{color}]{'█' * filled}[/{color}][dim]{'░' * (w - filled)}[/dim]"
+        return f"  VRAM {bar} {self.gpu_alloc // 1024}/{self.gpu_total // 1024}GB"
+
+
+class InfoCard(Static):
+    """A status card (Compute / KV Cache / Memory)."""
+    DEFAULT_CSS = """
+    InfoCard {
+        width: 1fr;
+        height: auto;
+        min-height: 7;
+        border: solid $primary;
+        padding: 0 1;
+    }
+    """
+
+
+class BottomBar(Static):
+    """Pinned bottom status bar with GPU stats + shortcuts."""
+    DEFAULT_CSS = """
+    BottomBar {
+        dock: bottom;
+        height: 1;
+        background: $surface;
+    }
+    """
+    gpu_text = reactive("")
+
+    def render(self):
+        return self.gpu_text or " GPU --/--  SWAP --  MEM --"
+
+
+class HealthDashboard(App):
+    """GPU Health Dashboard — fixed layout, no scrolling."""
+
+    CSS = """
+    Screen {
+        layout: vertical;
+    }
+    #header-bar {
+        height: 3;
+        padding: 0 1;
+    }
+    #cards-row {
+        height: auto;
+        min-height: 8;
+        max-height: 10;
+    }
+    #vram-bar {
+        height: 2;
+        padding: 0 1;
+    }
+    #procs-panel {
+        height: 1fr;
+        padding: 0 1;
+    }
+    #fixes-panel {
+        height: auto;
+        max-height: 8;
+        padding: 0 1;
+        border: solid $warning;
+    }
+    InfoCard {
+        border: solid $primary;
+        padding: 0 1;
+        width: 1fr;
+    }
+    #status-line {
+        height: 1;
+        dock: top;
+    }
+    DataTable {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("c", "cleanup", "Cleanup"),
+        ("d", "debloat", "Debloat"),
+        ("s", "simulate", "Simulate"),
+        ("r", "refresh", "Refresh"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield StatusIndicator(id="status-line")
+        yield Static(id="header-bar")
+
+        with Horizontal(id="cards-row"):
+            yield InfoCard(id="card-compute")
+            yield InfoCard(id="card-kv")
+            yield InfoCard(id="card-mem")
+
+        yield GpuBar(id="vram-bar")
+
+        yield Container(
+            DataTable(id="proc-table"),
+            id="procs-panel",
+        )
+
+        yield Static(id="fixes-panel")
+        yield BottomBar(id="bottom-bar")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Start loading data."""
+        self.load_data()
+
+    @work(thread=True)
+    def load_data(self) -> None:
+        """Load GPU data in background thread."""
+        from localcoder.backends import (
+            get_machine_specs, diagnose_gpu_health, get_metal_gpu_stats,
+            get_top_memory_processes, get_swap_usage_mb, _detect_model_info,
+        )
+
+        specs = get_machine_specs()
+        diag = diagnose_gpu_health()
+        metal = get_metal_gpu_stats()
+        procs = get_top_memory_processes(min_mb=80, limit=8)
+        swap_mb = get_swap_usage_mb()
+        model_info = _detect_model_info(diag["server_config"], None)
+
+        # Update UI from worker thread
+        self.call_from_thread(self._update_ui, specs, diag, metal, procs, swap_mb, model_info)
+
+    def _update_ui(self, specs, diag, metal, procs, swap_mb, model_info):
+        """Update all widgets with loaded data."""
+        # Status
+        status = self.query_one("#status-line", StatusIndicator)
+        status.status = diag["status"]
+
+        # Header
+        header = self.query_one("#header-bar", Static)
+        model_str = ""
+        if model_info["name"]:
+            parts = [model_info["name"]]
+            if model_info["quant"]:
+                parts.append(model_info["quant"])
+            if model_info["size_gb"]:
+                parts.append(f"{model_info['size_gb']}GB")
+            model_str = f"\n  [cyan]{'  ·  '.join(parts)}[/cyan]"
+        header.update(
+            f"  [bold]{specs['chip']}[/bold]  ·  {specs['ram_gb']}GB RAM  ·  "
+            f"{specs.get('gpu_cores', '?')} GPU cores{model_str}"
+        )
+
+        # Compute card
+        srv = diag["server_config"]
+        if srv.get("running"):
+            gpu_icon = "[green]●[/] GPU (Metal)" if diag["on_gpu"] else "[red]●[/] CPU — SLOW"
+            compute = (
+                f"[bold]Compute[/bold]\n"
+                f"{gpu_icon}\n"
+                f"Layers: {diag['gpu_layers']}/99\n"
+                f"Util: {diag['gpu_util_pct']}%\n"
+                f"Model: {srv.get('footprint_mb', 0)} MB"
+            )
+        else:
+            compute = "[bold]Compute[/bold]\n[dim]Server not running[/dim]"
+        self.query_one("#card-compute", InfoCard).update(compute)
+
+        # KV Cache card
+        kv_icon = "[green]●[/]" if diag["kv_quantized"] else "[red]●[/]"
+        kv_type = f"Type: {diag['kv_type']}\n" if diag["kv_type"] else ""
+        fa_icon = "[green]●[/]" if diag["flash_attn"] else "[yellow]●[/]"
+        self.query_one("#card-kv", InfoCard).update(
+            f"[bold]KV Cache[/bold]\n"
+            f"{kv_icon} {'Quantized' if diag['kv_quantized'] else 'Full (2x mem!)'}\n"
+            f"{kv_type}"
+            f"Size: ~{diag['kv_cache_est_mb']} MB\n"
+            f"Ctx: {diag['context_size'] // 1024}K\n"
+            f"{fa_icon} FlashAttn: {'on' if diag['flash_attn'] else 'off'}"
+        )
+
+        # Memory card
+        pc = {"normal": "green", "warn": "yellow", "critical": "red"}.get(diag["mem_pressure"], "dim")
+        sc = "red" if swap_mb > 4000 else "green"
+        headroom = diag["gpu_total_mb"] - diag["gpu_alloc_mb"]
+        hc = "green" if headroom > 2048 else "yellow" if headroom > 0 else "red"
+        self.query_one("#card-mem", InfoCard).update(
+            f"[bold]Memory[/bold]\n"
+            f"Pressure: [{pc}]{diag['mem_pressure']}[/{pc}]\n"
+            f"Swap: [{sc}]{swap_mb // 1024}GB[/{sc}]\n"
+            f"GPU: {diag['gpu_alloc_mb'] // 1024}/{diag['gpu_total_mb'] // 1024}GB\n"
+            f"Free: [{hc}]{headroom // 1024}GB[/{hc}]"
+        )
+
+        # VRAM bar
+        vram = self.query_one("#vram-bar", GpuBar)
+        vram.gpu_alloc = diag["gpu_alloc_mb"]
+        vram.gpu_total = diag["gpu_total_mb"]
+
+        # Process table
+        table = self.query_one("#proc-table", DataTable)
+        table.clear(columns=True)
+        table.add_columns("#", "Process", "Memory", "Type")
+        for i, p in enumerate(procs, 1):
+            mb = p["mb"]
+            size = f"{mb / 1024:.1f}G" if mb >= 1024 else f"{mb}M"
+            cat = {"ml": "ML", "app": "app", "system": "sys", "bloat": "bloat"}.get(p["category"], "?")
+            name = p["name"] + (f" ×{p['count']}" if p.get("count", 1) > 1 else "")
+            table.add_row(str(i), name, size, cat)
+
+        # Fixes
+        fixes = self.query_one("#fixes-panel", Static)
+        if diag["issues"]:
+            lines = []
+            for issue in diag["issues"]:
+                lines.append(f"[red]●[/] {issue}")
+            for fix in diag.get("fixes", []):
+                lines.append(f"[green]→[/] {fix}")
+            fixes.update("\n".join(lines))
+        else:
+            fixes.update("[green]All good — no issues detected[/]")
+
+        # Bottom bar
+        bar = self.query_one("#bottom-bar", BottomBar)
+        gc = "red" if diag["gpu_alloc_mb"] > diag["gpu_total_mb"] else "green"
+        bar.gpu_text = (
+            f" GPU [{gc}]{diag['gpu_alloc_mb'] // 1024}/{diag['gpu_total_mb'] // 1024}GB[/{gc}]"
+            f"  SWAP [{sc}]{swap_mb // 1024}GB[/{sc}]"
+            f"  MEM [{pc}]{diag['mem_pressure']}[/{pc}]"
+        )
+
+    def action_refresh(self) -> None:
+        status = self.query_one("#status-line", StatusIndicator)
+        status.status = "scanning"
+        self.load_data()
+
+    def action_cleanup(self) -> None:
+        self.exit(return_code=10)  # Signal to CLI to run cleanup
+
+    def action_debloat(self) -> None:
+        self.exit(return_code=11)
+
+    def action_simulate(self) -> None:
+        self.exit(return_code=12)
+
+
+def run_tui_dashboard():
+    """Launch the Textual TUI dashboard."""
+    app = HealthDashboard()
+    result = app.run()
+    return result