llmcode-cli 1.0.0__py3-none-any.whl

llm_code/tui/status_bar.py

@@ -0,0 +1,72 @@
+"""StatusBar — persistent bottom line with model, tokens, cost, hints."""
+from __future__ import annotations
+
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.app import RenderResult
+
+
+class StatusBar(Widget):
+    """Bottom status: model │ ↓tokens tok │ $cost │ streaming… │ /help │ Ctrl+D quit"""
+
+    model: reactive[str] = reactive("")
+    tokens: reactive[int] = reactive(0)
+    cost: reactive[str] = reactive("")
+    is_streaming: reactive[bool] = reactive(False)
+    vim_mode: reactive[str] = reactive("")  # "" | "NORMAL" | "INSERT"
+    is_local: reactive[bool] = reactive(False)
+    plan_mode: reactive[str] = reactive("")  # "" | "PLAN"
+
+    DEFAULT_CSS = """
+    StatusBar {
+        dock: bottom;
+        height: 1;
+        background: $surface-darken-1;
+        color: $text-muted;
+        padding: 0 1;
+    }
+    """
+
+    def _format_content(self) -> str:
+        parts: list[str] = []
+        if self.plan_mode:
+            parts.append(self.plan_mode)
+        if self.vim_mode:
+            parts.append(f"-- {self.vim_mode} --")
+        if self.model:
+            parts.append(self.model)
+        if self.tokens > 0:
+            parts.append(f"↓{self.tokens:,} tok")
+        if self.is_local:
+            parts.append("free")
+        elif self.cost:
+            parts.append(self.cost)
+        if self.is_streaming:
+            parts.append("streaming…")
+        parts.append("/help")
+        parts.append("Ctrl+D quit")
+        return " │ ".join(parts)
+
+    def render(self) -> RenderResult:
+        return self._format_content()
+
+    def watch_model(self) -> None:
+        self.refresh()
+
+    def watch_tokens(self) -> None:
+        self.refresh()
+
+    def watch_cost(self) -> None:
+        self.refresh()
+
+    def watch_is_streaming(self) -> None:
+        self.refresh()
+
+    def watch_vim_mode(self) -> None:
+        self.refresh()
+
+    def watch_is_local(self) -> None:
+        self.refresh()
+
+    def watch_plan_mode(self) -> None:
+        self.refresh()

llm_code/tui/theme.py

@@ -0,0 +1,96 @@
+"""Color constants and Textual CSS for the fullscreen TUI."""
+from __future__ import annotations
+
+# Semantic color map — values are Rich/Textual style strings
+COLORS: dict[str, str] = {
+    "prompt": "bold cyan",
+    "tool_name": "bold cyan",
+    "tool_line": "dim",
+    "tool_args": "dim",
+    "success": "bold green",
+    "error": "bold red",
+    "diff_add": "green",
+    "diff_del": "red",
+    "thinking": "#cc7a00",
+    "warning": "yellow",
+    "spinner": "blue",
+    "dim": "dim",
+    "bash_cmd": "white on #2a2a3a",
+    "agent": "bold cyan",
+    "shortcut_key": "bold",
+}
+
+# Textual CSS applied to the App
+APP_CSS = """
+Screen {
+    layout: vertical;
+}
+
+#header-bar {
+    dock: top;
+    height: 1;
+    background: $surface-darken-1;
+    color: $text-muted;
+    padding: 0 1;
+}
+
+#chat-view {
+    height: 1fr;
+    overflow-y: auto;
+    padding: 0 1;
+}
+
+#input-bar {
+    dock: bottom;
+    height: auto;
+    min-height: 1;
+    max-height: 8;
+    padding: 0 1;
+}
+
+#status-bar {
+    dock: bottom;
+    height: 1;
+    background: $surface-darken-1;
+    color: $text-muted;
+    padding: 0 1;
+}
+
+.tool-block {
+    margin: 0 0 0 2;
+}
+
+.thinking-collapsed {
+    color: $text-muted;
+}
+
+.thinking-expanded {
+    color: $text-muted;
+    border: round $accent;
+    padding: 0 1;
+    max-height: 20;
+    overflow-y: auto;
+}
+
+.permission-inline {
+    border-left: thick $warning;
+    padding: 0 1;
+    margin: 0 0 0 2;
+}
+
+.turn-summary {
+    margin: 0 0 1 0;
+}
+
+.spinner-line {
+    color: $accent;
+}
+
+.user-message {
+    margin: 1 0 0 0;
+}
+
+.assistant-text {
+    margin: 0 0 1 0;
+}
+"""

