aria-code 4.1.3__py3-none-any.whl

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:]))

ui/input_box.py

@@ -0,0 +1,376 @@
+"""Prompt-toolkit input panel — lightweight Claude Code-style input block.
+
+Layout:
+  ──────────────────────────────────────────────  ← subtle top rule
+   › cursor_                                      ← padded input row
+  ──────────────────────────────────────────────  ← subtle bottom rule
+  model  ·  ~/workspace                          ← dim status bar
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass, replace
+from typing import Callable, Optional
+
+try:
+    from prompt_toolkit.application import Application
+    from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.layout import Float, FloatContainer, HSplit, Layout, VSplit, Window
+    from prompt_toolkit.layout.controls import FormattedTextControl
+    from prompt_toolkit.layout.menus import CompletionsMenu
+    from prompt_toolkit.layout.processors import Processor, Transformation
+    from prompt_toolkit.styles import Style
+    from prompt_toolkit.widgets import TextArea
+    HAS_PROMPT_TOOLKIT = True
+except ImportError:
+    HAS_PROMPT_TOOLKIT = False
+
+    class Processor:  # type: ignore[no-redef]
+        pass
+
+    class Transformation:  # type: ignore[no-redef]
+        def __init__(self, fragments, source_to_display=None, display_to_source=None):
+            self.fragments = fragments
+            self.source_to_display = source_to_display or (lambda i: i)
+            self.display_to_source = display_to_source or (lambda i: i)
+
+    class Style:  # type: ignore[no-redef]
+        @staticmethod
+        def from_dict(values):
+            return values
+
+    Application = Buffer = KeyBindings = Dimension = None  # type: ignore
+    Float = FloatContainer = HSplit = Layout = VSplit = Window = None  # type: ignore
+    FormattedTextControl = CompletionsMenu = TextArea = None  # type: ignore
+
+
+# ── Theme detection ────────────────────────────────────────────────────────────
+
+def detect_terminal_theme() -> str:
+    explicit = 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
+    if os.uname().sysname == "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"
+
+
+# ── Config ─────────────────────────────────────────────────────────────────────
+
+@dataclass
+class PanelInputConfig:
+    prompt: str = "› "
+    placeholder: str = "问 Aria、编辑文件、运行命令…  /命令  @文件  !shell"
+    theme: str = "auto"
+
+    est_tokens: int = 0
+    max_tokens: int = 131072
+
+    # Status bar display
+    model_label: str = ""
+    cwd: str = ""
+
+    # Robot mascot — show animated dot in status bar
+    show_robot: bool = True
+
+    # Legacy fields kept for call-site compatibility
+    privacy: str = "local-only"
+    tools_count: int = 0
+    skills_count: int = 0
+    ollama_status: str = ""
+    pending_file: str = ""
+
+    # Resolved by .resolved()
+    fg: str = ""
+    accent: str = ""
+    accent_y: str = ""
+    accent_b: str = ""
+    muted: str = ""
+    dim: str = ""
+    sep: str = ""
+    input_bg: str = ""   # intentional input-area background
+    ph_color: str = ""   # very dim placeholder
+    box: str = ""        # rounded border color
+
+    # Completion menu palette (copper, theme-aware)
+    menu_bg: str = ""
+    menu_fg: str = ""
+    menu_sel_bg: str = ""
+    menu_sel_fg: str = ""
+    menu_meta: str = ""
+    menu_meta_cur: str = ""
+    scroll_bg: str = ""
+    scroll_btn: str = ""
+    hi: str = ""         # fuzzy-match highlight (copper)
+
+    def resolved(self) -> "PanelInputConfig":
+        theme = self.theme if self.theme != "auto" else detect_terminal_theme()
+        if theme == "dark":
+            return replace(self, theme=theme,
+                fg="#c9d1d9",
+                accent="#3fb950", accent_y="#d29922", accent_b="#79c0ff",
+                muted="#6e7781", dim="#484f58", sep="#2d333b",
+                input_bg="default",   # transparent — box border defines the zone
+                ph_color="#484f58",   # dim placeholder, readable
+                box="#C08050",        # copper — Aria's brand accent on the frame
+                menu_bg="#161b22", menu_fg="#c9d1d9",
+                menu_sel_bg="#3a2e20", menu_sel_fg="#e8c9a6",
+                menu_meta="#6e7681", menu_meta_cur="#c0a585",
+                scroll_bg="#161b22", scroll_btn="#C08050",
+                hi="#C08050",
+            )
+        return replace(self, theme="light",
+            fg="#24292f",
+            accent="#1a7f37", accent_y="#9a6700", accent_b="#0969da",
+            muted="#57606a", dim="#8c959f", sep="#d0d7de",
+            input_bg="default",
+            ph_color="#6e7781",
+            box="#9a6700",
+            menu_bg="#f2eee4", menu_fg="#24292f",
+            menu_sel_bg="#e7e1d3", menu_sel_fg="#8a5a00",
+            menu_meta="#6e7781", menu_meta_cur="#8a5a00",
+            scroll_bg="#e7e1d3", scroll_btn="#9a6700",
+            hi="#9a6700",
+        )
+
+
+# ── Processor (mode badge + placeholder) ──────────────────────────────────────
+
+class PromptAndPlaceholderProcessor(Processor):
+    def __init__(self, get_prefix: Callable[[], list], placeholder: str,
+                 is_empty: Callable[[], bool]) -> None:
+        self.get_prefix = get_prefix
+        self.placeholder = placeholder
+        self.is_empty = is_empty
+
+    def apply_transformation(self, ti) -> Transformation:
+        if ti.lineno == 0:
+            empty = self.is_empty()
+            prefix = self.get_prefix()
+            pw = sum(len(t) for _, t in prefix)
+            frags = list(prefix)
+            if empty:
+                frags.append(("class:ph", self.placeholder))
+            frags.extend(ti.fragments)
+            return Transformation(
+                frags,
+                source_to_display=lambda i: pw + i,
+                display_to_source=lambda i: 0 if (i <= pw or empty) else max(0, i - pw),
+            )
+        return Transformation(ti.fragments)
+
+
+PlaceholderProcessor = PromptAndPlaceholderProcessor
+
+
+INPUT_MAX_HEIGHT = 6
+
+
+# ── Style ──────────────────────────────────────────────────────────────────────
+
+def _build_style(cfg: PanelInputConfig) -> Style:
+    return Style.from_dict({
+        # Input row: transparent bg — the rounded box border defines the zone
+        "input-bg":  cfg.fg if cfg.input_bg == "default" else f"{cfg.fg} bg:{cfg.input_bg}",
+        "ph":        cfg.ph_color,
+        # Rounded box border (Claude Code style)
+        "box":       cfg.box,
+        # Mode prompt glyph — always copper (brand). 5-color discipline:
+        # red/green are reserved for 涨跌 semantics, never for chrome.
+        "mode-chat": f"bold {cfg.box}",
+        "mode-cmd":  f"bold {cfg.box}",
+        "mode-file": f"bold {cfg.box}",
+        "prompt":    cfg.muted,
+        # Divider (transparent bg — terminal bg shows through)
+        "divider":   cfg.sep,
+        # Status bar (transparent bg)
+        "st-model":  cfg.muted,
+        "st-sep":    cfg.dim,
+        "st-cwd":    cfg.dim,
+        "tok-warn":  cfg.box,            # copper — context-pressure caution
+        "tok-crit":  "#f85149",          # red — critical only
+        # Completion menu — theme-aware copper palette (matches terminal theme)
+        "completion-menu":                    f"bg:{cfg.menu_bg} {cfg.menu_fg}",
+        "completion-menu.completion":         f"bg:{cfg.menu_bg} {cfg.menu_fg}",
+        "completion-menu.completion.current": f"bg:{cfg.menu_sel_bg} {cfg.menu_sel_fg} bold",
+        "completion-menu.meta.completion":         f"bg:{cfg.menu_bg} {cfg.menu_meta}",
+        "completion-menu.meta.completion.current": f"bg:{cfg.menu_sel_bg} {cfg.menu_meta_cur}",
+        "completion-menu.multi-column-meta":       f"bg:{cfg.menu_bg} {cfg.menu_meta}",
+        "scrollbar.background":               f"bg:{cfg.scroll_bg}",
+        "scrollbar.button":                   f"bg:{cfg.scroll_btn}",
+        # Fuzzy-match highlight classes (shared with ui/completer.py) — copper
+        "fz-hi":                              f"bold {cfg.hi}",
+        "fz-cat":                             cfg.dim,
+    })
+
+
+# ── Row builders ───────────────────────────────────────────────────────────────
+
+def _input_rule(cfg: PanelInputConfig) -> list:
+    w = shutil.get_terminal_size((80, 24)).columns
+    return [("class:divider", "─" * w)]
+
+
+def _input_pad() -> list:
+    return [("", " ")]
+
+
+def _mode_prefix(cfg: PanelInputConfig, text_getter: Callable[[], str]) -> list:
+    """Claude Code-style ›  glyph — color shifts by detected input mode."""
+    txt = text_getter().lstrip()
+    if txt.startswith("/"):
+        return [("class:mode-cmd",  "› ")]
+    if txt.startswith("@") or txt.startswith("!"):
+        return [("class:mode-file", "› ")]
+    return     [("class:mode-chat", "› ")]
+
+
+def _status_bar(cfg: PanelInputConfig) -> list:
+    """Dim status row: [robot dot]  model · cwd [· ctx warning when >60%]"""
+    from .robot import get_status_dot, get_robot_state, RobotState
+
+    tick = int(time.monotonic() * 4)  # 4 fps tick without a background thread
+    parts: list = []
+
+    if cfg.show_robot:
+        dot_frags = get_status_dot(tick)
+        parts.extend(dot_frags)
+        parts.append(("class:st-sep", "  "))
+
+    if cfg.model_label:
+        parts.append(("class:st-model", cfg.model_label))
+
+    if cfg.cwd:
+        if cfg.model_label:
+            parts.append(("class:st-sep", "  ·  "))
+        parts.append(("class:st-cwd", cfg.cwd))
+
+    # Token warning only above 60% — silent below that
+    if cfg.est_tokens > 0:
+        ratio = cfg.est_tokens / max(cfg.max_tokens, 1)
+        if ratio >= 0.60:
+            tc = "tok-crit" if ratio >= 0.85 else "tok-warn"
+            def _k(n: int) -> str:
+                return f"{n // 1000}K" if n >= 1000 else str(n)
+            parts += [
+                ("class:st-sep", "  ·  "),
+                (f"class:{tc}", f"ctx {_k(cfg.est_tokens)}/{_k(cfg.max_tokens)}"),
+            ]
+
+    return parts
+
+
+# ── Main ───────────────────────────────────────────────────────────────────────
+
+def run_panel_input(
+    *,
+    completer=None,
+    history=None,
+    status_text: Callable[[], str] | str = "",   # kept for compat
+    config: Optional[PanelInputConfig] = None,
+) -> str:
+    cfg = (config or PanelInputConfig()).resolved()
+    if not HAS_PROMPT_TOOLKIT:
+        try:
+            return input(cfg.prompt)
+        except EOFError:
+            return ""
+
+    def _accept(buf: Buffer) -> bool:
+        app.exit(result=buf.text)
+        return True
+
+    def _get_text() -> str:
+        try:
+            return text_area.text
+        except Exception:
+            return ""
+
+    text_area = TextArea(
+        height=Dimension(min=1, max=INPUT_MAX_HEIGHT),
+        multiline=True,
+        wrap_lines=True,
+        dont_extend_height=True,
+        completer=completer,
+        complete_while_typing=True,
+        history=history,
+        prompt="",
+        input_processors=[
+            PromptAndPlaceholderProcessor(
+                lambda: _mode_prefix(cfg, _get_text),
+                cfg.placeholder,
+                lambda: _get_text() == "",
+            ),
+        ],
+        accept_handler=_accept,
+        style="class:input-bg",   # only the input row gets the subtle bg
+    )
+
+    kb = KeyBindings()
+
+    @kb.add("escape")
+    def _cancel(event) -> None:
+        event.app.exit(result="")
+
+    @kb.add("enter", eager=True)
+    def _submit(event) -> None:
+        event.app.exit(result=text_area.text)
+
+    @kb.add("s-tab")
+    def _shift_tab(event) -> None:
+        event.app.current_buffer.complete_previous()
+
+    root = FloatContainer(
+        content=HSplit([
+            # Lightweight terminal-native input section.
+            Window(height=1,
+                   content=FormattedTextControl(lambda: _input_rule(cfg), focusable=False)),
+            VSplit([
+                Window(width=1, content=FormattedTextControl(_input_pad, focusable=False)),
+                text_area,
+                Window(width=1, content=FormattedTextControl(_input_pad, focusable=False)),
+            ]),
+            Window(height=1,
+                   content=FormattedTextControl(lambda: _input_rule(cfg), focusable=False)),
+            # Status bar: transparent bg, dim model · cwd
+            Window(height=1,
+                   content=FormattedTextControl(lambda: _status_bar(cfg), focusable=False)),
+        ]),
+        floats=[
+            Float(
+                xcursor=True,
+                ycursor=True,
+                content=CompletionsMenu(max_height=12, scroll_offset=2),
+            )
+        ],
+    )
+
+    app: Application = Application(
+        layout=Layout(root, focused_element=text_area),
+        key_bindings=kb,
+        style=_build_style(cfg),
+        full_screen=False,
+        erase_when_done=False,
+        mouse_support=False,
+        refresh_interval=0.25,  # drives robot dot animation at 4 fps
+    )
+    return app.run() or ""