llmcode-cli 1.0.0__py3-none-any.whl

llm_code/api/types.py

@@ -0,0 +1,140 @@
+"""Frozen dataclass types for the LLM provider API layer."""
+from __future__ import annotations
+
+import dataclasses
+from typing import Union
+
+
+@dataclasses.dataclass(frozen=True)
+class TextBlock:
+    text: str
+
+
+@dataclasses.dataclass(frozen=True)
+class ToolUseBlock:
+    id: str
+    name: str
+    input: dict
+
+
+@dataclasses.dataclass(frozen=True)
+class ToolResultBlock:
+    tool_use_id: str
+    content: str
+    is_error: bool = False
+
+
+@dataclasses.dataclass(frozen=True)
+class ImageBlock:
+    media_type: str
+    data: str
+
+
+ContentBlock = Union[TextBlock, ToolUseBlock, ToolResultBlock, ImageBlock]
+
+
+@dataclasses.dataclass(frozen=True)
+class Message:
+    role: str
+    content: tuple[ContentBlock, ...]
+
+
+@dataclasses.dataclass(frozen=True)
+class ToolDefinition:
+    name: str
+    description: str
+    input_schema: dict
+
+
+@dataclasses.dataclass(frozen=True)
+class MessageRequest:
+    model: str
+    messages: tuple[Message, ...]
+    system: str | None = None
+    tools: tuple[ToolDefinition, ...] = ()
+    max_tokens: int = 4096
+    temperature: float = 0.7
+    stream: bool = True
+    extra_body: dict | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class TokenUsage:
+    input_tokens: int
+    output_tokens: int
+
+
+@dataclasses.dataclass(frozen=True)
+class MessageResponse:
+    content: tuple[ContentBlock, ...]
+    usage: TokenUsage
+    stop_reason: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamEvent:
+    """Base class for all stream events."""
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamMessageStart(StreamEvent):
+    model: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamTextDelta(StreamEvent):
+    text: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamToolUseStart(StreamEvent):
+    id: str
+    name: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamToolUseInputDelta(StreamEvent):
+    id: str
+    partial_json: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamMessageStop(StreamEvent):
+    usage: TokenUsage
+    stop_reason: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamToolProgress(StreamEvent):
+    tool_name: str
+    message: str
+    percent: float | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamToolExecStart(StreamEvent):
+    """Emitted when a tool starts executing."""
+    tool_name: str
+    args_summary: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamToolExecResult(StreamEvent):
+    """Emitted when a tool finishes executing."""
+    tool_name: str
+    output: str
+    is_error: bool = False
+    metadata: dict | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamThinkingDelta(StreamEvent):
+    """Emitted when the model produces a thinking/reasoning token."""
+    text: str
+
+
+@dataclasses.dataclass(frozen=True)
+class StreamPermissionRequest(StreamEvent):
+    """Emitted when a tool requires user permission before execution."""
+    tool_name: str
+    args_preview: str

llm_code/cli/commands.py

