aria-code 0.52.0__py3-none-any.whl

aria_code/ui/console.py

@@ -0,0 +1,281 @@
+"""Shared Rich console, availability flags, and ESC-key watcher.
+
+Import this instead of repeating the try/except blocks everywhere:
+
+    from ui.console import console, HAS_RICH, HAS_PT, _SYNTAX_THEME
+    from ui.console import _EscWatcher, _esc_watcher
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+import sys
+import threading
+import time
+from typing import Optional
+
+# ── Rich ───────────────────────────────────────────────────────────────────────
+
+try:
+    from rich.console import Console
+    from rich.markdown import Markdown
+    from rich.live import Live
+    from rich.text import Text
+    from rich.status import Status
+    from rich.syntax import Syntax
+    from rich.panel import Panel
+    from rich.rule import Rule
+    from rich import box as rich_box
+    from rich.theme import Theme
+    HAS_RICH = True
+except ImportError:
+    HAS_RICH = False
+
+# ── prompt_toolkit ─────────────────────────────────────────────────────────────
+
+try:
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.completion import Completer, Completion
+    from prompt_toolkit.formatted_text import HTML
+    from prompt_toolkit.history import FileHistory
+    from prompt_toolkit.styles import Style as PTStyle
+    HAS_PT = True
+except ImportError:
+    HAS_PT = False
+
+# ── Console singleton ──────────────────────────────────────────────────────────
+
+_SYNTAX_THEME: str = "monokai"
+
+
+def _detect_terminal_theme() -> str:
+    """Return a best-effort terminal theme: ``dark`` or ``light``."""
+    explicit = os.getenv("ARIA_RICH_THEME", os.getenv("ARIA_INPUT_THEME", "")).strip().lower()
+    if explicit in {"dark", "light"}:
+        return explicit
+    colorfgbg = os.getenv("COLORFGBG", "")
+    if colorfgbg:
+        try:
+            return "dark" if int(colorfgbg.split(";")[-1]) < 8 else "light"
+        except ValueError:
+            pass
+    # macOS appearance is not the Terminal profile appearance. Apple Terminal's
+    # default Basic profile is light even when the OS itself is in dark mode;
+    # using AppleInterfaceStyle here produced pale dark-theme headings on white.
+    if os.getenv("TERM_PROGRAM", "") == "Apple_Terminal":
+        return "light"
+    # os.uname() is Unix-only — doesn't exist on Windows at all. sys.platform
+    # is the portable equivalent and already covers the "Darwin" case here.
+    if sys.platform == "darwin":
+        try:
+            r = subprocess.run(
+                ["defaults", "read", "-g", "AppleInterfaceStyle"],
+                capture_output=True, text=True, timeout=0.2, check=False,
+            )
+            return "dark" if (r.returncode == 0 and "dark" in r.stdout.lower()) else "light"
+        except Exception:
+            pass
+    return "dark"
+
+
+def _build_rich_theme(theme: str) -> "Theme":
+    """Build a Markdown palette with enough contrast for the terminal theme."""
+    if theme == "light":
+        return Theme({
+            "markdown.h1": "bold #24292f",
+            "markdown.h2": "bold #24292f",
+            "markdown.h3": "bold #8a5a00",
+            "markdown.h4": "bold #8a5a00",
+            "markdown.h5": "bold #8a5a00",
+            "markdown.h6": "bold #8a5a00",
+            "markdown.heading": "bold #24292f",
+            "markdown.code": "bold #8a5a00",
+            "markdown.code_inline": "bold #8a5a00",
+            "markdown.link": "underline #0969da",
+            "markdown.link_url": "underline #57606a",
+            "markdown.item.bullet": "bold #8a5a00",
+            "markdown.item.number": "bold #8a5a00",
+            "markdown.table.header": "bold #8a5a00",
+            "markdown.table.border": "#8c959f",
+            "markdown.hr": "#8c959f",
+            "markdown.strong": "bold #1f2328",
+            "markdown.em": "italic #57606a",
+            "markdown.block_quote": "#6e7781",
+        })
+    return Theme({
+        # Keep Markdown close to the terminal palette: neutral text, copper
+        # accents, no blue/purple headings, and no black inline-code blocks.
+        "markdown.h1": "bold #e8e0d4",
+        "markdown.h2": "bold #e8e0d4",
+        "markdown.h3": "bold #d6ba8e",
+        "markdown.h4": "bold #d6ba8e",
+        "markdown.h5": "bold #d6ba8e",
+        "markdown.h6": "bold #d6ba8e",
+        "markdown.heading": "bold #e8e0d4",
+        "markdown.code": "bold #c08050",
+        "markdown.code_inline": "bold #c08050",
+        "markdown.link": "underline #c08050",
+        "markdown.link_url": "underline #8f867a",
+        "markdown.item.bullet": "bold #d6ba8e",
+        "markdown.item.number": "bold #d6ba8e",
+        "markdown.table.header": "bold #d6ba8e",
+        "markdown.table.border": "#6f675d",
+        "markdown.hr": "#6f675d",
+        "markdown.strong": "bold #e8e0d4",
+        "markdown.em": "italic #c7beb2",
+        "markdown.block_quote": "#a8a096",
+    })
+
+
+if HAS_RICH:
+    ARIA_RICH_THEME_NAME = _detect_terminal_theme()
+    ARIA_RICH_THEME = _build_rich_theme(ARIA_RICH_THEME_NAME)
+    console = Console(highlight=False, theme=ARIA_RICH_THEME)
+
+    def make_markdown(markup: str) -> Markdown:
+        """Create Markdown with Aria's low-saturation terminal theme."""
+        from ui.render.output import adapt_markdown_for_width
+
+        markup = adapt_markdown_for_width(markup, getattr(console, "width", 80))
+        return Markdown(
+            markup,
+            code_theme="bw",
+            inline_code_theme="bw",
+        )
+else:
+    class _FallbackConsole:
+        def print(self, *a, **kw):
+            print(*[str(x) for x in a])
+
+        def input(self, prompt: str = "") -> str:
+            return input(prompt)
+
+        def status(self, msg: str):
+            class _Ctx:
+                def __enter__(self):
+                    print(msg)
+                    return self
+                def __exit__(self, *a):
+                    pass
+                def update(self, msg: str):
+                    print(msg)
+            return _Ctx()
+
+    console = _FallbackConsole()
+
+    def make_markdown(markup: str) -> str:
+        return markup
+
+# ── termios / raw-mode availability ───────────────────────────────────────────
+
+try:
+    import termios
+    import tty
+    import select as _select
+    _HAS_TERMIOS = True
+except ImportError:
+    _HAS_TERMIOS = False
+
+
+# ── ESC-key watcher ───────────────────────────────────────────────────────────
+
+class _EscWatcher:
+    """Background thread that watches for ESC key press to cancel streaming."""
+
+    def __init__(self):
+        self._active = False
+        self._paused = False
+        self._thread: Optional[threading.Thread] = None
+        self._old_settings = None
+        self._cancel_event: Optional[asyncio.Event] = None
+        self._fd: Optional[int] = None
+
+    def start(self, cancel_event: asyncio.Event):
+        if not _HAS_TERMIOS or not sys.stdin.isatty():
+            return
+        self._cancel_event = cancel_event
+        self._fd = sys.stdin.fileno()
+        try:
+            self._old_settings = termios.tcgetattr(self._fd)
+            tty.setcbreak(self._fd)
+        except Exception:
+            self._old_settings = None
+            return
+        self._active = True
+        self._paused = False
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def pause(self):
+        self._paused = True
+        if self._old_settings and self._fd is not None:
+            try:
+                termios.tcsetattr(self._fd, termios.TCSADRAIN, self._old_settings)
+            except Exception:
+                pass
+
+    def resume(self):
+        if not self._active or not _HAS_TERMIOS or self._fd is None:
+            return
+        if self._cancel_event and self._cancel_event.is_set():
+            return
+        try:
+            termios.tcflush(self._fd, termios.TCIFLUSH)
+            self._old_settings = termios.tcgetattr(self._fd)
+            tty.setcbreak(self._fd)
+        except Exception:
+            return
+        self._paused = False
+
+    def stop(self):
+        self._active = False
+        self._paused = False
+        if self._old_settings and self._fd is not None:
+            try:
+                termios.tcsetattr(self._fd, termios.TCSADRAIN, self._old_settings)
+            except Exception:
+                pass
+            self._old_settings = None
+        if self._thread:
+            self._thread.join(timeout=0.3)
+            self._thread = None
+
+    def _run(self):
+        fd = self._fd
+        try:
+            while self._active:
+                if self._paused:
+                    time.sleep(0.1)
+                    continue
+                try:
+                    ready, _, _ = _select.select([fd], [], [], 0.15)
+                except (ValueError, OSError):
+                    break
+                if not self._active or self._paused:
+                    continue
+                if ready:
+                    try:
+                        ch = os.read(fd, 1)
+                    except OSError:
+                        break
+                    if ch == b'\x1b':
+                        try:
+                            r2, _, _ = _select.select([fd], [], [], 0.05)
+                        except (ValueError, OSError):
+                            break
+                        if r2:
+                            try:
+                                os.read(fd, 16)
+                            except OSError:
+                                pass
+                        else:
+                            if self._cancel_event:
+                                self._cancel_event.set()
+                            self._active = False
+        except Exception:
+            pass
+
+
+_esc_watcher = _EscWatcher()

