llmcode-cli 1.0.0__py3-none-any.whl

llm_code/vim/transitions.py

@@ -0,0 +1,279 @@
+"""Vim state machine — key handling, mode transitions, repeat, undo.
+
+The central function is handle_key(state, key) -> VimState.
+It dispatches based on current mode and accumulated pending_keys.
+"""
+from __future__ import annotations
+
+from dataclasses import replace
+
+from llm_code.vim.types import VimMode, VimState, ParsedCommand
+from llm_code.vim.motions import (
+    move_h, move_l, move_w, move_b, move_e,
+    move_W, move_B, move_E,
+    move_0, move_caret, move_dollar,
+    move_gg, move_G,
+    move_f, move_F, move_t, move_T,
+)
+from llm_code.vim.operators import (
+    op_delete, op_change, op_yank,
+    op_delete_line, op_change_line, op_yank_line,
+    op_x, op_replace, op_tilde, op_join,
+    op_put_after, op_put_before,
+    op_open_below, op_open_above,
+    op_indent_right, op_indent_left,
+)
+from llm_code.vim.text_objects import select_text_object
+
+
+_MOTION_KEYS = frozenset("hlwbeWBE0^$")
+_OPERATOR_KEYS = frozenset("dcy")
+_SINGLE_CHAR_OPS = frozenset("xrR~JpPoO")
+
+
+def handle_key(state: VimState, key: str) -> VimState:
+    """Process a single key press and return the new VimState."""
+    if state.mode == VimMode.INSERT:
+        return _handle_insert(state, key)
+    return _handle_normal(state, key)
+
+
+def _handle_insert(state: VimState, key: str) -> VimState:
+    """INSERT mode: type characters, Esc to exit."""
+    if key == "\x1b":  # Escape
+        cursor = max(0, state.cursor - 1)
+        return replace(state, mode=VimMode.NORMAL, cursor=cursor)
+    if key in ("\x7f", "\x08"):  # Backspace
+        if state.cursor == 0:
+            return state
+        new_buf = state.buffer[:state.cursor - 1] + state.buffer[state.cursor:]
+        return replace(state, buffer=new_buf, cursor=state.cursor - 1)
+    # Regular character insertion
+    new_buf = state.buffer[:state.cursor] + key + state.buffer[state.cursor:]
+    return replace(state, buffer=new_buf, cursor=state.cursor + 1)
+
+
+def _handle_normal(state: VimState, key: str) -> VimState:
+    """NORMAL mode: motions, operators, mode switches."""
+    pending = state.pending_keys + key
+
+    # ── Count prefix ──────────────────────────────────────────────
+    if pending.isdigit() and pending != "0":
+        return replace(state, pending_keys=pending)
+
+    # ── Parse accumulated pending keys ────────────────────────────
+    count = 1
+    rest = pending
+    # Extract leading digits as count
+    i = 0
+    while i < len(rest) and rest[i].isdigit() and (i > 0 or rest[i] != "0"):
+        i += 1
+    if i > 0:
+        count = int(rest[:i])
+        rest = rest[i:]
+
+    if not rest:
+        return replace(state, pending_keys=pending)
+
+    # ── Dot repeat ────────────────────────────────────────────────
+    if rest == ".":
+        if state.last_command is not None:
+            return _replay_command(replace(state, pending_keys=""), state.last_command)
+        return replace(state, pending_keys="")
+
+    # ── Undo ──────────────────────────────────────────────────────
+    if rest == "u":
+        return replace(state.pop_undo(), pending_keys="")
+
+    # ── Mode switches ─────────────────────────────────────────────
+    if rest == "i":
+        return replace(state, mode=VimMode.INSERT, pending_keys="")
+    if rest == "a":
+        cursor = min(state.cursor + 1, len(state.buffer))
+        return replace(state, mode=VimMode.INSERT, cursor=cursor, pending_keys="")
+    if rest == "A":
+        return replace(state, mode=VimMode.INSERT, cursor=len(state.buffer), pending_keys="")
+    if rest == "I":
+        pos = move_caret(state)
+        return replace(state, mode=VimMode.INSERT, cursor=pos, pending_keys="")
+
+    # ── Single-key operators ──────────────────────────────────────
+    if rest == "x":
+        result = state
+        for _ in range(count):
+            result = op_x(result)
+        cmd = ParsedCommand(count=count, operator="x")
+        return replace(result, pending_keys="", last_command=cmd)
+
+    if rest == "~":
+        result = state
+        for _ in range(count):
+            result = op_tilde(result)
+        return replace(result, pending_keys="")
+
+    if rest == "J":
+        return replace(op_join(state), pending_keys="")
+
+    if rest == "p":
+        return replace(op_put_after(state), pending_keys="")
+
+    if rest == "P":
+        return replace(op_put_before(state), pending_keys="")
+
+    if rest == "o":
+        return replace(op_open_below(state), pending_keys="")
+
+    if rest == "O":
+        return replace(op_open_above(state), pending_keys="")
+
+    # ── Operator waiting for motion/text-object ───────────────────
+    if len(rest) == 1 and rest in _OPERATOR_KEYS:
+        return replace(state, pending_keys=pending)
+
+    # ── Line-wise doubled operators: dd, cc, yy ──────────────────
+    if rest == "dd":
+        result = op_delete_line(state)
+        cmd = ParsedCommand(count=count, operator="dd")
+        return replace(result, pending_keys="", last_command=cmd)
+    if rest == "cc":
+        result = op_change_line(state)
+        return replace(result, pending_keys="")
+    if rest == "yy":
+        result = op_yank_line(state)
+        return replace(result, pending_keys="")
+
+    # ── Indent ────────────────────────────────────────────────────
+    if rest == ">>":
+        result = state
+        for _ in range(count):
+            result = op_indent_right(result)
+        return replace(result, pending_keys="")
+    if rest == "<<":
+        result = state
+        for _ in range(count):
+            result = op_indent_left(result)
+        return replace(result, pending_keys="")
+    if rest in (">", "<"):
+        return replace(state, pending_keys=pending)
+
+    # ── Replace: r{char} ─────────────────────────────────────────
+    if len(rest) == 1 and rest == "r":
+        return replace(state, pending_keys=pending)
+    if len(rest) == 2 and rest[0] == "r":
+        result = op_replace(state, rest[1])
+        return replace(result, pending_keys="")
+
+    # ── Char-search: f/F/t/T{char} ──────────────────────────────
+    if len(rest) == 1 and rest in "fFtT":
+        return replace(state, pending_keys=pending)
+    if len(rest) == 2 and rest[0] in "fFtT":
+        motion_fn = {"f": move_f, "F": move_F, "t": move_t, "T": move_T}[rest[0]]
+        new_cursor = motion_fn(state, rest[1])
+        return replace(state, cursor=new_cursor, pending_keys="")
+
+    # ── g-prefixed: gg, gj, gk ──────────────────────────────────
+    if rest == "g":
+        return replace(state, pending_keys=pending)
+    if rest == "gg":
+        return replace(state, cursor=move_gg(state), pending_keys="")
+    if rest == "G":
+        return replace(state, cursor=move_G(state), pending_keys="")
+
+    # ── Operator + text object (e.g., "diw", "ca(") ─────────────
+    if len(rest) >= 3 and rest[0] in _OPERATOR_KEYS and rest[1] in "ia":
+        text_obj = rest[1:]
+        region = select_text_object(state, text_obj)
+        if region is None:
+            return replace(state, pending_keys="")
+        start, end = region
+        op_fn = {"d": op_delete, "c": op_change, "y": op_yank}[rest[0]]
+        result = op_fn(state, start, end)
+        cmd = ParsedCommand(count=count, operator=rest[0], text_object=text_obj)
+        return replace(result, pending_keys="", last_command=cmd)
+
+    # ── Operator + motion (e.g., "dw", "cw", "yw") ──────────────
+    if len(rest) >= 2 and rest[0] in _OPERATOR_KEYS:
+        motion_key = rest[1:]
+        # cw/cW acts like ce/cE in vim (stops before trailing whitespace)
+        effective_motion = motion_key
+        if rest[0] == "c" and motion_key == "w":
+            effective_motion = "e"
+        elif rest[0] == "c" and motion_key == "W":
+            effective_motion = "E"
+        new_cursor = _resolve_motion(state, effective_motion, count)
+        if new_cursor is not None:
+            start = min(state.cursor, new_cursor)
+            # For e/E motions, end is inclusive so add 1
+            end = max(state.cursor, new_cursor)
+            if effective_motion in ("e", "E"):
+                end = end + 1
+            op_fn = {"d": op_delete, "c": op_change, "y": op_yank}[rest[0]]
+            result = op_fn(state, start, end)
+            cmd = ParsedCommand(count=count, operator=rest[0], motion=motion_key)
+            return replace(result, pending_keys="", last_command=cmd)
+        # Unknown motion after operator — wait for more input or reset
+        if len(rest) < 4:
+            return replace(state, pending_keys=pending)
+        return replace(state, pending_keys="")
+
+    # ── Simple motions ────────────────────────────────────────────
+    new_cursor = _resolve_motion(state, rest, count)
+    if new_cursor is not None:
+        return replace(state, cursor=new_cursor, pending_keys="")
+
+    # ── Unknown key sequence — reset pending ──────────────────────
+    return replace(state, pending_keys="")
+
+
+def _resolve_motion(state: VimState, key: str, count: int) -> int | None:
+    """Resolve a motion key to a cursor position, or None if not a motion."""
+    if key == "h":
+        return move_h(state, count)
+    if key == "l":
+        return move_l(state, count)
+    if key == "w":
+        return move_w(state, count)
+    if key == "b":
+        return move_b(state, count)
+    if key == "e":
+        return move_e(state, count)
+    if key == "W":
+        return move_W(state, count)
+    if key == "B":
+        return move_B(state, count)
+    if key == "E":
+        return move_E(state, count)
+    if key == "0":
+        return move_0(state)
+    if key == "^":
+        return move_caret(state)
+    if key == "$":
+        return move_dollar(state)
+    return None
+
+
+def _replay_command(state: VimState, cmd: ParsedCommand) -> VimState:
+    """Replay a recorded command (dot repeat)."""
+    if cmd.operator == "x":
+        result = state
+        for _ in range(cmd.count):
+            result = op_x(result)
+        return replace(result, last_command=cmd)
+    if cmd.operator == "dd":
+        return replace(op_delete_line(state), last_command=cmd)
+    if cmd.operator and cmd.text_object:
+        region = select_text_object(state, cmd.text_object)
+        if region is None:
+            return state
+        start, end = region
+        op_fn = {"d": op_delete, "c": op_change, "y": op_yank}[cmd.operator]
+        return replace(op_fn(state, start, end), last_command=cmd)
+    if cmd.operator and cmd.motion:
+        new_cursor = _resolve_motion(state, cmd.motion, cmd.count)
+        if new_cursor is None:
+            return state
+        start = min(state.cursor, new_cursor)
+        end = max(state.cursor, new_cursor)
+        op_fn = {"d": op_delete, "c": op_change, "y": op_yank}[cmd.operator]
+        return replace(op_fn(state, start, end), last_command=cmd)
+    return state

