llmcode-cli 1.0.0__py3-none-any.whl

llm_code/cli/streaming.py

@@ -0,0 +1,92 @@
+"""Incremental Markdown renderer for streaming LLM output."""
+from __future__ import annotations
+
+import re
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.syntax import Syntax
+
+_CODE_BLOCK_RE = re.compile(r"^```(\w*)\n(.*?)```\s*$", re.DOTALL)
+
+
+class IncrementalMarkdownRenderer:
+    """Renders streaming token output incrementally using Rich.
+
+    Strategy:
+    - Accumulate tokens in a buffer.
+    - After each feed, attempt to flush completed blocks:
+        * Code block: text between opening ``` and closing ```.
+        * Paragraph / heading / list: text terminated by \\n\\n.
+    - finish() flushes whatever remains.
+    """
+
+    def __init__(self, console: Console) -> None:
+        self._console = console
+        self._buffer = ""
+        self._in_code_block = False
+
+    def feed(self, token: str) -> None:
+        """Accumulate a token and try to flush completed blocks."""
+        self._buffer += token
+        self._try_flush()
+
+    def finish(self) -> None:
+        """Flush all remaining buffered content."""
+        if self._buffer.strip():
+            self._render_block(self._buffer)
+        self._buffer = ""
+        self._in_code_block = False
+
+    def _try_flush(self) -> None:
+        """Detect and render complete blocks from the buffer."""
+        while True:
+            if self._in_code_block:
+                # Look for closing ```
+                close_idx = self._buffer.find("```", 3)  # skip opening ```
+                if close_idx == -1:
+                    break  # code block not yet closed
+                # Include everything up to and including the closing ```
+                end = close_idx + 3
+                # Consume optional trailing newlines
+                while end < len(self._buffer) and self._buffer[end] in ("\n",):
+                    end += 1
+                block = self._buffer[:end]
+                self._buffer = self._buffer[end:]
+                self._in_code_block = False
+                self._render_block(block)
+            else:
+                # Check if we're entering a code block
+                if self._buffer.startswith("```"):
+                    self._in_code_block = True
+                    continue  # re-check with in_code_block=True
+
+                # Look for paragraph boundary (\n\n)
+                para_idx = self._buffer.find("\n\n")
+                if para_idx == -1:
+                    break  # no complete paragraph yet
+
+                block = self._buffer[: para_idx + 2]
+                self._buffer = self._buffer[para_idx + 2 :]
+
+                # After consuming a paragraph, the remainder might start a code block
+                if self._buffer.startswith("```"):
+                    self._in_code_block = True
+
+                stripped = block.strip()
+                if stripped:
+                    self._render_block(stripped)
+
+    def _render_block(self, block: str) -> None:
+        """Render a single block — code block as Syntax, else as Markdown."""
+        stripped = block.strip()
+        if not stripped:
+            return
+
+        m = _CODE_BLOCK_RE.match(stripped)
+        if m:
+            lang = m.group(1) or "text"
+            code = m.group(2)
+            self._console.print(Syntax(code, lang, theme="monokai"))
+        else:
+            self._console.print(Markdown(stripped))

llm_code/cli/tui_main.py

