llmcode-cli 1.0.0__py3-none-any.whl

llm_code/utils/version_check.py

@@ -0,0 +1,62 @@
+"""Non-blocking version check against GitHub releases API."""
+from __future__ import annotations
+
+import dataclasses
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+_RELEASES_URL = "https://api.github.com/repos/djfeu-adam/llm-code/releases/latest"
+_TIMEOUT = 5.0
+
+
+@dataclasses.dataclass(frozen=True)
+class VersionInfo:
+    current: str
+    latest: str
+    is_outdated: bool
+    release_url: str
+
+
+def _parse_version(tag: str) -> tuple[int, ...]:
+    """Parse a version tag like 'v1.2.3' or '1.2.3' into a comparable tuple."""
+    cleaned = tag.lstrip("v")
+    try:
+        return tuple(int(x) for x in cleaned.split("."))
+    except ValueError:
+        return (0,)
+
+
+async def check_latest_version(current: str) -> VersionInfo | None:
+    """Fetch latest release from GitHub and compare with *current*.
+
+    Returns a :class:`VersionInfo` or ``None`` on any network/parse failure.
+    """
+    try:
+        import httpx
+
+        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
+            response = await client.get(
+                _RELEASES_URL,
+                headers={"Accept": "application/vnd.github+json"},
+                follow_redirects=True,
+            )
+            response.raise_for_status()
+            data = response.json()
+    except Exception:
+        return None
+
+    try:
+        tag_name: str = data["tag_name"]
+        release_url: str = data.get("html_url", "")
+    except (KeyError, TypeError):
+        return None
+
+    is_outdated = _parse_version(tag_name) > _parse_version(current)
+    return VersionInfo(
+        current=current,
+        latest=tag_name.lstrip("v"),
+        is_outdated=is_outdated,
+        release_url=release_url,
+    )

llm_code/vim/__init__.py

@@ -0,0 +1,4 @@
+"""Vim mode engine for llm-code."""
+from llm_code.vim.types import VimMode, VimState, Register, ParsedCommand, initial_state
+
+__all__ = ["VimMode", "VimState", "Register", "ParsedCommand", "initial_state"]

llm_code/vim/engine.py

@@ -0,0 +1,51 @@
+"""VimEngine — top-level API for the vim editing engine.
+
+Wraps the pure-functional state machine in a mutable shell for
+convenient imperative use.
+"""
+from __future__ import annotations
+
+from llm_code.vim.types import VimMode, VimState, initial_state
+from llm_code.vim.transitions import handle_key
+
+
+class VimEngine:
+    """Mutable wrapper around the immutable VimState."""
+
+    def __init__(self, buffer: str = "") -> None:
+        self._state = initial_state(buffer)
+
+    @property
+    def buffer(self) -> str:
+        return self._state.buffer
+
+    @property
+    def cursor(self) -> int:
+        return self._state.cursor
+
+    @property
+    def mode(self) -> VimMode:
+        return self._state.mode
+
+    @property
+    def mode_display(self) -> str:
+        if self._state.mode == VimMode.NORMAL:
+            return "-- NORMAL --"
+        return "-- INSERT --"
+
+    def feed_key(self, key: str) -> None:
+        """Process a single key press."""
+        self._state = handle_key(self._state, key)
+
+    def feed_keys(self, keys: str) -> None:
+        """Process a sequence of key presses."""
+        for k in keys:
+            self.feed_key(k)
+
+    def set_buffer(self, buffer: str) -> None:
+        """Replace the buffer (used when syncing with external input)."""
+        self._state = self._state.with_buffer(buffer, cursor=len(buffer))
+
+    def snapshot(self) -> VimState:
+        """Return an immutable snapshot of the current state."""
+        return self._state

llm_code/vim/motions.py