llm_code/utils/diff.py

@@ -0,0 +1,111 @@
+"""Unified diff generation for file edits."""
+from __future__ import annotations
+
+import dataclasses
+import difflib
+import re
+
+
+@dataclasses.dataclass(frozen=True)
+class DiffHunk:
+    """A single hunk from a unified diff."""
+
+    old_start: int
+    old_lines: int
+    new_start: int
+    new_lines: int
+    lines: tuple[str, ...]
+
+    def to_dict(self) -> dict:
+        return {
+            "old_start": self.old_start,
+            "old_lines": self.old_lines,
+            "new_start": self.new_start,
+            "new_lines": self.new_lines,
+            "lines": list(self.lines),
+        }
+
+
+_HUNK_HEADER = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+
+MAX_DIFF_LINES = 500
+
+
+def generate_diff(
+    old: str,
+    new: str,
+    filename: str,
+    context: int = 3,
+) -> list[DiffHunk]:
+    """Generate structured diff hunks from old and new file content.
+
+    Uses difflib.unified_diff with the given context (default 3).
+    Truncates total output lines at MAX_DIFF_LINES.
+    """
+    if old == new:
+        return []
+
+    diff_lines = list(
+        difflib.unified_diff(
+            old.splitlines(keepends=True),
+            new.splitlines(keepends=True),
+            fromfile=f"a/{filename}",
+            tofile=f"b/{filename}",
+            n=context,
+        )
+    )
+
+    hunks: list[DiffHunk] = []
+    current_lines: list[str] = []
+    old_start = new_start = old_count = new_count = 0
+    total_lines = 0
+
+    for raw_line in diff_lines:
+        # Skip the --- and +++ header lines
+        if raw_line.startswith("---") or raw_line.startswith("+++"):
+            continue
+
+        m = _HUNK_HEADER.match(raw_line)
+        if m:
+            # Flush previous hunk
+            if current_lines:
+                hunks.append(DiffHunk(
+                    old_start=old_start,
+                    old_lines=old_count,
+                    new_start=new_start,
+                    new_lines=new_count,
+                    lines=tuple(current_lines),
+                ))
+            old_start = int(m.group(1))
+            old_count = int(m.group(2)) if m.group(2) else 1
+            new_start = int(m.group(3))
+            new_count = int(m.group(4)) if m.group(4) else 1
+            current_lines = []
+            continue
+
+        if total_lines >= MAX_DIFF_LINES:
+            break
+
+        # Normalize: strip trailing newline, keep prefix (+/-/space)
+        stripped = raw_line.rstrip("\n\r")
+        current_lines.append(stripped)
+        total_lines += 1
+
+    # Flush final hunk
+    if current_lines:
+        hunks.append(DiffHunk(
+            old_start=old_start,
+            old_lines=old_count,
+            new_start=new_start,
+            new_lines=new_count,
+            lines=tuple(current_lines),
+        ))
+
+    return hunks
+
+
+def count_changes(hunks: list[DiffHunk]) -> tuple[int, int]:
+    """Count total additions and deletions across all hunks."""
+    adds = sum(1 for h in hunks for line in h.lines if line.startswith("+"))
+    dels = sum(1 for h in hunks for line in h.lines if line.startswith("-"))
+    return adds, dels

llm_code/utils/errors.py

