iac-code 0.1.0__py3-none-any.whl

iac_code/ui/core/raw_input.py

@@ -0,0 +1,302 @@
+"""Raw terminal input capture using terminal raw mode."""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+import termios
+import time
+import tty
+from typing import Optional
+
+from iac_code.ui.core.key_event import KeyEvent
+
+_CURSOR_REPORT_RE = re.compile(rb"\x1b\[(\d+);(\d+)R")
+
+# SGR-encoded mouse event: ``\x1b[<button;col;row{M|m}``.  Only the
+# leading ``[<button;col;row`` portion is matched against the bytes
+# *after* the ESC byte, since we strip the ESC before parsing escape
+# sequences.
+_MOUSE_SGR_RE = re.compile(r"\[<(\d+);(\d+);(\d+)([Mm])")
+
+
+def query_cursor_row(fd: int, timeout: float = 0.1) -> int | None:
+    """Send Device Status Report 6 and parse the cursor's 1-indexed row.
+
+    The terminal must already be in raw mode — under cooked mode the
+    response (``\\x1b[<row>;<col>R``) wouldn't be readable until a
+    newline. Returns ``None`` if the terminal doesn't reply within
+    ``timeout``.
+    """
+    import select
+
+    try:
+        os.write(fd, b"\x1b[6n")
+    except OSError:
+        return None
+    buf = b""
+    deadline = time.monotonic() + timeout
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            break
+        ready, _, _ = select.select([fd], [], [], remaining)
+        if not ready:
+            break
+        try:
+            chunk = os.read(fd, 32)
+        except OSError:
+            break
+        if not chunk:
+            break
+        buf += chunk
+        if b"R" in buf:
+            break
+    m = _CURSOR_REPORT_RE.search(buf)
+    if m is None:
+        return None
+    try:
+        return int(m.group(1))
+    except ValueError:
+        return None
+
+
+# Mapping from escape sequence (after initial ESC byte) to key name
+_ESCAPE_SEQUENCES: dict[str, str] = {
+    "[A": "up",
+    "[B": "down",
+    "[C": "right",
+    "[D": "left",
+    "[H": "home",
+    "[F": "end",
+    "[3~": "delete",
+    "[5~": "pageup",
+    "[6~": "pagedown",
+    "OP": "f1",
+    "OQ": "f2",
+    "OR": "f3",
+    "OS": "f4",
+}
+
+
+class RawInputCapture:
+    """Context manager that puts the terminal into raw mode for key-by-key input.
+
+    Usage:
+        with RawInputCapture() as cap:
+            event = cap.read_key(timeout=1.0)
+    """
+
+    def __init__(self, fd: int | None = None) -> None:
+        self._fd = fd if fd is not None else sys.stdin.fileno()
+        self._old_settings: Optional[list] = None
+
+    def __enter__(self) -> "RawInputCapture":
+        try:
+            self._old_settings = termios.tcgetattr(self._fd)
+            tty.setraw(self._fd)
+            # Enable bracket paste mode so we can distinguish pasted text from typed input
+            os.write(self._fd, b"\033[?2004h")
+        except OSError:
+            # File descriptor may be invalid after interruption (e.g. double Ctrl+C)
+            self._old_settings = None
+            raise
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        try:
+            # Disable bracket paste mode
+            os.write(self._fd, b"\033[?2004l")
+        except OSError:
+            pass
+        if self._old_settings is not None:
+            try:
+                termios.tcsetattr(self._fd, termios.TCSADRAIN, self._old_settings)
+            except OSError:
+                pass
+
+    def read_key(self, timeout: Optional[float] = None) -> Optional[KeyEvent]:
+        """Read a single key press and return the corresponding KeyEvent.
+
+        Args:
+            timeout: Maximum seconds to wait. None means block indefinitely.
+                     Returns None if no key is available within the timeout.
+
+        Returns:
+            A KeyEvent, or None on timeout.
+        """
+        import select
+
+        if timeout is not None:
+            ready, _, _ = select.select([self._fd], [], [], timeout)
+            if not ready:
+                return None
+
+        first = os.read(self._fd, 1)
+        if not first:
+            return None
+
+        b = first[0]
+
+        # Escape — may begin a multi-byte sequence
+        if b == 27:
+            ready, _, _ = select.select([self._fd], [], [], 0.05)
+
+            if not ready:
+                # Standalone ESC
+                return self._byte_to_key_event(27)
+
+            # 64 bytes is enough for any reasonable single sequence
+            # including SGR mouse events at large coordinates.
+            rest = os.read(self._fd, 64)
+
+            # Bracket paste start: ESC [200~ — check raw bytes before decoding
+            # to avoid splitting multi-byte UTF-8 characters
+            if rest.startswith(b"[200~"):
+                pasted = self._read_bracketed_paste(rest[5:])
+                return KeyEvent(key="paste", char=pasted)
+
+            seq = rest.decode("utf-8", errors="replace")
+            return self._parse_escape_sequence(seq)
+
+        # Multi-byte UTF-8 character (Chinese, etc.)
+        if b >= 0x80:
+            return self._read_utf8_char(first)
+
+        return self._byte_to_key_event(b)
+
+    def _read_bracketed_paste(self, initial: bytes) -> str:
+        """Read pasted content until the bracket paste end sequence ESC [201~.
+
+        Works entirely with raw bytes to avoid splitting multi-byte UTF-8
+        characters during intermediate reads, and only decodes once all
+        content has been collected.
+
+        Args:
+            initial: Any leftover bytes already read after the start marker.
+
+        Returns:
+            The pasted text with the end marker stripped.
+        """
+        import select as _select
+
+        buf = initial
+        end_marker = b"\033[201~"
+
+        while end_marker not in buf:
+            ready, _, _ = _select.select([self._fd], [], [], 1.0)
+            if not ready:
+                break
+            chunk = os.read(self._fd, 4096)
+            if not chunk:
+                break
+            buf += chunk
+
+        idx = buf.find(end_marker)
+        if idx >= 0:
+            buf = buf[:idx]
+
+        text = buf.decode("utf-8", errors="replace")
+        # Normalize \r\n and \r to \n
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+        return text
+
+    def _read_utf8_char(self, first_byte: bytes) -> KeyEvent:
+        """Read remaining bytes of a multi-byte UTF-8 character."""
+        b = first_byte[0]
+        # Determine expected byte count from leading byte
+        if b < 0xC0:
+            # Continuation byte alone — shouldn't happen
+            return KeyEvent(key="unknown", char="", ctrl=False, alt=False, shift=False)
+        elif b < 0xE0:
+            remaining = 1
+        elif b < 0xF0:
+            remaining = 2
+        else:
+            remaining = 3
+
+        data = first_byte
+        for _ in range(remaining):
+            extra = os.read(self._fd, 1)
+            if not extra:
+                break
+            data += extra
+
+        try:
+            char = data.decode("utf-8")
+        except UnicodeDecodeError:
+            return KeyEvent(key="unknown", char="", ctrl=False, alt=False, shift=False)
+
+        return KeyEvent(key=char, char=char, ctrl=False, alt=False, shift=False)
+
+    @staticmethod
+    def _byte_to_key_event(b: int) -> KeyEvent:
+        """Convert a single byte value to a KeyEvent.
+
+        Args:
+            b: Integer byte value (0-255).
+
+        Returns:
+            The corresponding KeyEvent.
+        """
+        if b in (13, 10):
+            return KeyEvent(key="enter", char=chr(b))
+
+        if b == 9:
+            return KeyEvent(key="tab", char="\t")
+
+        if b == 127:
+            return KeyEvent(key="backspace", char=chr(127))
+
+        if b == 27:
+            return KeyEvent(key="escape", char="\x1b")
+
+        # Ctrl+a through ctrl+z (bytes 1-26, excluding 9, 10, 13)
+        if 1 <= b <= 26:
+            letter = chr(ord("a") + b - 1)
+            return KeyEvent(key=letter, char=chr(b), ctrl=True)
+
+        # Printable ASCII: 32-126
+        if 32 <= b <= 126:
+            char = chr(b)
+            shift = char.isupper()
+            return KeyEvent(key=char, char=char, shift=shift)
+
+        # Fallback
+        return KeyEvent(key="unknown", char=chr(b) if b < 256 else "")
+
+    @staticmethod
+    def _parse_escape_sequence(seq: str) -> KeyEvent:
+        """Parse the bytes following an ESC byte into a KeyEvent.
+
+        Args:
+            seq: String of characters that came after the ESC byte.
+
+        Returns:
+            The corresponding KeyEvent.
+        """
+        if seq in _ESCAPE_SEQUENCES:
+            return KeyEvent(key=_ESCAPE_SEQUENCES[seq], char="")
+
+        # SGR mouse event — only wheel up/down are useful here.  The
+        # ``rest`` buffer may contain multiple back-to-back wheel events
+        # when the user spins the wheel quickly; ``re.match`` picks up
+        # the first one and the trailing bytes are dropped (each tick
+        # is small, losing a few during a fast spin is fine).
+        m = _MOUSE_SGR_RE.match(seq)
+        if m is not None:
+            button = int(m.group(1))
+            if button == 64:
+                return KeyEvent(key="wheel_up", char="")
+            if button == 65:
+                return KeyEvent(key="wheel_down", char="")
+            # Other mouse events (clicks, motion) — pass through as a
+            # generic ``mouse`` event so callers can ignore them.
+            return KeyEvent(key="mouse", char="")
+
+        # Single printable char → alt+char
+        if len(seq) == 1 and 32 <= ord(seq) <= 126:
+            return KeyEvent(key=seq, char=seq, alt=True)
+
+        return KeyEvent(key="unknown", char="")

