llmcode-cli 1.0.0__py3-none-any.whl

llm_code/mcp/types.py

@@ -0,0 +1,53 @@
+"""MCP protocol types as frozen dataclasses."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class McpServerConfig:
+    """Configuration for connecting to an MCP server."""
+
+    command: str | None = None
+    args: tuple[str, ...] = ()
+    env: dict[str, str] | None = None
+    transport_type: str = "stdio"
+    url: str | None = None
+    headers: dict[str, str] | None = None
+
+
+@dataclass(frozen=True)
+class McpToolDefinition:
+    """Definition of a tool exposed by an MCP server."""
+
+    name: str
+    description: str
+    input_schema: dict
+    annotations: dict | None = None
+
+
+@dataclass(frozen=True)
+class McpToolResult:
+    """Result returned from calling an MCP tool."""
+
+    content: str
+    is_error: bool = False
+
+
+@dataclass(frozen=True)
+class McpResource:
+    """A resource exposed by an MCP server."""
+
+    uri: str
+    name: str
+    description: str | None = None
+    mime_type: str | None = None
+
+
+@dataclass(frozen=True)
+class McpServerInfo:
+    """Information about an MCP server returned during initialization."""
+
+    name: str
+    version: str
+    capabilities: dict

llm_code/remote/client.py

@@ -0,0 +1,136 @@
+"""Remote client — connects to a remote llm-code server, renders UI locally."""
+from __future__ import annotations
+
+import asyncio
+import json
+
+import websockets
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+console = Console()
+
+
+class RemoteClient:
+    def __init__(self, url: str):
+        self._url = url if url.startswith("ws") else f"ws://{url}"
+        self._ws = None
+
+    async def connect(self) -> None:
+        """Connect to remote server and start UI."""
+        console.print(f"[dim]Connecting to {self._url}...[/]")
+
+        try:
+            async with websockets.connect(self._url) as ws:
+                self._ws = ws
+                console.print("[green]✓ Connected[/]")
+
+                # Start reading server events in background
+                recv_task = asyncio.create_task(self._recv_loop(ws))
+
+                # Input loop
+                from prompt_toolkit import PromptSession
+                from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+                session = PromptSession(auto_suggest=AutoSuggestFromHistory())
+
+                while True:
+                    try:
+                        user_input = await session.prompt_async("❯ ")
+                    except (EOFError, KeyboardInterrupt):
+                        console.print("\n[dim]Disconnecting...[/]")
+                        break
+
+                    user_input = user_input.strip()
+                    if not user_input:
+                        continue
+
+                    if user_input in ("/exit", "/quit"):
+                        break
+
+                    await ws.send(json.dumps({"type": "user_input", "text": user_input}))
+
+                recv_task.cancel()
+
+        except ConnectionRefusedError:
+            console.print(f"[red]Cannot connect to {self._url}[/]")
+        except Exception as exc:
+            console.print(f"[red]Connection error: {exc}[/]")
+
+    async def _recv_loop(self, ws) -> None:
+        """Receive and render server events."""
+        try:
+            async for raw in ws:
+                msg = json.loads(raw)
+                self._render_event(msg)
+        except asyncio.CancelledError:
+            pass
+        except websockets.ConnectionClosed:
+            console.print("[dim]Server disconnected.[/]")
+
+    def _render_event(self, msg: dict) -> None:
+        """Render a server event — same format as Ink IPC protocol."""
+        msg_type = msg.get("type", "")
+
+        if msg_type == "welcome":
+            console.print()
+            console.print("  [bold cyan]╭──────────────╮[/]")
+            console.print("  [bold cyan]│   llm-code   │[/]  [dim](remote)[/]")
+            console.print("  [bold cyan]╰──────────────╯[/]")
+            console.print(f"  [yellow]Model         [/] {msg.get('model', '')}")
+            console.print(f"  [yellow]Directory     [/] {msg.get('cwd', '')}")
+            console.print(f"  [yellow]Server        [/] {self._url}")
+            console.print()
+
+        elif msg_type == "user_echo":
+            console.print(f"\n[bold]❯[/] {msg.get('text', '')}")
+
+        elif msg_type == "thinking_start":
+            console.print("[blue]⠋ Thinking…[/]", end="\r")
+
+        elif msg_type == "thinking_stop":
+            elapsed = msg.get("elapsed", 0)
+            console.print(f"[dim]({elapsed:.1f}s)[/]        ")
+
+        elif msg_type == "text_delta":
+            text = msg.get("text", "")
+            if text.strip():
+                console.print(Markdown(text, code_theme="monokai"))
+
+        elif msg_type == "text_done":
+            text = msg.get("text", "")
+            if text.strip():
+                console.print(Markdown(text, code_theme="monokai"))
+
+        elif msg_type == "tool_start":
+            name = msg.get("name", "")
+            detail = msg.get("detail", "")
+            console.print(f"\n  [grey62]╭─[/] [bold cyan]{name}[/] [grey62]─╮[/]")
+            console.print(f"  [grey62]│[/] {detail}")
+            console.print(f"  [grey62]╰{'─' * (len(name) + 4)}╯[/]")
+
+        elif msg_type == "tool_result":
+            output = msg.get("output", "")
+            is_error = msg.get("isError", False)
+            if is_error:
+                console.print(f"  [bold red]✗[/] {output[:150]}")
+            else:
+                lines = output.strip().splitlines()[:3]
+                for line in lines:
+                    console.print(f"  [green]✓[/] [dim]{line[:150]}[/]")
+
+        elif msg_type == "turn_done":
+            elapsed = msg.get("elapsed", 0)
+            tokens = msg.get("tokens", 0)
+            console.print(f"[green]✓ Done ({elapsed:.1f}s)[/]  [dim]↓{tokens} tok[/]")
+            console.print()
+
+        elif msg_type == "message":
+            console.print(f"[dim]{msg.get('text', '')}[/]")
+
+        elif msg_type == "error":
+            console.print(f"[bold red]Error: {msg.get('message', '')}[/]")
+
+        elif msg_type == "help":
+            for c in msg.get("commands", []):
+                console.print(f"  [dim]{c['cmd']:<20} {c['desc']}[/]")

llm_code/remote/protocol.py

@@ -0,0 +1,22 @@
+"""Remote execution protocol — JSON-RPC over WebSocket."""
+from __future__ import annotations
+from dataclasses import dataclass
+import json
+
+# Server → Client events (same as Ink IPC protocol)
+# Client → Server commands
+
+@dataclass
+class RemoteMessage:
+    """Base message format for client-server communication."""
+    type: str
+    data: dict
+
+    def to_json(self) -> str:
+        return json.dumps({"type": self.type, **self.data})
+
+    @classmethod
+    def from_json(cls, text: str) -> RemoteMessage:
+        obj = json.loads(text)
+        msg_type = obj.pop("type", "unknown")
+        return cls(type=msg_type, data=obj)

llm_code/remote/server.py

@@ -0,0 +1,275 @@
+"""Remote server — runs on the remote machine, executes tools locally."""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import time
+from pathlib import Path
+
+import websockets
+from websockets.asyncio.server import ServerConnection
+
+from llm_code.runtime.config import RuntimeConfig, load_config
+from llm_code.runtime.model_aliases import resolve_model
+
+
+class RemoteServer:
+    def __init__(self, host: str = "0.0.0.0", port: int = 8765, config: RuntimeConfig | None = None):
+        self._host = host
+        self._port = port
+        self._config = config
+        self._runtime = None
+        self._skills = None
+        self._memory = None
+
+    async def start(self) -> None:
+        """Start WebSocket server."""
+        print(f"llm-code server listening on ws://{self._host}:{self._port}")
+        async with websockets.serve(self._handle_client, self._host, self._port):
+            await asyncio.Future()  # run forever
+
+    async def _handle_client(self, ws: ServerConnection) -> None:
+        """Handle a connected client."""
+        print(f"Client connected: {ws.remote_address}")
+
+        # Load config if not provided
+        if not self._config:
+            cwd = Path.cwd()
+            self._config = load_config(
+                user_dir=Path.home() / ".llm-code",
+                project_dir=cwd,
+                local_path=cwd / ".llm-code" / "config.json",
+                cli_overrides={},
+            )
+
+        # Initialize session
+        self._init_session()
+
+        # Send welcome
+        cwd = Path.cwd()
+        import subprocess
+        try:
+            branch = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                cwd=cwd, capture_output=True, text=True, timeout=3
+            ).stdout.strip()
+        except Exception:
+            branch = ""
+
+        await ws.send(json.dumps({
+            "type": "welcome",
+            "model": self._config.model,
+            "workspace": cwd.name,
+            "cwd": str(cwd),
+            "permissions": self._config.permission_mode,
+            "branch": branch,
+        }))
+
+        # Main message loop
+        try:
+            async for raw in ws:
+                msg = json.loads(raw)
+                await self._handle_message(ws, msg)
+        except websockets.ConnectionClosed:
+            print(f"Client disconnected: {ws.remote_address}")
+
+    async def _handle_message(self, ws: ServerConnection, msg: dict) -> None:
+        msg_type = msg.get("type", "")
+
+        if msg_type == "user_input":
+            text = msg.get("text", "").strip()
+            if text.startswith("/"):
+                await self._handle_command(ws, text)
+            else:
+                await self._run_turn(ws, text)
+
+    async def _run_turn(self, ws: ServerConnection, user_input: str) -> None:
+        """Run a conversation turn, streaming events to client."""
+        if not self._runtime:
+            self._init_session()
+
+        from llm_code.api.types import (
+            StreamTextDelta, StreamToolExecStart, StreamToolExecResult,
+            StreamToolProgress, StreamMessageStop,
+        )
+
+        await ws.send(json.dumps({"type": "user_echo", "text": user_input}))
+        await ws.send(json.dumps({"type": "thinking_start"}))
+
+        start = time.monotonic()
+        text_buffer = ""
+        output_tokens = 0
+
+        # Tag filtering state
+        in_tool_call = False
+        in_think = False
+        tag_buffer = ""
+
+        try:
+            async for event in self._runtime.run_turn(user_input):
+                if isinstance(event, StreamTextDelta):
+                    output_tokens += len(event.text) // 4
+
+                    # Filter tags
+                    for char in event.text:
+                        if in_tool_call:
+                            tag_buffer += char
+                            if tag_buffer.endswith("</tool_call>"):
+                                in_tool_call = False
+                                tag_buffer = ""
+                        elif in_think:
+                            tag_buffer += char
+                            if tag_buffer.endswith("</think>"):
+                                in_think = False
+                                tag_buffer = ""
+                        elif tag_buffer:
+                            tag_buffer += char
+                            if tag_buffer == "<tool_call>":
+                                in_tool_call = True
+                            elif tag_buffer == "<think>":
+                                in_think = True
+                            elif not "<tool_call>".startswith(tag_buffer) and not "<think>".startswith(tag_buffer):
+                                text_buffer += tag_buffer
+                                tag_buffer = ""
+                        elif char == "<":
+                            tag_buffer = "<"
+                        else:
+                            text_buffer += char
+
+                    # Flush periodically
+                    in_code = text_buffer.count("```") % 2 == 1
+                    if not in_code and len(text_buffer) > 100:
+                        await ws.send(json.dumps({"type": "text_delta", "text": text_buffer}))
+                        text_buffer = ""
+
+                elif isinstance(event, StreamToolExecStart):
+                    if text_buffer:
+                        await ws.send(json.dumps({"type": "text_delta", "text": text_buffer}))
+                        text_buffer = ""
+                    await ws.send(json.dumps({"type": "tool_start", "name": event.tool_name, "detail": event.args_summary}))
+
+                elif isinstance(event, StreamToolExecResult):
+                    await ws.send(json.dumps({"type": "tool_result", "name": event.tool_name, "output": event.output[:500], "isError": event.is_error}))
+
+                elif isinstance(event, StreamToolProgress):
+                    await ws.send(json.dumps({"type": "tool_progress", "name": event.tool_name, "message": event.message}))
+
+                elif isinstance(event, StreamMessageStop):
+                    if event.usage and event.usage.output_tokens > 0:
+                        output_tokens = event.usage.output_tokens
+
+        except Exception as exc:
+            await ws.send(json.dumps({"type": "error", "message": str(exc)}))
+            return
+
+        # Flush remaining
+        if tag_buffer and not in_tool_call and not in_think:
+            text_buffer += tag_buffer
+        if text_buffer:
+            await ws.send(json.dumps({"type": "text_done", "text": text_buffer}))
+        else:
+            await ws.send(json.dumps({"type": "text_done", "text": ""}))
+
+        elapsed = time.monotonic() - start
+        await ws.send(json.dumps({"type": "thinking_stop", "elapsed": elapsed, "tokens": output_tokens}))
+        await ws.send(json.dumps({"type": "turn_done", "elapsed": elapsed, "tokens": output_tokens}))
+
+    async def _handle_command(self, ws: ServerConnection, text: str) -> None:
+        from llm_code.cli.commands import parse_slash_command
+        cmd = parse_slash_command(text)
+        if not cmd:
+            return
+
+        if cmd.name == "help":
+            await ws.send(json.dumps({
+                "type": "help",
+                "commands": [
+                    {"cmd": "/help", "desc": "Show commands"},
+                    {"cmd": "/clear", "desc": "Clear conversation"},
+                    {"cmd": "/cost", "desc": "Token usage"},
+                    {"cmd": "/exit", "desc": "Disconnect"},
+                ],
+            }))
+        elif cmd.name == "clear":
+            self._init_session()
+            await ws.send(json.dumps({"type": "message", "text": "Conversation cleared."}))
+        elif cmd.name == "cost":
+            if self._runtime:
+                u = self._runtime.session.total_usage
+                await ws.send(json.dumps({"type": "message", "text": f"Tokens — in: {u.input_tokens:,}  out: {u.output_tokens:,}"}))
+        elif cmd.name == "exit":
+            await ws.close()
+        else:
+            await ws.send(json.dumps({"type": "message", "text": f"Command /{cmd.name} not available in remote mode."}))
+
+    def _init_session(self) -> None:
+        """Initialize ConversationRuntime — same pattern as tui.py."""
+        from llm_code.api.client import ProviderClient
+        from llm_code.runtime.context import ProjectContext
+        from llm_code.runtime.conversation import ConversationRuntime
+        from llm_code.runtime.hooks import HookRunner
+        from llm_code.runtime.permissions import PermissionMode, PermissionPolicy
+        from llm_code.runtime.prompt import SystemPromptBuilder
+        from llm_code.runtime.session import Session
+        from llm_code.tools.registry import ToolRegistry
+
+        model = resolve_model(self._config.model, self._config.model_aliases)
+        api_key = os.environ.get(self._config.provider_api_key_env, "")
+
+        provider = ProviderClient.from_model(
+            model=model,
+            base_url=self._config.provider_base_url or "",
+            api_key=api_key,
+            timeout=self._config.timeout,
+            max_retries=self._config.max_retries,
+            native_tools=self._config.native_tools,
+        )
+
+        from llm_code.tools.read_file import ReadFileTool
+        from llm_code.tools.write_file import WriteFileTool
+        from llm_code.tools.edit_file import EditFileTool
+        from llm_code.tools.bash import BashTool
+        from llm_code.tools.glob_search import GlobSearchTool
+        from llm_code.tools.grep_search import GrepSearchTool
+
+        registry = ToolRegistry()
+        for cls in (ReadFileTool, WriteFileTool, EditFileTool, BashTool, GlobSearchTool, GrepSearchTool):
+            registry.register(cls())
+
+        try:
+            from llm_code.tools.git_tools import (
+                GitStatusTool, GitDiffTool, GitLogTool, GitCommitTool,
+                GitPushTool, GitStashTool, GitBranchTool,
+            )
+            for cls in (GitStatusTool, GitDiffTool, GitLogTool, GitCommitTool, GitPushTool, GitStashTool, GitBranchTool):
+                try:
+                    registry.register(cls())
+                except ValueError:
+                    pass
+        except ImportError:
+            pass
+
+        mode_map = {
+            "read_only": PermissionMode.READ_ONLY,
+            "workspace_write": PermissionMode.WORKSPACE_WRITE,
+            "full_access": PermissionMode.FULL_ACCESS,
+            "auto_accept": PermissionMode.AUTO_ACCEPT,
+            "prompt": PermissionMode.PROMPT,
+        }
+
+        cwd = Path.cwd()
+        self._runtime = ConversationRuntime(
+            provider=provider,
+            tool_registry=registry,
+            permission_policy=PermissionPolicy(
+                mode=mode_map.get(self._config.permission_mode, PermissionMode.PROMPT),
+                allow_tools=self._config.allowed_tools,
+                deny_tools=self._config.denied_tools,
+            ),
+            hook_runner=HookRunner(self._config.hooks),
+            prompt_builder=SystemPromptBuilder(),
+            config=self._config,
+            session=Session.create(cwd),
+            context=ProjectContext.discover(cwd),
+        )

llm_code/remote/ssh_proxy.py

@@ -0,0 +1,56 @@
+"""SSH proxy — SSH to remote host, auto-start server, connect."""
+from __future__ import annotations
+
+import asyncio
+import subprocess
+
+
+async def ssh_connect(target: str, port: int = 8765) -> None:
+    """SSH to target, start llm-code server, connect locally.
+
+    target: user@host or just host
+    """
+    from rich.console import Console
+    console = Console()
+
+    console.print(f"[dim]Setting up SSH tunnel to {target}...[/]")
+
+    # Start SSH tunnel: forward local port to remote
+    # Also start llm-code --serve on remote
+    ssh_cmd = [
+        "ssh", "-tt",
+        "-L", f"{port}:localhost:{port}",
+        target,
+        f"cd ~ && llm-code --serve --port {port}",
+    ]
+
+    console.print(f"[dim]$ {' '.join(ssh_cmd)}[/]")
+
+    # Start SSH in background
+    ssh_proc = subprocess.Popen(
+        ssh_cmd,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    # Wait a moment for server to start
+    await asyncio.sleep(3)
+
+    if ssh_proc.poll() is not None:
+        stderr = ssh_proc.stderr.read().decode() if ssh_proc.stderr else ""
+        console.print(f"[red]SSH failed: {stderr[:200]}[/]")
+        return
+
+    console.print("[green]✓ SSH tunnel established[/]")
+
+    # Connect to local forwarded port
+    from llm_code.remote.client import RemoteClient
+    client = RemoteClient(f"ws://localhost:{port}")
+
+    try:
+        await client.connect()
+    finally:
+        ssh_proc.terminate()
+        ssh_proc.wait(timeout=5)
+        console.print("[dim]SSH tunnel closed.[/]")

llm_code/runtime/auto_commit.py

@@ -0,0 +1,56 @@
+"""Auto-commit checkpoint -- git commit individual file changes after tool edits."""
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_TIMEOUT_S = 5
+
+
+def auto_commit_file(path: Path, tool_name: str) -> bool:
+    """Stage and commit a single file as a checkpoint.
+
+    Returns True on successful commit, False on any failure (silently).
+    """
+    if not path.exists():
+        return False
+
+    try:
+        # Stage the specific file only
+        add_result = subprocess.run(
+            ["git", "add", "--", str(path)],
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_S,
+            cwd=path.parent,
+        )
+        if add_result.returncode != 0:
+            logger.debug("git add failed (rc=%d): %s", add_result.returncode, add_result.stderr)
+            return False
+
+        # Commit with checkpoint message
+        filename = path.name
+        message = f"checkpoint: {tool_name} {filename}"
+        commit_result = subprocess.run(
+            ["git", "commit", "-m", message, "--no-verify"],
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_S,
+            cwd=path.parent,
+        )
+        if commit_result.returncode != 0:
+            logger.debug("git commit failed (rc=%d): %s", commit_result.returncode, commit_result.stderr)
+            return False
+
+        logger.info("Auto-committed checkpoint: %s", message)
+        return True
+
+    except subprocess.TimeoutExpired:
+        logger.warning("Auto-commit timed out for %s", path)
+        return False
+    except (OSError, FileNotFoundError):
+        logger.debug("Auto-commit skipped -- git not available or not a repo")
+        return False

llm_code/runtime/auto_diagnose.py

@@ -0,0 +1,62 @@
+"""Auto-diagnose -- run LSP diagnostics after file edits and report errors."""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Extension to language mapping (mirrors llm_code/lsp/tools.py)
+_EXT_LANGUAGE: dict[str, str] = {
+    ".py": "python",
+    ".pyi": "python",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "typescript",
+    ".jsx": "typescript",
+    ".go": "go",
+    ".rs": "rust",
+}
+
+
+def format_diagnostics(diagnostics: list[Any]) -> list[str]:
+    """Format diagnostic objects into human-readable strings."""
+    return [
+        f"{d.file}:{d.line}:{d.column} [{d.severity}] {d.message} ({d.source})"
+        for d in diagnostics
+    ]
+
+
+async def auto_diagnose(lsp_manager: Any, file_path: str) -> list[str]:
+    """Run LSP diagnostics on a file and return error-level issues only.
+
+    Returns a list of formatted error strings. Empty list if no errors
+    or LSP is unavailable. Never raises — all exceptions are caught.
+    """
+    try:
+        suffix = Path(file_path).suffix.lower()
+        language = _EXT_LANGUAGE.get(suffix, "")
+        if not language:
+            return []
+
+        client = lsp_manager.get_client(language)
+        if client is None:
+            return []
+
+        file_uri = Path(file_path).resolve().as_uri()
+        diagnostics = await client.get_diagnostics(file_uri)
+
+        if not diagnostics:
+            return []
+
+        # Filter to error-level only
+        errors = [d for d in diagnostics if d.severity == "error"]
+        if not errors:
+            return []
+
+        return format_diagnostics(errors)
+
+    except Exception:
+        logger.debug("Auto-diagnose failed for %s", file_path, exc_info=True)
+        return []