llm_code/vim/types.py

@@ -0,0 +1,68 @@
+"""Core vim types — mode, state, register, parsed command."""
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass, replace
+
+
+class VimMode(enum.Enum):
+    NORMAL = "normal"
+    INSERT = "insert"
+
+
+@dataclass(frozen=True)
+class Register:
+    content: str = ""
+
+
+@dataclass(frozen=True)
+class ParsedCommand:
+    count: int = 1
+    operator: str | None = None
+    motion: str | None = None
+    text_object: str | None = None
+
+
+@dataclass(frozen=True)
+class VimState:
+    buffer: str
+    cursor: int
+    mode: VimMode
+    register: Register
+    undo_stack: tuple[tuple[str, int], ...] = ()
+    last_command: ParsedCommand | None = None
+    pending_keys: str = ""
+
+    def with_cursor(self, pos: int) -> VimState:
+        clamped = max(0, min(pos, len(self.buffer)))
+        return replace(self, cursor=clamped)
+
+    def with_buffer(self, buf: str, cursor: int | None = None) -> VimState:
+        c = cursor if cursor is not None else self.cursor
+        clamped = max(0, min(c, len(buf)))
+        return replace(self, buffer=buf, cursor=clamped)
+
+    def with_mode(self, mode: VimMode) -> VimState:
+        return replace(self, mode=mode)
+
+    def with_register(self, content: str) -> VimState:
+        return replace(self, register=Register(content=content))
+
+    def push_undo(self) -> VimState:
+        entry = (self.buffer, self.cursor)
+        return replace(self, undo_stack=self.undo_stack + (entry,))
+
+    def pop_undo(self) -> VimState:
+        if not self.undo_stack:
+            return self
+        *rest, (buf, cur) = self.undo_stack
+        return replace(self, buffer=buf, cursor=cur, undo_stack=tuple(rest))
+
+
+def initial_state(buffer: str) -> VimState:
+    return VimState(
+        buffer=buffer,
+        cursor=len(buffer),
+        mode=VimMode.INSERT,
+        register=Register(),
+    )