@@ -0,0 +1,172 @@
+"""Vim motion functions.
+
+Each motion takes a VimState and count (or char for f/F/t/T) and returns
+the new cursor position (int). Motions are pure functions — they never
+mutate state.
+"""
+from __future__ import annotations
+
+import re
+from llm_code.vim.types import VimState
+
+
+# ── Character motions ─────────────────────────────────────────────
+
+def move_h(state: VimState, count: int) -> int:
+    return max(0, state.cursor - count)
+
+
+def move_l(state: VimState, count: int) -> int:
+    max_pos = max(0, len(state.buffer) - 1)
+    return min(max_pos, state.cursor + count)
+
+
+# ── Word motions (small word = split on non-alnum boundary) ───────
+
+_WORD_RE = re.compile(r"[A-Za-z0-9_]+|[^\sA-Za-z0-9_]+")
+
+
+def move_w(state: VimState, count: int) -> int:
+    pos = state.cursor
+    for _ in range(count):
+        matches = list(_WORD_RE.finditer(state.buffer))
+        found = False
+        for m in matches:
+            if m.start() > pos:
+                pos = m.start()
+                found = True
+                break
+        if not found:
+            break
+    return pos
+
+
+def move_b(state: VimState, count: int) -> int:
+    pos = state.cursor
+    for _ in range(count):
+        matches = list(_WORD_RE.finditer(state.buffer))
+        found = False
+        for m in reversed(matches):
+            if m.start() < pos:
+                pos = m.start()
+                found = True
+                break
+        if not found:
+            pos = 0
+            break
+    return pos
+
+
+def move_e(state: VimState, count: int) -> int:
+    pos = state.cursor
+    for _ in range(count):
+        matches = list(_WORD_RE.finditer(state.buffer))
+        found = False
+        for m in matches:
+            end = m.end() - 1
+            if end > pos:
+                pos = end
+                found = True
+                break
+        if not found:
+            break
+    return pos
+
+
+# ── WORD motions (big word = split on whitespace only) ────────────
+
+_BIGWORD_RE = re.compile(r"\S+")
+
+
+def move_W(state: VimState, count: int) -> int:
+    pos = state.cursor
+    for _ in range(count):
+        matches = list(_BIGWORD_RE.finditer(state.buffer))
+        found = False
+        for m in matches:
+            if m.start() > pos:
+                pos = m.start()
+                found = True
+                break
+        if not found:
+            break
+    return pos
+
+
+def move_B(state: VimState, count: int) -> int:
+    pos = state.cursor
+    for _ in range(count):
+        matches = list(_BIGWORD_RE.finditer(state.buffer))
+        found = False
+        for m in reversed(matches):
+            if m.start() < pos:
+                pos = m.start()
+                found = True
+                break
+        if not found:
+            pos = 0
+            break
+    return pos
+
+
+def move_E(state: VimState, count: int) -> int:
+    pos = state.cursor
+    for _ in range(count):
+        matches = list(_BIGWORD_RE.finditer(state.buffer))
+        found = False
+        for m in matches:
+            end = m.end() - 1
+            if end > pos:
+                pos = end
+                found = True
+                break
+        if not found:
+            break
+    return pos
+
+
+# ── Line motions ──────────────────────────────────────────────────
+
+def move_0(state: VimState) -> int:
+    return 0
+
+
+def move_caret(state: VimState) -> int:
+    stripped = state.buffer.lstrip()
+    return len(state.buffer) - len(stripped)
+
+
+def move_dollar(state: VimState) -> int:
+    return max(0, len(state.buffer) - 1)
+
+
+# ── Document motions ─────────────────────────────────────────────
+
+def move_gg(state: VimState) -> int:
+    return 0
+
+
+def move_G(state: VimState) -> int:
+    return max(0, len(state.buffer) - 1)
+
+
+# ── Char search motions ─────────────────────────────────────────
+
+def move_f(state: VimState, char: str) -> int:
+    idx = state.buffer.find(char, state.cursor + 1)
+    return idx if idx != -1 else state.cursor
+
+
+def move_F(state: VimState, char: str) -> int:
+    idx = state.buffer.rfind(char, 0, state.cursor)
+    return idx if idx != -1 else state.cursor
+
+
+def move_t(state: VimState, char: str) -> int:
+    idx = state.buffer.find(char, state.cursor + 1)
+    return idx - 1 if idx > 0 else state.cursor
+
+
+def move_T(state: VimState, char: str) -> int:
+    idx = state.buffer.rfind(char, 0, state.cursor)
+    return idx + 1 if idx != -1 else state.cursor

llm_code/vim/operators.py