@@ -0,0 +1,70 @@
+"""Human-friendly error message formatting for tool execute() methods."""
+from __future__ import annotations
+
+import json
+import subprocess
+
+
+def friendly_error(error: Exception, context: str = "") -> str:
+    """Return a user-friendly error message for the given exception.
+
+    Parameters
+    ----------
+    error:
+        The exception to format.
+    context:
+        Optional extra context (e.g. the file path being operated on).
+    """
+    prefix = f"[{context}] " if context else ""
+
+    if isinstance(error, FileNotFoundError):
+        path = error.filename or str(error)
+        return f"{prefix}File not found: {path}. Check the working directory with /cd"
+
+    if isinstance(error, PermissionError):
+        path = error.filename or str(error)
+        return (
+            f"{prefix}Permission denied: {path}. "
+            "The file may be read-only or owned by another user"
+        )
+
+    if isinstance(error, json.JSONDecodeError):
+        return (
+            f"{prefix}Invalid JSON at line {error.lineno}: {error.msg}"
+        )
+
+    if isinstance(error, subprocess.TimeoutExpired):
+        timeout = error.timeout
+        return (
+            f"{prefix}Command timed out after {timeout}s. "
+            "Try increasing timeout or simplifying the command"
+        )
+
+    if isinstance(error, ConnectionError):
+        # Try to extract target from the message
+        target = str(error).split("'")[1] if "'" in str(error) else str(error)
+        return (
+            f"{prefix}Connection failed: {target}. Check if the server is running"
+        )
+
+    return f"{prefix}Error: {type(error).__name__}: {error}"
+
+
+def suggest_fix(error: Exception) -> str | None:
+    """Return an actionable suggestion for the given exception, or None."""
+    if isinstance(error, FileNotFoundError):
+        return "Use /cd to navigate to the correct directory, or verify the file path."
+
+    if isinstance(error, PermissionError):
+        return "Try running with elevated permissions, or check file ownership with `ls -la`."
+
+    if isinstance(error, json.JSONDecodeError):
+        return f"Check JSON syntax around line {error.lineno}. Common issues: trailing commas, missing quotes."
+
+    if isinstance(error, subprocess.TimeoutExpired):
+        return "Increase the timeout parameter, or break the command into smaller steps."
+
+    if isinstance(error, ConnectionError):
+        return "Verify the server is running and the URL/port is correct."
+
+    return None

llm_code/utils/hyperlink.py

@@ -0,0 +1,73 @@
+"""OSC8 terminal hyperlink utilities."""
+from __future__ import annotations
+
+import os
+import re
+
+# Regex to detect http/https URLs; excludes trailing punctuation like . ) > " <
+_URL_RE = re.compile(r"https?://[^\s)<>\"]+")
+
+# Terminals (TERM_PROGRAM values) known to support OSC8 hyperlinks
+_SUPPORTED_TERM_PROGRAMS: frozenset[str] = frozenset({"iTerm.app", "WezTerm"})
+
+
+def make_hyperlink(url: str, text: str | None = None) -> str:
+    """Return an OSC8 hyperlink escape sequence.
+
+    Args:
+        url:  The target URL.
+        text: Display text; defaults to *url* when ``None`` or empty.
+
+    Returns:
+        A string containing the OSC8 escape sequences so terminals that
+        support them render a clickable hyperlink.
+    """
+    display = text if text else url
+    return f"\033]8;;{url}\033\\{display}\033]8;;\033\\"
+
+
+def auto_link(text: str) -> str:
+    """Detect URLs in *text* and wrap each one in an OSC8 hyperlink.
+
+    Only ``http://`` and ``https://`` URLs are matched.  Trailing
+    punctuation characters that are unlikely to be part of the URL
+    (i.e. ``.``, ``,``, ``)``, ``]``) are excluded from the link target
+    so that sentences such as "See https://example.com." render
+    correctly.
+
+    Args:
+        text: Plain text that may contain URLs.
+
+    Returns:
+        Text with any detected URLs replaced by OSC8 hyperlink sequences.
+    """
+    _TRAILING_PUNCT = frozenset(".),]")
+
+    def _replace(match: re.Match) -> str:  # type: ignore[type-arg]
+        url = match.group(0)
+        # Strip trailing punctuation that is very likely not part of the URL.
+        while url and url[-1] in _TRAILING_PUNCT:
+            url = url[:-1]
+        suffix = match.group(0)[len(url):]
+        return make_hyperlink(url) + suffix
+
+    return _URL_RE.sub(_replace, text)
+
+
+def supports_hyperlinks() -> bool:
+    """Return ``True`` when the current terminal is known to support OSC8.
+
+    Checks the following environment variables (in order):
+
+    * ``TERM_PROGRAM`` — ``iTerm.app`` or ``WezTerm``
+    * ``WT_SESSION``   — set by Windows Terminal
+    * ``VTE_VERSION``  — set by VTE-based terminals (GNOME Terminal, etc.)
+    """
+    term_program = os.environ.get("TERM_PROGRAM", "")
+    if term_program in _SUPPORTED_TERM_PROGRAMS:
+        return True
+    if os.environ.get("WT_SESSION"):
+        return True
+    if os.environ.get("VTE_VERSION"):
+        return True
+    return False

llm_code/utils/notebook.py