llm_code/voice/__init__.py

@@ -0,0 +1 @@
+"""Voice input (STT) module for llm-code."""

llm_code/voice/languages.py

@@ -0,0 +1,43 @@
+"""Supported STT language codes."""
+from __future__ import annotations
+
+LANGUAGE_MAP: dict[str, str] = {
+    "en": "English",
+    "zh": "Chinese",
+    "ja": "Japanese",
+    "ko": "Korean",
+    "es": "Spanish",
+    "fr": "French",
+    "de": "German",
+    "pt": "Portuguese",
+    "ru": "Russian",
+    "ar": "Arabic",
+    "it": "Italian",
+    "nl": "Dutch",
+    "pl": "Polish",
+    "sv": "Swedish",
+    "da": "Danish",
+    "no": "Norwegian",
+    "fi": "Finnish",
+    "tr": "Turkish",
+    "th": "Thai",
+    "vi": "Vietnamese",
+    "id": "Indonesian",
+    "ms": "Malay",
+    "hi": "Hindi",
+    "uk": "Ukrainian",
+    "cs": "Czech",
+    "el": "Greek",
+    "he": "Hebrew",
+    "hu": "Hungarian",
+    "ro": "Romanian",
+}
+
+
+def validate_language(code: str) -> str:
+    """Return the code if valid, raise ValueError otherwise."""
+    if code not in LANGUAGE_MAP:
+        raise ValueError(
+            f"Unsupported language code: {code!r}. Valid: {sorted(LANGUAGE_MAP)}"
+        )
+    return code