@@ -0,0 +1,70 @@
+"""Slash command parsing for the CLI layer."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+KNOWN_COMMANDS = frozenset({
+    "help",
+    "clear",
+    "model",
+    "session",
+    "config",
+    "cd",
+    "image",
+    "cost",
+    "exit",
+    "quit",
+    "plugin",
+    "skill",
+    "undo",
+    "memory",
+    "index",
+    "lsp",
+    "mcp",
+    "budget",
+    "thinking",
+    "cron",
+    "vim",
+    "voice",
+    "ide",
+    "swarm",
+    "search",
+    "vcr",
+    "hida",
+    "task",
+    "checkpoint",
+    "cancel",
+    "keybind",
+    "audit",
+    "analyze",
+    "diff_check",
+})
+
+
+@dataclass(frozen=True)
+class SlashCommand:
+    name: str
+    args: str
+
+
+def parse_slash_command(text: str) -> SlashCommand | None:
+    """Parse a slash command from text.
+
+    Returns a SlashCommand if the text starts with '/', otherwise None.
+    """
+    stripped = text.strip()
+    if not stripped.startswith("/"):
+        return None
+
+    # Strip leading slash
+    rest = stripped[1:]
+
+    # Split on first whitespace
+    parts = rest.split(None, 1)
+    if not parts:
+        return None
+
+    name = parts[0].lower()
+    args = parts[1] if len(parts) > 1 else ""
+
+    return SlashCommand(name=name, args=args)

llm_code/cli/image.py

@@ -0,0 +1,122 @@
+"""Image loading utilities for the CLI layer."""
+from __future__ import annotations
+
+import base64
+import subprocess
+import sys
+from pathlib import Path
+
+from llm_code.api.types import ImageBlock
+
+
+# Map file extensions to MIME types
+_EXT_TO_MEDIA_TYPE: dict[str, str] = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+}
+
+
+def load_image_from_path(path: str) -> ImageBlock:
+    """Load an image from a file path.
+
+    Reads the file, base64-encodes it, and detects the media type from extension.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+        ValueError: If the file extension is not a supported image type.
+    """
+    file_path = Path(path)
+    if not file_path.exists():
+        raise FileNotFoundError(f"Image file not found: {path}")
+
+    ext = file_path.suffix.lower()
+    media_type = _EXT_TO_MEDIA_TYPE.get(ext)
+    if media_type is None:
+        # Default to png for unknown extensions
+        media_type = "image/png"
+
+    raw = file_path.read_bytes()
+    encoded = base64.b64encode(raw).decode("ascii")
+
+    return ImageBlock(media_type=media_type, data=encoded)
+
+
+def capture_clipboard_image() -> ImageBlock | None:
+    """Capture an image from the clipboard.
+
+    macOS: uses pngpaste -
+    Linux: uses xclip -selection clipboard -t image/png -o
+
+    Returns None if capture is not available or fails.
+    """
+    if sys.platform == "darwin":
+        try:
+            result = subprocess.run(
+                ["pngpaste", "-"],
+                capture_output=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout:
+                encoded = base64.b64encode(result.stdout).decode("ascii")
+                return ImageBlock(media_type="image/png", data=encoded)
+        except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+            pass
+        return None
+    else:
+        # Linux
+        try:
+            result = subprocess.run(
+                ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"],
+                capture_output=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout:
+                encoded = base64.b64encode(result.stdout).decode("ascii")
+                return ImageBlock(media_type="image/png", data=encoded)
+        except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+            pass
+        return None
+
+
+_IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"}
+
+
+def extract_dropped_images(text: str) -> tuple[str, list[ImageBlock]]:
+    r"""Detect drag-and-dropped image file paths in user input.
+
+    Terminal drag-and-drop produces paths like:
+      /Users/adam/screenshot.png
+      '/Users/adam/my screenshot.png'
+      /Users/adam/my\ screenshot.png
+
+    Returns (cleaned_text, list_of_ImageBlocks).
+    """
+    import shlex
+    from pathlib import Path as P
+
+    images: list[ImageBlock] = []
+    remaining_parts: list[str] = []
+
+    try:
+        tokens = shlex.split(text)
+    except ValueError:
+        tokens = text.split()
+
+    for token in tokens:
+        token = token.strip()
+        if not token:
+            continue
+        path = P(token)
+        if path.suffix.lower() in _IMAGE_EXTENSIONS and path.is_file():
+            try:
+                img = load_image_from_path(str(path))
+                images.append(img)
+            except Exception:
+                remaining_parts.append(token)
+        else:
+            remaining_parts.append(token)
+
+    return " ".join(remaining_parts), images

llm_code/cli/render.py

@@ -0,0 +1,214 @@
+"""Rich-based terminal renderer for the CLI layer."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+from llm_code.api.types import TokenUsage
+from llm_code.tools.base import ToolResult
+from llm_code.utils.hyperlink import auto_link, supports_hyperlinks
+
+
+# File extensions to language mappings for syntax highlighting
+_EXT_TO_LANG: dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".jsx": "jsx",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".md": "markdown",
+    ".html": "html",
+    ".css": "css",
+    ".sql": "sql",
+    ".rb": "ruby",
+    ".php": "php",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".r": "r",
+}
+
+SLASH_COMMANDS_HELP = [
+    ("/help", "Show this help message"),
+    ("/clear", "Clear the conversation history"),
+    ("/model [name]", "Show or switch the current model"),
+    ("/session list", "List saved sessions"),
+    ("/session save", "Save the current session"),
+    ("/session switch <id>", "Switch to a saved session"),
+    ("/config", "Show runtime config"),
+    ("/config get <key>", "Get a config value"),
+    ("/config set <key> <value>", "Set a runtime config value"),
+    ("/cd <path>", "Change the working directory"),
+    ("/image <path>", "Attach an image from file path"),
+    ("/cost", "Show token usage and estimated cost"),
+    ("/plugin", "Browse plugin marketplace"),
+    ("/plugin install|enable|disable|remove", "Manage plugins"),
+    ("/skill", "Browse skills marketplace"),
+    ("/skill install|enable|disable|remove", "Manage skills"),
+    ("/undo", "Undo last file change (git checkpoint)"),
+    ("/undo list", "List all checkpoints"),
+    ("/memory", "List project memory entries"),
+    ("/memory get|set|delete <key>", "Manage memory"),
+    ("/index", "Show project index summary"),
+    ("/index rebuild", "Rebuild project index"),
+    ("/mcp", "List MCP servers"),
+    ("/mcp search|install|remove", "MCP server marketplace"),
+    ("/lsp", "Show LSP server status"),
+    ("/budget <tokens>", "Set output token budget"),
+    ("/exit", "Exit the application"),
+]
+
+
+class TerminalRenderer:
+    """Renders CLI output using Rich."""
+
+    def __init__(self, console: Console | None = None) -> None:
+        self._console = console or Console()
+
+    def render_markdown(self, text: str) -> None:
+        """Render text as Rich Markdown."""
+        if supports_hyperlinks():
+            text = auto_link(text)
+        self._console.print(Markdown(text))
+
+    def render_tool_panel(
+        self,
+        tool_name: str,
+        args: dict,
+        result: ToolResult,
+    ) -> None:
+        """Render a tool call result in a panel with syntax highlighting."""
+        status_color = "red" if result.is_error else "green"
+        status_icon = "[red]✗[/red]" if result.is_error else "[green]✓[/green]"
+        title = f"{status_icon} [bold]{tool_name}[/bold]"
+
+        # Determine content to display
+        output = result.output or ""
+
+        # Check for diff metadata first
+        if result.metadata and "diff" in result.metadata:
+            content = self._build_diff_content(args, result)
+        elif tool_name == "read_file":
+            file_path = args.get("path", "")
+            ext = Path(file_path).suffix.lower()
+            lang = _EXT_TO_LANG.get(ext, "text")
+            if output:
+                content = Syntax(output, lang, theme="monokai", line_numbers=True)
+            else:
+                content = Text(output)
+        elif tool_name == "bash":
+            content = Syntax(output, "bash", theme="monokai") if output else Text(output)
+        else:
+            if supports_hyperlinks() and output:
+                output = auto_link(output)
+            content = Text(output)
+
+        self._console.print(
+            Panel(
+                content,
+                title=title,
+                border_style=status_color,
+                expand=False,
+            )
+        )
+
+    def _build_diff_content(self, args: dict, result: ToolResult) -> Text:
+        """Build Rich Text with colored diff output."""
+        text = Text()
+        meta = result.metadata or {}
+        adds = meta.get("additions", 0)
+        dels = meta.get("deletions", 0)
+
+        # Header line
+        filename = Path(args.get("path", "file")).name
+        text.append(f"{filename}  ", style="bold")
+        text.append(f"+{adds}", style="bold green")
+        text.append("  ")
+        text.append(f"-{dels}", style="bold red")
+        text.append("\n")
+
+        # Summary
+        text.append(result.output or "")
+        text.append("\n")
+
+        for hunk in meta.get("diff", []):
+            text.append(
+                f"@@ -{hunk['old_start']},{hunk['old_lines']} "
+                f"+{hunk['new_start']},{hunk['new_lines']} @@\n",
+                style="cyan",
+            )
+            for line in hunk.get("lines", []):
+                if line.startswith("+"):
+                    text.append(line + "\n", style="green")
+                elif line.startswith("-"):
+                    text.append(line + "\n", style="red")
+                else:
+                    text.append(line + "\n")
+
+        return text
+
+    def render_permission_prompt(self, tool_name: str, args: dict) -> None:
+        """Render a permission prompt for a tool call."""
+        import json
+
+        args_str = json.dumps(args, indent=2)
+        content = (
+            f"[bold yellow]Tool:[/bold yellow] {tool_name}\n"
+            f"[bold yellow]Args:[/bold yellow]\n{args_str}"
+        )
+        self._console.print(
+            Panel(
+                content,
+                title="[bold yellow]Permission Required[/bold yellow]",
+                border_style="yellow",
+                expand=False,
+            )
+        )
+        self._console.print("[bold]Allow? [y/n/a(lways)/never][/bold] ", end="")
+
+    def render_usage(self, usage: TokenUsage) -> None:
+        """Render token usage statistics."""
+        total = usage.input_tokens + usage.output_tokens
+        self._console.print(
+            f"[dim]Tokens — input: {usage.input_tokens:,}  "
+            f"output: {usage.output_tokens:,}  "
+            f"total: {total:,}[/dim]"
+        )
+
+    def render_tool_progress(self, tool_name: str, message: str, percent: float | None = None) -> None:
+        """Render an in-progress update for a running tool (overwrites current line)."""
+        if percent is not None:
+            pct = f"{percent:.0%}"
+            self._console.print(f"  [dim]{tool_name}[/dim] {message} [{pct}]", end="\r")
+        else:
+            self._console.print(f"  [dim]{tool_name}[/dim] {message}", end="\r")
+
+    def render_help(self) -> None:
+        """Render a table of available slash commands."""
+        table = Table(title="Available Commands", show_header=True, header_style="bold cyan")
+        table.add_column("Command", style="bold green", no_wrap=True)
+        table.add_column("Description")
+
+        for cmd, desc in SLASH_COMMANDS_HELP:
+            table.add_row(cmd, desc)
+
+        self._console.print(table)