aria_code/ui/image_render.py

@@ -0,0 +1,243 @@
+"""Terminal image rendering — show a real PNG in the terminal, with fallback.
+
+Three layered techniques, best-first (exactly what chafa/viu/timg do):
+
+  1. iTerm2 inline images  (OSC 1337)         — iTerm2, WezTerm, ghostty
+  2. Kitty graphics protocol                   — kitty, ghostty
+  3. Half-block + truecolor downscale (``▀``)   — any 24-bit colour terminal
+
+Layer 3 is the universal floor: it resizes the image and prints one ``▀`` per
+cell, packing two vertical pixels into each character (foreground = top pixel,
+background = bottom pixel). Pixel-art sources render almost perfectly this way.
+
+Used for the startup mascot banner, and reusable for ``/vision`` previews,
+``/screenshot`` echoes, and inline quant charts.
+
+CLI:  python3 -m ui.image_render <path> [width] [--half|--iterm|--kitty]
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+import sys
+
+try:
+    from PIL import Image
+    _HAS_PIL = True
+except Exception:  # pragma: no cover - PIL is a hard dep for this module
+    _HAS_PIL = False
+
+
+# ── Terminal capability detection ────────────────────────────────────────────
+def _in_tmux() -> bool:
+    # Image protocols need passthrough wrapping inside tmux; play safe and fall
+    # back to half-blocks rather than spraying escape bytes the pane won't eat.
+    return bool(os.environ.get("TMUX"))
+
+
+def supports_iterm() -> bool:
+    if _in_tmux():
+        return False
+    if os.environ.get("TERM_PROGRAM") in ("iTerm.app", "WezTerm", "ghostty"):
+        return True
+    return bool(os.environ.get("ITERM_SESSION_ID"))
+
+
+def supports_kitty() -> bool:
+    if _in_tmux():
+        return False
+    if os.environ.get("KITTY_WINDOW_ID"):
+        return True
+    return os.environ.get("TERM") == "xterm-kitty"
+
+
+def supports_truecolor() -> bool:
+    if os.environ.get("COLORTERM") in ("truecolor", "24bit"):
+        return True
+    # Most modern terminals are truecolor even without advertising it; only the
+    # genuinely ancient (TERM=dumb / linux console) are not.
+    return os.environ.get("TERM", "") not in ("", "dumb", "linux")
+
+
+def best_method() -> str:
+    """Return the best available render method for the current terminal."""
+    if supports_iterm():
+        return "iterm"
+    if supports_kitty():
+        return "kitty"
+    if supports_truecolor():
+        return "half"
+    return "none"
+
+
+# ── Protocol emitters ────────────────────────────────────────────────────────
+def _iterm_sequence(png_bytes: bytes, cells_wide: int) -> str:
+    """iTerm2 OSC 1337 inline image. Width in character cells, height auto."""
+    b64 = base64.b64encode(png_bytes).decode()
+    return (
+        f"\x1b]1337;File=inline=1;width={cells_wide};"
+        f"preserveAspectRatio=1:{b64}\x07"
+    )
+
+
+def _kitty_sequence(png_bytes: bytes, cells_wide: int) -> str:
+    """Kitty graphics protocol, PNG payload (f=100), chunked at 4096 bytes."""
+    b64 = base64.b64encode(png_bytes).decode()
+    chunk = 4096
+    parts: list[str] = []
+    i = 0
+    first = True
+    while i < len(b64):
+        piece = b64[i : i + chunk]
+        i += chunk
+        more = 1 if i < len(b64) else 0
+        if first:
+            # a=T transmit+display, f=100 PNG, c=columns to scale into
+            ctrl = f"a=T,f=100,c={cells_wide},m={more}"
+            first = False
+        else:
+            ctrl = f"m={more}"
+        parts.append(f"\x1b_G{ctrl};{piece}\x1b\\")
+    return "".join(parts)
+
+
+# ── Half-block fallback (universal) ──────────────────────────────────────────
+_UPPER = "▀"  # ▀ upper half block
+
+
+def autocrop(img: "Image.Image", tol: int = 18, pad: int = 1) -> "Image.Image":
+    """Trim a uniform border (e.g. the robot's black canvas) so the subject
+    fills the frame. Background colour is sampled from the top-left pixel;
+    pixels within ``tol`` of it are treated as border. Falls back to the
+    original image if nothing distinct is found.
+    """
+    from PIL import ImageChops, Image as _I
+
+    rgb = img.convert("RGB")
+    bg = _I.new("RGB", rgb.size, rgb.getpixel((0, 0)))
+    diff = ImageChops.difference(rgb, bg).convert("L")
+    box = diff.point(lambda p: 255 if p > tol else 0).getbbox()
+    if not box:
+        return img
+    l, t, r, b = box
+    l, t = max(0, l - pad), max(0, t - pad)
+    r, b = min(img.width, r + pad), min(img.height, b + pad)
+    return img.crop((l, t, r, b))
+
+
+def half_block_render(img: "Image.Image", cells_wide: int = 36) -> str:
+    """Render a PIL image as ``▀`` half-blocks with 24-bit colour.
+
+    Each character is 1 pixel wide and 2 pixels tall, so a square source maps to
+    ``cells_wide`` columns × ``cells_wide // 2`` rows. Foreground paints the top
+    pixel, background the bottom one.
+    """
+    img = img.convert("RGB")
+    w, h = img.size
+    # Sample at cells_wide × (2 px per row). Rows chosen to preserve aspect once
+    # the 1:2 cell shape is accounted for, so on-screen proportions match.
+    px_w = max(1, cells_wide)
+    px_h = max(2, round(px_w * h / w))
+    if px_h % 2:
+        px_h += 1  # even rows so every cell has a top+bottom pixel
+    small = img.resize((px_w, px_h), Image.LANCZOS)
+    px = small.load()
+
+    lines: list[str] = []
+    for row in range(0, px_h, 2):
+        cells: list[str] = []
+        for x in range(px_w):
+            tr, tg, tb = px[x, row]
+            br, bg, bb = px[x, row + 1]
+            cells.append(
+                f"\x1b[38;2;{tr};{tg};{tb};48;2;{br};{bg};{bb}m{_UPPER}"
+            )
+        cells.append("\x1b[0m")
+        lines.append("".join(cells))
+    return "\n".join(lines)
+
+
+# ── Public entry point ───────────────────────────────────────────────────────
+def render_image(
+    path: str,
+    cells_wide: int = 36,
+    method: str | None = None,
+    crop: bool = True,
+) -> str | None:
+    """Return a printable string that draws ``path`` in the terminal.
+
+    ``method`` forces one of ``iterm`` / ``kitty`` / ``half``; default auto-detects.
+    ``crop`` trims a uniform border first so the subject fills the frame.
+    Returns ``None`` if the image can't be loaded or no method is usable.
+    """
+    chosen = method or best_method()
+
+    # Protocol path (iTerm2/Kitty) only needs the raw PNG bytes — the terminal
+    # scales them. PIL is optional here: with it we autocrop so the subject
+    # fills the frame; without it we send the file as-is. This means the real
+    # image still shows even when Pillow isn't installed in the venv.
+    if chosen in ("iterm", "kitty"):
+        try:
+            if _HAS_PIL:
+                import io
+
+                img = Image.open(path)
+                if crop:
+                    try:
+                        img = autocrop(img)
+                    except Exception:
+                        pass
+                buf = io.BytesIO()
+                img.convert("RGB").save(buf, format="PNG")
+                data = buf.getvalue()
+            else:
+                with open(path, "rb") as fh:
+                    data = fh.read()
+            if chosen == "iterm":
+                return _iterm_sequence(data, cells_wide)
+            return _kitty_sequence(data, cells_wide)
+        except Exception:
+            chosen = "half"  # fall through to the universal path
+
+    # Half-block fallback needs PIL to resize.
+    if chosen == "half" and _HAS_PIL:
+        try:
+            img = Image.open(path)
+            if crop:
+                try:
+                    img = autocrop(img)
+                except Exception:
+                    pass
+            return half_block_render(img, cells_wide)
+        except Exception:
+            return None
+    return None
+
+
+def _main(argv: list[str]) -> int:
+    args = [a for a in argv if not a.startswith("--")]
+    flags = {a for a in argv if a.startswith("--")}
+    if not args:
+        print("usage: python3 -m ui.image_render <image> [width] [--half|--iterm|--kitty]")
+        return 2
+    path = args[0]
+    width = int(args[1]) if len(args) > 1 and args[1].isdigit() else 36
+    method = None
+    if "--half" in flags:
+        method = "half"
+    elif "--iterm" in flags:
+        method = "iterm"
+    elif "--kitty" in flags:
+        method = "kitty"
+    out = render_image(path, width, method)
+    if out is None:
+        print(f"(cannot render {path}; method={method or best_method()})")
+        return 1
+    sys.stdout.write(out + "\n")
+    sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main(sys.argv[1:]))