@@ -0,0 +1,179 @@
+"""Notebook utility — parse, format, edit, and validate Jupyter notebooks."""
+from __future__ import annotations
+
+import copy
+import dataclasses
+import uuid
+
+_OUTPUT_TRUNCATION_LIMIT = 10 * 1024  # 10 KB
+
+
+@dataclasses.dataclass(frozen=True)
+class NotebookCell:
+    index: int
+    cell_type: str
+    source: str
+    execution_count: int | None
+    output_text: str
+    images: tuple[dict, ...]
+
+
+def _extract_output(outputs: list[dict]) -> tuple[str, list[dict]]:
+    """Extract text and images from a list of cell outputs."""
+    text_parts: list[str] = []
+    images: list[dict] = []
+
+    for output in outputs:
+        output_type = output.get("output_type", "")
+
+        if output_type == "stream":
+            text = output.get("text", "")
+            if isinstance(text, list):
+                text = "".join(text)
+            text_parts.append(text)
+
+        elif output_type in ("execute_result", "display_data"):
+            data = output.get("data", {})
+            # Collect images
+            for media_type in ("image/png", "image/jpeg"):
+                if media_type in data:
+                    images.append({"media_type": media_type, "data": data[media_type]})
+            # Prefer plain text representation
+            if "text/plain" in data:
+                text = data["text/plain"]
+                if isinstance(text, list):
+                    text = "".join(text)
+                text_parts.append(text)
+
+        elif output_type == "error":
+            ename = output.get("ename", "Error")
+            evalue = output.get("evalue", "")
+            text_parts.append(f"{ename}: {evalue}")
+
+    combined = "\n".join(text_parts)
+    if len(combined) > _OUTPUT_TRUNCATION_LIMIT:
+        combined = combined[:_OUTPUT_TRUNCATION_LIMIT] + "\n... [truncated]"
+
+    return combined, images
+
+
+def parse_notebook(data: dict) -> list[NotebookCell]:
+    """Parse a notebook dict into a list of NotebookCell objects."""
+    cells = data.get("cells", [])
+    result: list[NotebookCell] = []
+
+    for index, cell in enumerate(cells):
+        cell_type = cell.get("cell_type", "code")
+        source = cell.get("source", "")
+        if isinstance(source, list):
+            source = "".join(source)
+
+        execution_count = cell.get("execution_count") if cell_type == "code" else None
+        outputs = cell.get("outputs", []) if cell_type == "code" else []
+        output_text, images = _extract_output(outputs)
+
+        result.append(NotebookCell(
+            index=index,
+            cell_type=cell_type,
+            source=source,
+            execution_count=execution_count,
+            output_text=output_text,
+            images=tuple(images),
+        ))
+
+    return result
+
+
+def format_cells(cells: list[NotebookCell]) -> str:
+    """Format a list of NotebookCell objects into a human-readable string."""
+    if not cells:
+        return ""
+
+    parts: list[str] = []
+    for cell in cells:
+        exec_info = f" (exec {cell.execution_count})" if cell.execution_count is not None else ""
+        header = f"Cell {cell.index} [{cell.cell_type}]{exec_info}"
+        body = cell.source
+
+        section = f"{header}\n{body}"
+        if cell.output_text:
+            section += f"\nOutput:\n{cell.output_text}"
+
+        parts.append(section)
+
+    return "\n\n".join(parts)
+
+
+def validate_notebook(data: dict) -> bool:
+    """Return True if data is a valid notebook (nbformat >= 4 and cells is a list)."""
+    if not isinstance(data, dict):
+        return False
+    nbformat = data.get("nbformat")
+    if not isinstance(nbformat, int) or nbformat < 4:
+        return False
+    cells = data.get("cells")
+    if not isinstance(cells, list):
+        return False
+    return True
+
+
+def _generate_cell_id() -> str:
+    """Generate a short cell ID compatible with nbformat >= 4.5."""
+    return uuid.uuid4().hex[:8]
+
+
+def edit_notebook(
+    data: dict,
+    command: str,
+    cell_index: int,
+    source: str | None = None,
+    cell_type: str | None = None,
+) -> dict:
+    """Return a new notebook dict with the specified edit applied.
+
+    Commands:
+        replace — replace cell at cell_index with new source (and optionally cell_type)
+        insert  — insert a new cell before cell_index
+        delete  — remove the cell at cell_index
+    """
+    result = copy.deepcopy(data)
+    cells: list[dict] = result["cells"]
+    nbformat_minor: int = data.get("nbformat_minor", 0)
+    needs_id = nbformat_minor >= 5
+
+    if command == "replace":
+        if cell_index < 0 or cell_index >= len(cells):
+            raise IndexError(f"Cell index {cell_index} out of range (0..{len(cells) - 1})")
+        cell = cells[cell_index]
+        cell["source"] = source if source is not None else cell["source"]
+        if cell_type is not None:
+            cell["cell_type"] = cell_type
+        # Reset execution metadata when replacing
+        if cell.get("cell_type") == "code" and "outputs" not in cell:
+            cell["outputs"] = []
+
+    elif command == "insert":
+        if cell_index < 0 or cell_index > len(cells):
+            raise IndexError(f"Insert index {cell_index} out of range (0..{len(cells)})")
+        resolved_type = cell_type or "code"
+        new_cell: dict = {
+            "cell_type": resolved_type,
+            "metadata": {},
+            "source": source or "",
+        }
+        if needs_id:
+            new_cell["id"] = _generate_cell_id()
+        if resolved_type == "code":
+            new_cell["execution_count"] = None
+            new_cell["outputs"] = []
+        cells.insert(cell_index, new_cell)
+
+    elif command == "delete":
+        if cell_index < 0 or cell_index >= len(cells):
+            raise IndexError(f"Cell index {cell_index} out of range (0..{len(cells) - 1})")
+        cells.pop(cell_index)
+
+    else:
+        raise ValueError(f"Unknown notebook edit command: {command!r}. Use replace, insert, or delete.")
+
+    return result