llm_code/voice/recorder.py

@@ -0,0 +1,136 @@
+"""Audio recording with sounddevice (primary) and sox/arecord fallback."""
+from __future__ import annotations
+
+import enum
+import shutil
+import subprocess
+import threading
+import time
+
+
+class RecorderBackend(enum.Enum):
+    SOUNDDEVICE = "sounddevice"
+    SOX = "sox"
+    ARECORD = "arecord"
+
+
+def detect_backend() -> RecorderBackend:
+    """Detect the best available recording backend."""
+    try:
+        import sounddevice as _sd  # noqa: F401
+        return RecorderBackend.SOUNDDEVICE
+    except (ImportError, TypeError):
+        pass
+
+    if shutil.which("sox"):
+        return RecorderBackend.SOX
+    if shutil.which("arecord"):
+        return RecorderBackend.ARECORD
+
+    raise RuntimeError(
+        "No audio recording backend available. "
+        "Install sounddevice (`pip install llm-code[voice]`) or ensure sox/arecord is on PATH."
+    )
+
+
+class AudioRecorder:
+    """Records 16kHz mono 16-bit PCM audio from the microphone."""
+
+    def __init__(
+        self,
+        backend: RecorderBackend | None = None,
+        sample_rate: int = 16000,
+        channels: int = 1,
+    ):
+        self._backend = backend or RecorderBackend.SOUNDDEVICE
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self._buffer = bytearray()
+        self._recording = False
+        self._start_time: float | None = None
+        self._stream = None
+        self._process: subprocess.Popen | None = None
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        """Begin recording audio."""
+        self._buffer = bytearray()
+        self._recording = True
+        self._start_time = time.monotonic()
+
+        if self._backend == RecorderBackend.SOUNDDEVICE:
+            self._start_sounddevice()
+        elif self._backend == RecorderBackend.SOX:
+            self._start_external([
+                "sox", "-d", "-t", "raw", "-r", str(self.sample_rate),
+                "-e", "signed", "-b", "16", "-c", str(self.channels), "-",
+            ])
+        elif self._backend == RecorderBackend.ARECORD:
+            self._start_external([
+                "arecord", "-f", "S16_LE", "-r", str(self.sample_rate),
+                "-c", str(self.channels), "-t", "raw", "-",
+            ])
+
+    def stop(self) -> bytes:
+        """Stop recording and return the captured PCM bytes."""
+        if not self._recording:
+            return b""
+
+        self._recording = False
+
+        if self._backend == RecorderBackend.SOUNDDEVICE and self._stream is not None:
+            self._stream.stop()
+            self._stream.close()
+            self._stream = None
+        elif self._process is not None:
+            self._process.terminate()
+            self._process.wait(timeout=3)
+            self._process = None
+        if self._thread is not None:
+            self._thread.join(timeout=3)
+            self._thread = None
+
+        result = bytes(self._buffer)
+        self._buffer = bytearray()
+        self._start_time = None
+        return result
+
+    def elapsed_seconds(self) -> float:
+        """Return seconds since recording started, or 0.0 if not recording."""
+        if self._start_time is None or not self._recording:
+            return 0.0
+        return time.monotonic() - self._start_time
+
+    def _start_sounddevice(self) -> None:
+        import sounddevice as sd  # type: ignore[import]
+
+        def callback(indata, frames, time_info, status):
+            if self._recording:
+                self._buffer.extend(indata.tobytes())
+
+        self._stream = sd.RawInputStream(
+            samplerate=self.sample_rate,
+            channels=self.channels,
+            dtype="int16",
+            callback=callback,
+        )
+        self._stream.start()
+
+    def _start_external(self, cmd: list[str]) -> None:
+        self._process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+        )
+
+        def _read_loop():
+            assert self._process is not None
+            assert self._process.stdout is not None
+            while self._recording:
+                chunk = self._process.stdout.read(4096)
+                if not chunk:
+                    break
+                self._buffer.extend(chunk)
+
+        self._thread = threading.Thread(target=_read_loop, daemon=True)
+        self._thread.start()