iac_code/ui/core/screen.py

@@ -0,0 +1,80 @@
+"""Screen management using the alternate screen buffer."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+
+
+class ScreenManager:
+    """Wraps a Rich Console to provide alternate-screen and clear/render helpers.
+
+    The alternate screen buffer allows the UI to restore the terminal to its
+    previous state when the application exits.
+    """
+
+    def __init__(self, console: Console) -> None:
+        self._console = console
+
+    def enter_alternate_screen(self) -> None:
+        """Switch to the terminal alternate screen buffer and move cursor home."""
+        self._console.file.write("\033[?1049h")
+        self._console.file.write("\033[H")
+        self._console.file.flush()
+
+    def leave_alternate_screen(self) -> None:
+        """Switch back from the alternate screen buffer to the normal screen."""
+        self._console.file.write("\033[?1049l")
+        self._console.file.flush()
+
+    def enable_mouse_tracking(self) -> None:
+        """Turn on basic + SGR-encoded mouse event reporting.
+
+        ``?1000h`` enables button (incl. wheel) press/release events;
+        ``?1006h`` switches the encoding to the SGR form
+        ``\\x1b[<button;col;row{M|m}`` so coordinates aren't bounded by
+        a single byte and event parsing is unambiguous.  Used by the
+        ``/resume`` preview to translate scroll-wheel ticks into
+        ``wheel_up``/``wheel_down`` ``KeyEvent``s while the alternate
+        screen is active.
+        """
+        self._console.file.write("\033[?1000h\033[?1006h")
+        self._console.file.flush()
+
+    def disable_mouse_tracking(self) -> None:
+        """Restore the terminal's pre-tracking mouse settings."""
+        self._console.file.write("\033[?1006l\033[?1000l")
+        self._console.file.flush()
+
+    def clear(self) -> None:
+        """Move cursor to top-left and erase the entire screen."""
+        self._console.file.write("\033[H\033[2J")
+        self._console.file.flush()
+
+    def clear_and_render(self, renderable: Any) -> None:
+        """Clear the screen and then render a Rich renderable.
+
+        Captures Rich's output and rewrites bare ``\\n`` as ``\\r\\n`` so the
+        render is correct under raw mode too — :class:`RawInputCapture`
+        clears OPOST, which would otherwise leave each line indented to the
+        end column of the previous one.
+
+        Args:
+            renderable: Any object that Rich Console can print.
+        """
+        with self._console.capture() as capture:
+            self._console.print(renderable)
+        text = capture.get().replace("\r\n", "\n").replace("\n", "\r\n")
+        self._console.file.write("\033[H\033[2J")
+        self._console.file.write(text)
+        self._console.file.flush()
+
+    def get_size(self) -> tuple[int, int]:
+        """Return the current terminal dimensions.
+
+        Returns:
+            A tuple of (cols, rows).
+        """
+        size = self._console.size
+        return size.width, size.height

iac_code/ui/dialogs/global_search.py

@@ -0,0 +1,178 @@
+"""GlobalSearch dialog — search file contents with ripgrep/grep (Ctrl+F)."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import Callable
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+from iac_code.i18n import _
+from iac_code.ui.components.fuzzy_picker import FuzzyPicker, PickerItem
+
+
+class GlobalSearch:
+    """Dialog for searching file contents using ripgrep (or grep fallback).
+
+    Selecting a result returns ``"file_path:line_number"`` and inserts
+    ``@relative_path:line_number`` into the input.
+    """
+
+    def __init__(
+        self,
+        root_dir: str,
+        on_select: Callable[[str], None],
+        on_cancel: Callable[[], None],
+        keybinding_manager: object | None = None,
+    ) -> None:
+        self._root_dir = os.path.abspath(root_dir)
+        self._on_select = on_select
+        self._on_cancel = on_cancel
+        self._km = keybinding_manager
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def run(self) -> str | None:
+        """Open the global-search picker and return ``file:line`` or None."""
+        result_holder: list[str] = []
+
+        def _on_select(item: PickerItem) -> None:
+            key = item.key  # "abs_path:lineno"
+            result_holder.append(key)
+            self._on_select(f"@{item.display}")
+
+        def _on_cancel() -> None:
+            self._on_cancel()
+
+        def _empty_message() -> str:
+            return _("No matching content")
+
+        picker = FuzzyPicker(
+            items=self._search,
+            on_select=_on_select,
+            on_cancel=_on_cancel,
+            title=_("Search in Files"),
+            placeholder=_("Type to search content..."),
+            empty_message=_("Enter search query"),
+            render_preview=self._render_preview,
+            debounce_ms=300,
+            keybinding_manager=self._km,
+        )
+        picker.run()
+
+        return result_holder[0] if result_holder else None
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _search(self, query: str) -> list[PickerItem]:
+        """Run ripgrep (or grep) and return PickerItems for each match."""
+        if not query:
+            return []
+
+        try:
+            output = self._run_search(query)
+        except Exception:
+            return []
+
+        return self._parse_results(output)
+
+    def _run_search(self, query: str) -> str:
+        """Execute ripgrep or grep and return stdout."""
+        if shutil.which("rg"):
+            cmd = [
+                "rg",
+                "--line-number",
+                "--no-heading",
+                "--color=never",
+                "--max-count=100",
+                query,
+                self._root_dir,
+            ]
+        else:
+            cmd = [
+                "grep",
+                "-rn",
+                "--include=*",
+                "--color=never",
+                query,
+                self._root_dir,
+            ]
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        return result.stdout
+
+    def _parse_results(self, output: str) -> list[PickerItem]:
+        """Parse ``filepath:linenum:matched_line`` output into PickerItems."""
+        items: list[PickerItem] = []
+        seen: set[str] = set()
+
+        for line in output.splitlines():
+            parts = line.split(":", 2)
+            if len(parts) < 3:
+                continue
+            file_path, lineno_str, matched_text = parts[0], parts[1], parts[2]
+            if not lineno_str.isdigit():
+                continue
+
+            key = f"{file_path}:{lineno_str}"
+            if key in seen:
+                continue
+            seen.add(key)
+
+            rel_path = os.path.relpath(file_path, self._root_dir)
+            display = f"{rel_path}:{lineno_str}  {matched_text.strip()}"
+
+            items.append(
+                PickerItem(
+                    key=key,
+                    display=display,
+                    metadata={"file_path": file_path, "lineno": int(lineno_str), "text": matched_text},
+                    filter_text=display,
+                )
+            )
+
+        return items
+
+    def _render_preview(self, item: PickerItem) -> Panel:
+        """Render matched line ±5 lines with syntax highlighting."""
+        meta = item.metadata
+        if not isinstance(meta, dict):
+            return Panel(Text(""), border_style="dim")
+
+        file_path: str = meta["file_path"]
+        lineno: int = meta["lineno"]
+        ext = os.path.splitext(file_path)[1].lstrip(".")
+
+        start = max(1, lineno - 5)
+        end = lineno + 5
+
+        try:
+            with open(file_path, encoding="utf-8", errors="replace") as fh:
+                all_lines = fh.readlines()
+            snippet_lines = all_lines[start - 1 : end]
+            content = "".join(snippet_lines)
+        except OSError:
+            content = ""
+
+        syntax = Syntax(
+            content,
+            ext or "text",
+            line_numbers=True,
+            start_line=start,
+            highlight_lines={lineno},
+        )
+        rel_path = os.path.relpath(file_path, self._root_dir)
+        return Panel(syntax, title=f"{rel_path}:{lineno}", border_style="dim")

iac_code/ui/dialogs/history_search.py

@@ -0,0 +1,100 @@
+"""HistorySearch dialog — search conversation history with Ctrl+R."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from rich.panel import Panel
+
+from iac_code.i18n import _
+from iac_code.ui.components.fuzzy_picker import FuzzyPicker, PickerItem
+
+
+class HistorySearch:
+    """Dialog for searching conversation history.
+
+    Shows user messages most-recent-first; selecting one returns the full text.
+    """
+
+    def __init__(
+        self,
+        messages: list[dict[str, Any]],
+        on_select: Callable[[str], None],
+        on_cancel: Callable[[], None],
+        keybinding_manager: object | None = None,
+    ) -> None:
+        self._messages = messages
+        self._on_select = on_select
+        self._on_cancel = on_cancel
+        self._km = keybinding_manager
+        self._result: str | None = None
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def run(self) -> str | None:
+        """Open the history search picker and return selected message text or None."""
+        items = self._build_items()
+        result_holder: list[str] = []
+        cancelled = [False]
+
+        def _on_select(item: PickerItem) -> None:
+            content: str = item.metadata
+            result_holder.append(content)
+            self._on_select(content)
+
+        def _on_cancel() -> None:
+            cancelled[0] = True
+            self._on_cancel()
+
+        picker = FuzzyPicker(
+            items=items,
+            on_select=_on_select,
+            on_cancel=_on_cancel,
+            title=_("Search Conversation History"),
+            placeholder=_("Type to search..."),
+            empty_message=_("No conversation history"),
+            render_preview=self._render_preview,
+            keybinding_manager=self._km,
+        )
+        picker.run()
+
+        return result_holder[0] if result_holder else None
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _build_items(self) -> list[PickerItem]:
+        """Extract user messages, most recent first, as PickerItems."""
+        items: list[PickerItem] = []
+        user_messages = [m for m in self._messages if m.get("role") == "user"]
+        # Most recent first
+        for i, msg in enumerate(reversed(user_messages)):
+            content = msg.get("content", "")
+            if isinstance(content, list):
+                # Handle structured content blocks
+                text_parts = [block.get("text", "") if isinstance(block, dict) else str(block) for block in content]
+                content = " ".join(text_parts)
+            content = str(content)
+            items.append(
+                PickerItem(
+                    key=f"history-{i}",
+                    display=content[:80],
+                    metadata=content,
+                    filter_text=content,
+                )
+            )
+        return items
+
+    def _render_preview(self, item: PickerItem) -> Panel:
+        """Render full message text in a panel."""
+        from rich.text import Text
+
+        content: str = item.metadata
+        return Panel(
+            Text(content),
+            title=_("Message Preview"),
+            border_style="dim",
+        )