llm_code/utils/search.py

@@ -0,0 +1,69 @@
+"""Search utilities for llm-code conversation history."""
+from __future__ import annotations
+
+import dataclasses
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from llm_code.api.types import Message
+
+
+@dataclasses.dataclass(frozen=True)
+class SearchResult:
+    """A single search match within conversation messages."""
+
+    message_index: int
+    line_number: int
+    line_text: str
+    match_start: int
+    match_end: int
+
+
+def search_messages(
+    messages: list[Message],
+    query: str,
+    case_sensitive: bool = False,
+) -> list[SearchResult]:
+    """Search through TextBlock content in messages for the given query.
+
+    Only TextBlock.text is searched; ToolUseBlock, ToolResultBlock, and
+    ImageBlock content are ignored.
+
+    Args:
+        messages: List of Message objects from a session.
+        query: The string to search for.
+        case_sensitive: When False (default), search is case-insensitive.
+
+    Returns:
+        A list of SearchResult instances, one per match, in order of
+        appearance (message index, then line number, then match position).
+    """
+    if not query:
+        return []
+
+    from llm_code.api.types import TextBlock
+
+    flags = 0 if case_sensitive else re.IGNORECASE
+    pattern = re.compile(re.escape(query), flags)
+
+    results: list[SearchResult] = []
+
+    for msg_idx, message in enumerate(messages):
+        for block in message.content:
+            if not isinstance(block, TextBlock):
+                continue
+            text = block.text
+            for line_idx, line in enumerate(text.splitlines(), start=1):
+                for match in pattern.finditer(line):
+                    results.append(
+                        SearchResult(
+                            message_index=msg_idx,
+                            line_number=line_idx,
+                            line_text=line,
+                            match_start=match.start(),
+                            match_end=match.end(),
+                        )
+                    )
+
+    return results

llm_code/utils/text_normalize.py

@@ -0,0 +1,28 @@
+"""Text normalization utilities for fuzzy matching."""
+from __future__ import annotations
+
+
+_QUOTE_TABLE = str.maketrans(
+    {
+        "\u2018": "'",  # LEFT SINGLE QUOTATION MARK
+        "\u2019": "'",  # RIGHT SINGLE QUOTATION MARK
+        "\u201c": '"',  # LEFT DOUBLE QUOTATION MARK
+        "\u201d": '"',  # RIGHT DOUBLE QUOTATION MARK
+        "\u02bc": "'",  # MODIFIER LETTER APOSTROPHE
+    }
+)
+
+
+def normalize_quotes(text: str) -> str:
+    """Convert curly/smart quotes and modifier apostrophes to straight quotes."""
+    return text.translate(_QUOTE_TABLE)
+
+
+def strip_trailing_whitespace(text: str) -> str:
+    """Remove trailing spaces and tabs from each line."""
+    return "\n".join(line.rstrip(" \t") for line in text.split("\n"))
+
+
+def normalize_for_match(text: str) -> str:
+    """Apply quote normalization and trailing-whitespace stripping."""
+    return strip_trailing_whitespace(normalize_quotes(text))