llm_code/cli/status_line.py

@@ -0,0 +1,79 @@
+"""CLIStatusLine — persistent bottom status bar for the print CLI."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from rich.console import Console
+from rich.live import Live
+from rich.text import Text
+
+
+@dataclass
+class StatusLineState:
+    model: str = ""
+    tokens: int = 0
+    cost: str = ""
+    is_streaming: bool = False
+    permission_mode: str = ""
+    context_usage: float = 0.0  # 0.0-1.0
+
+
+def format_status_line(state: StatusLineState) -> str:
+    """Format status line as a pipe-separated string."""
+    parts: list[str] = []
+    if state.permission_mode and state.permission_mode != "prompt":
+        parts.append(f"[{state.permission_mode}]")
+    if state.model:
+        parts.append(state.model)
+    if state.tokens > 0:
+        parts.append(f"↓{state.tokens:,} tok")
+    if state.cost:
+        parts.append(state.cost)
+    if state.context_usage >= 0.6:
+        pct = int(state.context_usage * 100)
+        filled = int(state.context_usage * 8)
+        bar = "█" * filled + "░" * (8 - filled)
+        parts.append(f"[{bar}] {pct}%")
+    if state.is_streaming:
+        parts.append("streaming…")
+    parts.append("/help")
+    parts.append("Ctrl+D quit")
+    return " │ ".join(parts)
+
+
+class CLIStatusLine:
+    """Persistent bottom status line for the print CLI using Rich Live."""
+
+    def __init__(self, console: Console) -> None:
+        self._console = console
+        self.state = StatusLineState()
+        self._live: Live | None = None
+
+    def update(self, **kwargs: Any) -> None:
+        """Update one or more state fields and refresh the display."""
+        for key, value in kwargs.items():
+            if hasattr(self.state, key):
+                setattr(self.state, key, value)
+        if self._live is not None:
+            self._live.update(self._render())
+
+    def _render(self) -> Text:
+        """Render the current state as a Rich Text object."""
+        return Text(format_status_line(self.state), style="dim")
+
+    def start(self) -> None:
+        """Begin live rendering at the bottom of the terminal."""
+        self._live = Live(
+            self._render(),
+            console=self._console,
+            refresh_per_second=4,
+            transient=True,
+        )
+        self._live.start()
+
+    def stop(self) -> None:
+        """Stop live rendering."""
+        if self._live is not None:
+            self._live.stop()
+            self._live = None