@@ -0,0 +1,220 @@
+"""Entry point for llm-code."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import click
+
+_PERMISSION_CHOICES = ["prompt", "auto_accept", "read_only", "workspace_write", "full_access"]
+
+
+@click.command()
+@click.argument("prompt", required=False)
+@click.option("--model", "-m", default=None, help="Model name to use")
+@click.option("--api", default=None, help="API base URL")
+@click.option("--api-key", default=None, help="API key (or set LLM_API_KEY env var)")
+@click.option("--provider", type=click.Choice(["ollama"]), default=None, help="LLM provider shortcut")
+@click.option(
+    "--permission",
+    type=click.Choice(_PERMISSION_CHOICES),
+    default=None,
+    help="Permission mode",
+)
+@click.option("--budget", type=int, default=None, help="Token budget target")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+@click.option("--serve", is_flag=True, help="Start as remote server")
+@click.option("--port", type=int, default=8765, help="Server port (for --serve)")
+@click.option("--connect", default=None, help="Connect to remote server (host:port)")
+@click.option("--ssh", default=None, help="SSH to remote host and connect (user@host)")
+@click.option("--replay", default=None, help="Replay a VCR recording file (.jsonl)")
+@click.option("--replay-speed", type=float, default=1.0, help="Playback speed for --replay (0 = instant)")
+@click.option("--resume", default=None, help="Resume from a checkpoint (session_id or 'last')")
+def main(
+    prompt: str | None,
+    model: str | None,
+    api: str | None,
+    api_key: str | None,
+    provider: str | None,
+    permission: str | None,
+    budget: int | None,
+    verbose: bool = False,
+    serve: bool = False,
+    port: int = 8765,
+    connect: str | None = None,
+    ssh: str | None = None,
+    replay: str | None = None,
+    replay_speed: float = 1.0,
+    resume: str | None = None,
+) -> None:
+    """llm-code: AI coding assistant CLI."""
+    from llm_code.logging import setup_logging
+    from llm_code.runtime.config import load_config
+
+    setup_logging(verbose=verbose)
+    cwd = Path.cwd()
+
+    # Build CLI overrides
+    cli_overrides: dict = {}
+    if model:
+        cli_overrides["model"] = model
+    if api:
+        cli_overrides.setdefault("provider", {})["base_url"] = api
+    if api_key:
+        os.environ["LLM_API_KEY"] = api_key
+    if permission:
+        cli_overrides.setdefault("permissions", {})["mode"] = permission
+
+    # Ollama provider setup
+    if provider == "ollama":
+        ollama_result = _run_ollama_setup(
+            api_override=api,
+            model_override=model,
+        )
+        if ollama_result is None:
+            click.echo("Error: Cannot connect to Ollama at localhost:11434", err=True)
+            click.echo("Make sure Ollama is running: ollama serve", err=True)
+            raise SystemExit(1)
+        selected_model, base_url = ollama_result
+        cli_overrides["model"] = selected_model
+        cli_overrides.setdefault("provider", {})["base_url"] = base_url
+
+    user_dir = Path.home() / ".llm-code"
+    config = load_config(
+        user_dir=user_dir,
+        project_dir=cwd,
+        local_path=cwd / ".llm-code" / "config.json",
+        cli_overrides=cli_overrides,
+    )
+
+    import asyncio
+
+    if replay:
+        from llm_code.runtime.vcr import VCRPlayer
+        player = VCRPlayer(Path(replay))
+        summary = player.summary()
+        print(f"Replaying: {replay}")
+        print(f"  events={summary['event_count']}  duration={summary['duration']:.1f}s")
+        print()
+        for event in player.replay(speed=replay_speed):
+            print(f"[{event.type:15s}] {event.data}")
+        return
+
+    if serve:
+        from llm_code.remote.server import RemoteServer
+        server = RemoteServer(host="0.0.0.0", port=port, config=config)
+        asyncio.run(server.start())
+        return
+
+    if connect:
+        from llm_code.remote.client import RemoteClient
+        client = RemoteClient(connect)
+        asyncio.run(client.connect())
+        return
+
+    if ssh:
+        from llm_code.remote.ssh_proxy import ssh_connect
+        asyncio.run(ssh_connect(ssh, port=port))
+        return
+
+    # Resolve resume session if requested
+    resume_session = None
+    if resume:
+        from llm_code.runtime.checkpoint_recovery import CheckpointRecovery
+        checkpoints_dir = Path.home() / ".llm-code" / "checkpoints"
+        recovery = CheckpointRecovery(checkpoints_dir)
+        if resume == "last":
+            resume_session = recovery.detect_last_checkpoint()
+        else:
+            resume_session = recovery.load_checkpoint(resume)
+        if resume_session is None:
+            print(f"[warning] No checkpoint found for: {resume}")
+        else:
+            print(f"Resuming session {resume_session.id} ({len(resume_session.messages)} messages)")
+
+    # Textual fullscreen TUI (default and only UI mode)
+    from llm_code.tui.app import LLMCodeTUI
+    app = LLMCodeTUI(config=config, cwd=cwd, budget=budget)
+    app.run()
+
+
+_OLLAMA_DEFAULT_URL = "http://localhost:11434"
+
+
+def _run_ollama_setup(
+    api_override: str | None = None,
+    model_override: str | None = None,
+) -> tuple[str, str] | None:
+    """Probe Ollama, optionally select model. Returns (model, base_url) or None."""
+    import asyncio as _asyncio
+
+    base_url = api_override or _OLLAMA_DEFAULT_URL
+
+    async def _setup() -> tuple[str, str] | None:
+        from llm_code.runtime.ollama import OllamaClient, sort_models_for_selection
+        from llm_code.runtime.hardware import detect_vram_gb
+
+        client = OllamaClient(base_url=base_url)
+        try:
+            if not await client.probe():
+                return None
+
+            if model_override:
+                return (model_override, f"{base_url}/v1")
+
+            models = await client.list_models()
+            if not models:
+                click.echo("No models found in Ollama. Download one first:", err=True)
+                click.echo("  ollama pull qwen3:1.7b", err=True)
+                return None
+
+            if len(models) == 1:
+                click.echo(f"Using Ollama model: {models[0].name}")
+                return (models[0].name, f"{base_url}/v1")
+
+            vram_gb = detect_vram_gb()
+            sorted_models = sort_models_for_selection(models, vram_gb)
+            output = _format_model_list(sorted_models, vram_gb)
+            click.echo(output)
+
+            choice = click.prompt("Select model", default="1")
+            try:
+                idx = int(choice) - 1
+                if 0 <= idx < len(sorted_models):
+                    selected = sorted_models[idx]
+                else:
+                    selected = sorted_models[0]
+            except ValueError:
+                selected = sorted_models[0]
+
+            click.echo(f"Using: {selected.name}")
+            return (selected.name, f"{base_url}/v1")
+        finally:
+            await client.close()
+
+    return _asyncio.run(_setup())
+
+
+def _format_model_list(
+    models: list,
+    vram_gb: float | None,
+) -> str:
+    """Format models as a numbered list with VRAM annotations."""
+    lines = ["\nAvailable Ollama models:\n"]
+
+    for i, model in enumerate(models, 1):
+        size_str = f"~{model.estimated_vram_gb:.0f}GB"
+        prefix = "  "
+        suffix = ""
+
+        if vram_gb is not None:
+            if model.is_recommended(vram_gb):
+                prefix = "★ "
+                suffix = "  Recommended"
+            elif not model.fits_in_vram(vram_gb):
+                suffix = " ⚠️ May exceed available VRAM"
+
+        lines.append(f"  {prefix}{i}) {model.name:<20s} ({size_str}){suffix}")
+
+    lines.append("")
+    return "\n".join(lines)

llm_code/computer_use/__init__.py

@@ -0,0 +1,11 @@
+"""Computer use — GUI automation for llm-code."""
+
+
+def is_available() -> bool:
+    """Return True if pyautogui and Pillow are importable."""
+    try:
+        import pyautogui  # noqa: F401
+        import PIL  # noqa: F401
+        return True
+    except ImportError:
+        return False

llm_code/computer_use/app_detect.py

@@ -0,0 +1,49 @@
+"""Detect the frontmost application on macOS."""
+from __future__ import annotations
+
+import asyncio
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class AppInfo:
+    """Information about a running application."""
+    name: str
+    bundle_id: str
+    pid: int
+
+
+def _get_via_osascript() -> AppInfo:
+    """Use osascript to get frontmost app info."""
+    script = (
+        'tell application "System Events" to '
+        'set fp to first process whose frontmost is true\n'
+        'set n to name of fp\n'
+        'set b to bundle identifier of fp\n'
+        'set p to unix id of fp\n'
+        'return n & "|" & b & "|" & (p as text)'
+    )
+    result = subprocess.run(
+        ["osascript", "-e", script],
+        capture_output=True, text=True, timeout=5,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"osascript failed: {result.stderr}")
+    parts = result.stdout.strip().split("|")
+    if len(parts) < 3:
+        raise RuntimeError(f"Unexpected osascript output: {result.stdout}")
+    return AppInfo(name=parts[0], bundle_id=parts[1], pid=int(parts[2]))
+
+
+def get_frontmost_app_sync() -> AppInfo:
+    """Get frontmost app, with fallback to Unknown on any error."""
+    try:
+        return _get_via_osascript()
+    except Exception:
+        return AppInfo(name="Unknown", bundle_id="", pid=0)
+
+
+async def get_frontmost_app() -> AppInfo:
+    """Async wrapper for get_frontmost_app_sync."""
+    return await asyncio.to_thread(get_frontmost_app_sync)

llm_code/computer_use/app_tier.py

@@ -0,0 +1,57 @@
+"""App-aware tier classification and permission enforcement for computer use."""
+from __future__ import annotations
+
+import fnmatch
+from dataclasses import dataclass
+
+from llm_code.computer_use.app_detect import AppInfo
+
+
+@dataclass(frozen=True)
+class AppTierRule:
+    """Maps a bundle_id glob pattern to a tier."""
+    pattern: str
+    tier: str
+
+
+DEFAULT_RULES: tuple[AppTierRule, ...] = (
+    AppTierRule("com.apple.Safari*", "read"),
+    AppTierRule("com.google.Chrome*", "read"),
+    AppTierRule("org.mozilla.firefox*", "read"),
+    AppTierRule("company.thebrowser.Browser*", "read"),
+    AppTierRule("com.microsoft.edgemac*", "read"),
+    AppTierRule("com.apple.Terminal*", "click"),
+    AppTierRule("com.googlecode.iterm2*", "click"),
+    AppTierRule("com.microsoft.VSCode*", "click"),
+    AppTierRule("com.jetbrains.*", "click"),
+)
+
+
+TIER_PERMISSIONS: dict[str, frozenset[str]] = {
+    "read": frozenset({"screenshot", "get_frontmost_app"}),
+    "click": frozenset({"screenshot", "get_frontmost_app", "left_click", "scroll"}),
+    "full": frozenset({
+        "screenshot", "get_frontmost_app", "left_click", "right_click",
+        "double_click", "drag", "scroll", "type", "key", "hotkey",
+    }),
+}
+
+
+class AppTierDenied(Exception):
+    def __init__(self, app: str, tier: str, action: str, hint: str = "") -> None:
+        self.app = app
+        self.tier = tier
+        self.action = action
+        self.hint = hint
+        super().__init__(f"Action '{action}' denied for app '{app}' (tier='{tier}'). {hint}")
+
+
+@dataclass(frozen=True)
+class AppTierClassifier:
+    rules: tuple[AppTierRule, ...]
+
+    def classify(self, app: AppInfo) -> str:
+        for rule in self.rules:
+            if fnmatch.fnmatch(app.bundle_id, rule.pattern):
+                return rule.tier
+        return "full"

llm_code/computer_use/coordinator.py

@@ -0,0 +1,99 @@
+"""Coordinator that composes screenshot + input for tool actions."""
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from llm_code.runtime.config import ComputerUseConfig
+
+from llm_code.computer_use.app_detect import get_frontmost_app_sync
+from llm_code.computer_use.app_tier import (
+    DEFAULT_RULES,
+    TIER_PERMISSIONS,
+    AppTierClassifier,
+    AppTierDenied,
+    AppTierRule,
+)
+from llm_code.computer_use.input_control import (
+    keyboard_hotkey,
+    keyboard_type,
+    mouse_click,
+    mouse_drag,
+    scroll,
+)
+from llm_code.computer_use.screenshot import take_screenshot_base64
+
+
+class ComputerUseCoordinator:
+    """Orchestrates GUI actions with follow-up screenshots and app-aware tier enforcement."""
+
+    def __init__(self, config: "ComputerUseConfig") -> None:
+        self._config = config
+        user_rules = tuple(
+            AppTierRule(pattern=r["pattern"], tier=r["tier"])
+            for r in self._config.app_tiers
+            if isinstance(r, dict) and "pattern" in r and "tier" in r
+        )
+        self._classifier = AppTierClassifier(rules=user_rules + DEFAULT_RULES)
+
+    def _ensure_enabled(self) -> None:
+        if not self._config.enabled:
+            raise RuntimeError("Computer use is not enabled. Set computer_use.enabled=true in config.")
+
+    def _check_tier(self, action: str) -> None:
+        app = get_frontmost_app_sync()
+        tier = self._classifier.classify(app)
+        if action not in TIER_PERMISSIONS[tier]:
+            hint = ""
+            if tier == "read":
+                hint = "Use MCP browser tools (chrome-devtools) instead."
+            elif tier == "click" and action in ("type", "key", "hotkey"):
+                hint = "Use the Bash tool instead for terminal input."
+            raise AppTierDenied(app=app.name, tier=tier, action=action, hint=hint)
+
+    def _delay_then_screenshot(self) -> str:
+        if self._config.screenshot_delay > 0:
+            time.sleep(self._config.screenshot_delay)
+        return take_screenshot_base64()
+
+    def screenshot(self) -> dict:
+        self._ensure_enabled()
+        self._check_tier("screenshot")
+        img = self._delay_then_screenshot()
+        return {"screenshot_base64": img}
+
+    def click_and_observe(self, x: int, y: int, button: str = "left") -> dict:
+        self._ensure_enabled()
+        self._check_tier("left_click")
+        mouse_click(x, y, button=button)
+        img = self._delay_then_screenshot()
+        return {"action": "click", "x": x, "y": y, "button": button, "screenshot_base64": img}
+
+    def type_and_observe(self, text: str) -> dict:
+        self._ensure_enabled()
+        self._check_tier("type")
+        keyboard_type(text)
+        img = self._delay_then_screenshot()
+        return {"action": "type", "text": text, "screenshot_base64": img}
+
+    def hotkey_and_observe(self, *keys: str) -> dict:
+        self._ensure_enabled()
+        self._check_tier("hotkey")
+        keyboard_hotkey(*keys)
+        img = self._delay_then_screenshot()
+        return {"action": "hotkey", "keys": list(keys), "screenshot_base64": img}
+
+    def scroll_and_observe(self, clicks: int, x: int | None = None, y: int | None = None) -> dict:
+        self._ensure_enabled()
+        self._check_tier("scroll")
+        scroll(clicks, x=x, y=y)
+        img = self._delay_then_screenshot()
+        return {"action": "scroll", "clicks": clicks, "screenshot_base64": img}
+
+    def drag_and_observe(self, start_x: int, start_y: int, offset_x: int, offset_y: int, duration: float = 0.5) -> dict:
+        self._ensure_enabled()
+        self._check_tier("drag")
+        mouse_drag(start_x, start_y, offset_x, offset_y, duration=duration)
+        img = self._delay_then_screenshot()
+        return {"action": "drag", "start_x": start_x, "start_y": start_y, "offset_x": offset_x, "offset_y": offset_y, "screenshot_base64": img}

llm_code/computer_use/input_control.py

@@ -0,0 +1,71 @@
+"""Mouse and keyboard control via pyautogui (lazy import)."""
+from __future__ import annotations
+
+_DEFAULT_DELAY = 0.05  # 50ms between actions
+
+
+def _get_pyautogui():
+    """Lazy import pyautogui with clear error on missing dep."""
+    try:
+        import pyautogui
+        return pyautogui
+    except ImportError as exc:
+        raise RuntimeError(
+            "pyautogui is required for input control. "
+            "Install with: pip install llm-code[computer-use]"
+        ) from exc
+
+
+def mouse_move(x: int, y: int) -> None:
+    """Move mouse cursor to (x, y)."""
+    pag = _get_pyautogui()
+    pag.moveTo(x, y, duration=_DEFAULT_DELAY)
+
+
+def mouse_click(x: int, y: int, button: str = "left") -> None:
+    """Click at (x, y) with the given button."""
+    pag = _get_pyautogui()
+    pag.click(x, y, button=button)
+
+
+def mouse_double_click(x: int, y: int) -> None:
+    """Double-click at (x, y)."""
+    pag = _get_pyautogui()
+    pag.doubleClick(x, y)
+
+
+def mouse_drag(
+    start_x: int,
+    start_y: int,
+    offset_x: int,
+    offset_y: int,
+    duration: float = 0.5,
+    button: str = "left",
+) -> None:
+    """Drag from (start_x, start_y) by (offset_x, offset_y)."""
+    pag = _get_pyautogui()
+    pag.moveTo(start_x, start_y, duration=_DEFAULT_DELAY)
+    pag.drag(offset_x, offset_y, duration=duration, button=button)
+
+
+def keyboard_type(text: str) -> None:
+    """Type the given text string character by character."""
+    pag = _get_pyautogui()
+    pag.typewrite(text, interval=_DEFAULT_DELAY)
+
+
+def keyboard_hotkey(*keys: str) -> None:
+    """Press a keyboard shortcut (e.g., keyboard_hotkey('ctrl', 'c'))."""
+    pag = _get_pyautogui()
+    pag.hotkey(*keys)
+
+
+def scroll(clicks: int, x: int | None = None, y: int | None = None) -> None:
+    """Scroll the mouse wheel. Positive = up, negative = down."""
+    pag = _get_pyautogui()
+    kwargs: dict = {}
+    if x is not None:
+        kwargs["x"] = x
+    if y is not None:
+        kwargs["y"] = y
+    pag.scroll(clicks, **kwargs)

llm_code/computer_use/screenshot.py

@@ -0,0 +1,93 @@
+"""Cross-platform screenshot capture."""
+from __future__ import annotations
+
+import base64
+import platform
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Tuple
+
+
+def take_screenshot(region: Tuple[int, int, int, int] | None = None) -> bytes:
+    """Capture the screen and return raw PNG bytes.
+
+    Args:
+        region: Optional (x, y, width, height) crop region.
+
+    Returns:
+        PNG image bytes.
+
+    Platform strategy:
+        macOS  -> screencapture CLI
+        Linux  -> scrot CLI
+        Windows -> mss library (lazy import)
+    """
+    system = platform.system()
+
+    if system == "Darwin":
+        return _capture_macos(region)
+    elif system == "Linux":
+        return _capture_linux(region)
+    elif system == "Windows":
+        return _capture_windows(region)
+    else:
+        raise RuntimeError(f"Unsupported platform for screenshots: {system}")
+
+
+def take_screenshot_base64(region: Tuple[int, int, int, int] | None = None) -> str:
+    """Capture screen and return as a base64-encoded string."""
+    raw = take_screenshot(region)
+    return base64.b64encode(raw).decode("ascii")
+
+
+def _capture_macos(region: Tuple[int, int, int, int] | None) -> bytes:
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+        tmp_path = tmp.name
+
+    cmd = ["screencapture", "-x"]
+    if region:
+        x, y, w, h = region
+        cmd.extend(["-R", f"{x},{y},{w},{h}"])
+    cmd.append(tmp_path)
+
+    subprocess.run(cmd, check=True, timeout=10)
+    data = Path(tmp_path).read_bytes()
+    Path(tmp_path).unlink(missing_ok=True)
+    return data
+
+
+def _capture_linux(region: Tuple[int, int, int, int] | None) -> bytes:
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+        tmp_path = tmp.name
+
+    cmd = ["scrot"]
+    if region:
+        x, y, w, h = region
+        cmd.extend(["-a", f"{x},{y},{w},{h}"])
+    cmd.append(tmp_path)
+
+    subprocess.run(cmd, check=True, timeout=10)
+    data = Path(tmp_path).read_bytes()
+    Path(tmp_path).unlink(missing_ok=True)
+    return data
+
+
+def _capture_windows(region: Tuple[int, int, int, int] | None) -> bytes:
+    try:
+        import mss
+        import mss.tools
+    except ImportError as exc:
+        raise RuntimeError(
+            "mss is required for Windows screenshots. "
+            "Install with: pip install llm-code[computer-use]"
+        ) from exc
+
+    with mss.mss() as sct:
+        if region:
+            x, y, w, h = region
+            monitor = {"top": y, "left": x, "width": w, "height": h}
+        else:
+            monitor = sct.monitors[1]  # Primary monitor
+        img = sct.grab(monitor)
+        return mss.tools.to_png(img.rgb, img.size)