@@ -0,0 +1,183 @@
+"""Vim operator functions.
+
+Operators take a VimState (and a region) and return a new VimState.
+All functions are pure — they never mutate the input state.
+"""
+from __future__ import annotations
+
+from dataclasses import replace
+
+from llm_code.vim.types import VimMode, VimState, Register
+
+
+def op_delete(state: VimState, start: int, end: int) -> VimState:
+    """Delete text in [start, end) and yank it into register."""
+    deleted = state.buffer[start:end]
+    new_buf = state.buffer[:start] + state.buffer[end:]
+    cursor = min(start, max(0, len(new_buf) - 1))
+    return replace(
+        state,
+        buffer=new_buf,
+        cursor=max(0, cursor),
+        register=Register(content=deleted),
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_change(state: VimState, start: int, end: int) -> VimState:
+    """Delete text in [start, end), yank it, and enter INSERT mode."""
+    deleted = state.buffer[start:end]
+    new_buf = state.buffer[:start] + state.buffer[end:]
+    return replace(
+        state,
+        buffer=new_buf,
+        cursor=start,
+        mode=VimMode.INSERT,
+        register=Register(content=deleted),
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_yank(state: VimState, start: int, end: int) -> VimState:
+    """Yank text in [start, end) into register without modifying buffer."""
+    yanked = state.buffer[start:end]
+    return replace(
+        state,
+        cursor=start,
+        register=Register(content=yanked),
+    )
+
+
+def op_delete_line(state: VimState) -> VimState:
+    """Delete entire buffer (dd)."""
+    return op_delete(state, 0, len(state.buffer))
+
+
+def op_change_line(state: VimState) -> VimState:
+    """Clear entire buffer and enter INSERT (cc)."""
+    return op_change(state, 0, len(state.buffer))
+
+
+def op_yank_line(state: VimState) -> VimState:
+    """Yank entire buffer (yy)."""
+    return op_yank(state, 0, len(state.buffer))
+
+
+def op_x(state: VimState) -> VimState:
+    """Delete character under cursor."""
+    if not state.buffer:
+        return state
+    end = min(state.cursor + 1, len(state.buffer))
+    return op_delete(state, state.cursor, end)
+
+
+def op_replace(state: VimState, char: str) -> VimState:
+    """Replace character under cursor with char."""
+    if not state.buffer or state.cursor >= len(state.buffer):
+        return state
+    new_buf = state.buffer[:state.cursor] + char + state.buffer[state.cursor + 1:]
+    return replace(
+        state,
+        buffer=new_buf,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_tilde(state: VimState) -> VimState:
+    """Toggle case of character under cursor and advance."""
+    if not state.buffer or state.cursor >= len(state.buffer):
+        return state
+    ch = state.buffer[state.cursor]
+    toggled = ch.lower() if ch.isupper() else ch.upper()
+    new_buf = state.buffer[:state.cursor] + toggled + state.buffer[state.cursor + 1:]
+    new_cursor = min(state.cursor + 1, max(0, len(new_buf) - 1))
+    return replace(
+        state,
+        buffer=new_buf,
+        cursor=new_cursor,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_join(state: VimState) -> VimState:
+    """Join lines (J). For single-line input buffer, this is a no-op."""
+    return state
+
+
+def op_put_after(state: VimState) -> VimState:
+    """Paste register content after cursor (p)."""
+    content = state.register.content
+    if not content:
+        return state
+    insert_pos = state.cursor + 1
+    new_buf = state.buffer[:insert_pos] + content + state.buffer[insert_pos:]
+    return replace(
+        state,
+        buffer=new_buf,
+        cursor=insert_pos + len(content) - 1,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_put_before(state: VimState) -> VimState:
+    """Paste register content before cursor (P)."""
+    content = state.register.content
+    if not content:
+        return state
+    insert_pos = state.cursor
+    new_buf = state.buffer[:insert_pos] + content + state.buffer[insert_pos:]
+    return replace(
+        state,
+        buffer=new_buf,
+        cursor=insert_pos + len(content) - 1,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_open_below(state: VimState) -> VimState:
+    """Open line below (o) — append newline and enter INSERT."""
+    return replace(
+        state,
+        cursor=len(state.buffer),
+        mode=VimMode.INSERT,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_open_above(state: VimState) -> VimState:
+    """Open line above (O) — prepend and enter INSERT."""
+    return replace(
+        state,
+        cursor=0,
+        mode=VimMode.INSERT,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_indent_right(state: VimState) -> VimState:
+    """Indent right (>>). Add 2 spaces."""
+    new_buf = "  " + state.buffer
+    return replace(
+        state,
+        buffer=new_buf,
+        cursor=state.cursor + 2,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )
+
+
+def op_indent_left(state: VimState) -> VimState:
+    """Indent left (<<). Remove up to 2 leading spaces."""
+    if state.buffer.startswith("  "):
+        new_buf = state.buffer[2:]
+        new_cursor = max(0, state.cursor - 2)
+    elif state.buffer.startswith(" "):
+        new_buf = state.buffer[1:]
+        new_cursor = max(0, state.cursor - 1)
+    else:
+        return state
+    return replace(
+        state,
+        buffer=new_buf,
+        cursor=new_cursor,
+        undo_stack=state.undo_stack + ((state.buffer, state.cursor),),
+    )

llm_code/vim/text_objects.py

@@ -0,0 +1,139 @@
+"""Vim text object selectors.
+
+Each function returns (start, end) as an exclusive range [start, end),
+or None if the text object cannot be found at the cursor position.
+"""
+from __future__ import annotations
+
+import re
+from llm_code.vim.types import VimState
+
+_WORD_RE = re.compile(r"[A-Za-z0-9_]+|[^\sA-Za-z0-9_]+")
+_BIGWORD_RE = re.compile(r"\S+")
+
+_BRACKET_PAIRS = {
+    "(": ("(", ")"),
+    ")": ("(", ")"),
+    "[": ("[", "]"),
+    "]": ("[", "]"),
+    "{": ("{", "}"),
+    "}": ("{", "}"),
+    "<": ("<", ">"),
+    ">": ("<", ">"),
+}
+
+
+def select_text_object(
+    state: VimState, obj: str
+) -> tuple[int, int] | None:
+    """Select a text object region.
+
+    Args:
+        state: Current vim state.
+        obj: Text object string, e.g. "iw", "a(", "i\"".
+
+    Returns:
+        (start, end) exclusive range, or None if not found.
+    """
+    if len(obj) < 2:
+        return None
+
+    kind = obj[0]  # 'i' (inner) or 'a' (around)
+    target = obj[1]
+
+    if target in ("w",):
+        return _select_word(state, kind, small=True)
+    if target in ("W",):
+        return _select_word(state, kind, small=False)
+    if target in ('"', "'"):
+        return _select_quoted(state, kind, target)
+    if target in _BRACKET_PAIRS:
+        return _select_bracket(state, kind, target)
+
+    return None
+
+
+def _select_word(
+    state: VimState, kind: str, *, small: bool
+) -> tuple[int, int] | None:
+    pattern = _WORD_RE if small else _BIGWORD_RE
+    for m in pattern.finditer(state.buffer):
+        if m.start() <= state.cursor < m.end():
+            start, end = m.start(), m.end()
+            if kind == "a":
+                # Include trailing whitespace
+                while end < len(state.buffer) and state.buffer[end] == " ":
+                    end += 1
+            return (start, end)
+    return None
+
+
+def _select_quoted(
+    state: VimState, kind: str, quote: str
+) -> tuple[int, int] | None:
+    buf = state.buffer
+    # Find opening quote before or at cursor
+    open_idx = buf.rfind(quote, 0, state.cursor + 1)
+    if open_idx == -1:
+        return None
+    # Find closing quote after opening
+    close_idx = buf.find(quote, open_idx + 1)
+    if close_idx == -1 or close_idx < state.cursor:
+        return None
+    if kind == "i":
+        return (open_idx + 1, close_idx)
+    return (open_idx, close_idx + 1)
+
+
+def _select_bracket(
+    state: VimState, kind: str, target: str
+) -> tuple[int, int] | None:
+    open_ch, close_ch = _BRACKET_PAIRS[target]
+    buf = state.buffer
+
+    # For angle brackets, use simple nearest-neighbor search
+    # (find nearest > to the left and < to the right of cursor)
+    if open_ch == "<":
+        open_idx = buf.rfind(close_ch, 0, state.cursor + 1)
+        if open_idx == -1:
+            return None
+        close_idx = buf.find(open_ch, state.cursor)
+        if close_idx == -1:
+            return None
+        if kind == "i":
+            return (open_idx + 1, close_idx)
+        return (open_idx, close_idx + 1)
+
+    # Search backward for opening bracket (with nesting support)
+    depth = 0
+    open_idx = -1
+    for i in range(state.cursor, -1, -1):
+        if buf[i] == close_ch:
+            depth += 1
+        elif buf[i] == open_ch:
+            if depth == 0:
+                open_idx = i
+                break
+            depth -= 1
+
+    if open_idx == -1:
+        return None
+
+    # Search forward for matching closing bracket
+    depth = 0
+    close_idx = -1
+    for i in range(open_idx, len(buf)):
+        if buf[i] == open_ch:
+            depth += 1
+        elif buf[i] == close_ch:
+            depth -= 1
+            if depth == 0:
+                close_idx = i
+                break
+
+    if close_idx == -1:
+        return None
+
+    if kind == "i":
+        return (open_idx + 1, close_idx)
+    return (open_idx, close_idx + 1)