llm_code/voice/stt.py

@@ -0,0 +1,36 @@
+"""STT engine protocol and factory."""
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from llm_code.runtime.config import VoiceConfig
+
+
+@runtime_checkable
+class STTEngine(Protocol):
+    """Protocol for speech-to-text backends."""
+
+    def transcribe(self, audio_bytes: bytes, language: str) -> str:
+        """Transcribe raw PCM audio bytes to text."""
+        ...
+
+
+def create_stt_engine(config: VoiceConfig) -> STTEngine:
+    """Factory: create an STT engine from config."""
+    backend = config.backend
+
+    if backend == "whisper":
+        from llm_code.voice.stt_whisper import WhisperSTT
+        return WhisperSTT(url=config.whisper_url)
+
+    if backend == "google":
+        from llm_code.voice.stt_google import GoogleSTT
+        return GoogleSTT(language_code=config.google_language_code or config.language)
+
+    if backend == "anthropic":
+        from llm_code.voice.stt_anthropic import AnthropicSTT
+        return AnthropicSTT(ws_url=config.anthropic_ws_url)
+
+    raise ValueError(
+        f"Unknown STT backend: {backend!r}. Valid: whisper, google, anthropic"
+    )

llm_code/voice/stt_anthropic.py

@@ -0,0 +1,66 @@
+"""Anthropic WebSocket STT backend."""
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import os
+
+
+def _ws_transcribe(ws_url: str, audio_bytes: bytes, language: str) -> str:
+    """Connect to Anthropic voice_stream WebSocket and transcribe."""
+    return asyncio.get_event_loop().run_until_complete(
+        _async_ws_transcribe(ws_url, audio_bytes, language)
+    )
+
+
+async def _async_ws_transcribe(ws_url: str, audio_bytes: bytes, language: str) -> str:
+    """Async WebSocket transcription."""
+    import websockets  # type: ignore[import]
+
+    api_key = os.environ.get("ANTHROPIC_API_KEY", "")
+    url = f"{ws_url}/v1/voice_stream"
+
+    async with websockets.connect(
+        url,
+        additional_headers={"x-api-key": api_key, "anthropic-version": "2024-01-01"},
+    ) as ws:
+        await ws.send(json.dumps({
+            "type": "audio_start",
+            "language": language,
+            "encoding": "pcm_s16le",
+            "sample_rate": 16000,
+        }))
+
+        # Send audio in chunks
+        chunk_size = 32000  # 1 second of 16kHz 16-bit
+        for i in range(0, len(audio_bytes), chunk_size):
+            chunk = audio_bytes[i: i + chunk_size]
+            await ws.send(json.dumps({
+                "type": "audio_data",
+                "data": base64.b64encode(chunk).decode(),
+            }))
+
+        await ws.send(json.dumps({"type": "audio_end"}))
+
+        # Collect transcription
+        transcript_parts: list[str] = []
+        async for msg in ws:
+            data = json.loads(msg)
+            if data.get("type") == "transcription":
+                transcript_parts.append(data.get("text", ""))
+            elif data.get("type") == "transcription_complete":
+                break
+
+        return " ".join(transcript_parts).strip()
+
+
+class AnthropicSTT:
+    """Transcribe audio via Anthropic WebSocket voice_stream."""
+
+    def __init__(self, ws_url: str = "wss://api.anthropic.com"):
+        self._ws_url = ws_url
+
+    def transcribe(self, audio_bytes: bytes, language: str) -> str:
+        """Send audio to Anthropic WebSocket STT."""
+        return _ws_transcribe(self._ws_url, audio_bytes, language)

llm_code/voice/stt_google.py

@@ -0,0 +1,32 @@
+"""Google Cloud Speech STT backend."""
+from __future__ import annotations
+
+
+def _get_client():
+    """Lazy import and create Google Speech client."""
+    from google.cloud import speech  # type: ignore[import]
+    return speech.SpeechClient()
+
+
+class GoogleSTT:
+    """Transcribe audio via Google Cloud Speech-to-Text API."""
+
+    def __init__(self, language_code: str = "en-US"):
+        self._language_code = language_code
+
+    def transcribe(self, audio_bytes: bytes, language: str) -> str:
+        """Send PCM audio to Google Cloud Speech."""
+        from google.cloud import speech  # type: ignore[import]
+
+        client = _get_client()
+        audio = speech.RecognitionAudio(content=audio_bytes)
+        config = speech.RecognitionConfig(
+            encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
+            sample_rate_hertz=16000,
+            language_code=self._language_code if self._language_code else language,
+        )
+        response = client.recognize(config=config, audio=audio)
+
+        if not response.results:
+            return ""
+        return response.results[0].alternatives[0].transcript