aria-code 4.1.3__py3-none-any.whl

apps/cli/commands/ui_cmds.py

@@ -0,0 +1,358 @@
+"""UiCommandsMixin — vision, browser, screenshot, input, and context commands."""
+
+from __future__ import annotations
+
+import base64
+import io
+import pathlib
+from urllib.parse import urlsplit
+
+
+class UiCommandsMixin:
+    """Mixin: visual input and terminal UI commands."""
+
+    @staticmethod
+    def _short_url_label(url: str) -> str:
+        try:
+            from urllib.parse import urlsplit
+            parsed = urlsplit(url if url.startswith(("http://", "https://")) else f"https://{url}")
+            host = parsed.netloc or parsed.path
+            path = parsed.path.rstrip("/")
+            if len(path) > 32:
+                path = path[:29] + "..."
+            return f"{host}{path}" if path and path != "/" else host
+        except Exception:
+            return url[:48]
+
+    @staticmethod
+    def _load_image_source(path_or_url: str) -> dict:
+        """Load an image from a local path, URL, or clipboard."""
+        raw = (path_or_url or "").strip().strip("\"'")
+        if not raw:
+            raise ValueError("Missing image source")
+
+        mime_map = {
+            "png": "image/png",
+            "jpg": "image/jpeg",
+            "jpeg": "image/jpeg",
+            "gif": "image/gif",
+            "webp": "image/webp",
+        }
+
+        def _from_bytes(data: bytes, mime: str, label: str) -> dict:
+            if not data:
+                raise ValueError("Empty image data")
+            return {
+                "label": label,
+                "mime": mime,
+                "b64": base64.b64encode(data).decode(),
+                "size_kb": max(1, len(data) // 1024),
+            }
+
+        if raw.lower() in {"clipboard", "clip", "paste"}:
+            try:
+                from PIL import ImageGrab
+                img = ImageGrab.grabclipboard()
+                if img is None:
+                    raise ValueError("Clipboard does not contain an image")
+                if isinstance(img, list):
+                    for item in img:
+                        p = pathlib.Path(str(item))
+                        if p.is_file() and p.suffix.lstrip(".").lower() in mime_map:
+                            return UiCommandsMixin._load_image_source(str(p))
+                    raise ValueError("Clipboard does not contain a supported image file")
+                if hasattr(img, "save"):
+                    buf = io.BytesIO()
+                    img.save(buf, format="PNG")
+                    return _from_bytes(buf.getvalue(), "image/png", "clipboard")
+                raise ValueError("Clipboard image format not supported")
+            except Exception as exc:
+                raise ValueError(str(exc)) from exc
+
+        if raw.startswith(("http://", "https://", "www.")):
+            try:
+                import requests
+                url = raw if raw.startswith(("http://", "https://")) else f"https://{raw}"
+                resp = requests.get(url, timeout=20, headers={"User-Agent": "Mozilla/5.0"})
+                resp.raise_for_status()
+                content_type = (resp.headers.get("content-type") or "").split(";", 1)[0].strip().lower()
+                mime = content_type if content_type.startswith("image/") else "image/png"
+                if mime == "application/octet-stream":
+                    mime = "image/png"
+                return _from_bytes(resp.content, mime, UiCommandsMixin._short_url_label(url))
+            except Exception as exc:
+                raise ValueError(f"Cannot download image: {exc}") from exc
+
+        path = pathlib.Path(raw).expanduser().resolve()
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {path}")
+        suffix = path.suffix.lstrip(".").lower()
+        mime = mime_map.get(suffix)
+        if not mime:
+            raise ValueError(f"Unsupported image type: .{suffix}")
+        return _from_bytes(path.read_bytes(), mime, path.name)
+
+    def cmd_vision(self, args: str):
+        _curr_model = self.terminal.config.get("model", "")
+        if _curr_model and _HAS_MODEL_CAP:
+            _vcap = get_model_capability(_curr_model)
+            if not _vcap.vision:
+                _warn = (
+                    f"[yellow]⚠[/yellow]  当前模型 [bold]{_curr_model}[/bold] 不支持图片输入。\n"
+                    f"[dim]支持视觉的模型：llama3.2:11b · gemma3 · llava · qwen2-vl · moondream[/dim]"
+                )
+                if HAS_RICH:
+                    console.print(Panel(_warn, border_style="yellow", box=rich_box.ROUNDED, padding=(0, 1)))
+                else:
+                    print(f"Warning: model {_curr_model} does not support vision input.")
+                return
+
+        path_str = args.strip().strip("\"'")
+        if not path_str:
+            msg = "Usage: /vision <image_path|image_url|clipboard>  (e.g. /vision ~/Pictures/chart.png)"
+            console.print(f"[dim]{msg}[/dim]" if HAS_RICH else msg)
+            return
+
+        try:
+            payload = self._load_image_source(path_str)
+        except Exception as e:
+            _print_error(str(e), "vision")
+            return
+
+        self.terminal._pending_image = {
+            "type": "image_url",
+            "image_url": {"url": f"data:{payload['mime']};base64,{payload['b64']}"},
+        }
+        size_kb = payload["size_kb"]
+        if HAS_RICH:
+            console.print(Panel(
+                f"[green]✓[/green] [dim]{payload['label']}[/dim]  [dim]{size_kb} KB · {payload['mime']}[/dim]\n"
+                f"[dim]Image queued — ask your question now[/dim]",
+                border_style="dim",
+                box=rich_box.ROUNDED,
+                padding=(0, 1),
+            ))
+        else:
+            print(f"Image loaded: {payload['label']} ({size_kb} KB) — send your question now")
+
+    async def cmd_browser(self, args: str):
+        """Open a URL in a headless browser."""
+        if not _HAS_COMPUTER_USE:
+            _print_error(
+                "computer_use_tools not available.",
+                "Install: pip install playwright mss pyautogui pillow && playwright install chromium",
+            )
+            return
+        from computer_use_tools import _tool_browser_navigate, _tool_browser_screenshot
+
+        parts = args.strip().split(maxsplit=1)
+        if not parts:
+            if HAS_RICH:
+                console.print("[dim]Usage: /browser <url>  or  /browser screenshot <url>[/dim]")
+            return
+
+        if parts[0].lower() == "screenshot" and len(parts) > 1:
+            url = parts[1].strip()
+            if HAS_RICH:
+                with console.status(f"[dim]Screenshotting {self._short_url_label(url)}…[/dim]", spinner="dots"):
+                    result = _tool_browser_screenshot({"url": url})
+            else:
+                result = _tool_browser_screenshot({"url": url})
+            if result.get("success"):
+                d = result["data"]
+                from computer_use_tools import pop_pending_vision_image
+                b64 = pop_pending_vision_image()
+                if b64:
+                    self.terminal._pending_image = {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{b64}"},
+                    }
+                if HAS_RICH:
+                    console.print(Panel(
+                        f"[green]✓[/green]  [bold]{d.get('title','')[:60]}[/bold]\n"
+                        f"[dim]{self._short_url_label(url)}  ·  {d.get('size_kb', 0)} KB[/dim]\n"
+                        f"[dim]Screenshot queued — ask your question now[/dim]",
+                        border_style="dim", box=rich_box.ROUNDED, padding=(0, 1),
+                    ))
+                else:
+                    print(f"Screenshot ready ({d.get('size_kb', 0)} KB) — send your question")
+            else:
+                _print_error(result.get("error", "Screenshot failed"), "browser screenshot")
+        else:
+            url = parts[0].strip()
+            if HAS_RICH:
+                with console.status(f"[dim]Opening {self._short_url_label(url)}…[/dim]", spinner="dots"):
+                    result = _tool_browser_navigate({"url": url})
+            else:
+                result = _tool_browser_navigate({"url": url})
+            if result.get("success"):
+                d = result["data"]
+                title = d.get("title", "")
+                text = d.get("text", "")[:2000]
+                links = d.get("links", [])[:5]
+                engine = d.get("engine", "")
+                if HAS_RICH:
+                    link_str = "\n".join(f"  {l}" for l in links) if links else "  (none)"
+                    console.print(Panel(
+                        f"[bold]{title[:80]}[/bold]  [dim]({engine})[/dim]\n\n"
+                        f"{text}\n\n[dim]Links:[/dim]\n{link_str}",
+                        border_style="dim", box=rich_box.ROUNDED, padding=(0, 1),
+                        title=f"[dim]{self._short_url_label(url)}[/dim]", title_align="left",
+                    ))
+                else:
+                    print(f"Title: {title}\n{text[:500]}")
+            else:
+                _print_error(result.get("error", "Navigation failed"), "browser")
+
+    async def cmd_screenshot(self, args: str):
+        if not _HAS_COMPUTER_USE:
+            _print_error(
+                "computer_use_tools not available.",
+                "Install: pip install mss pillow",
+            )
+            return
+        from computer_use_tools import _tool_computer_screenshot, pop_pending_vision_image
+
+        monitor = int(args.strip()) if args.strip().isdigit() else 1
+        if HAS_RICH:
+            with console.status("[dim]Capturing screen…[/dim]", spinner="dots"):
+                result = _tool_computer_screenshot({"monitor": monitor})
+        else:
+            result = _tool_computer_screenshot({"monitor": monitor})
+
+        if result.get("success"):
+            d = result["data"]
+            b64 = pop_pending_vision_image()
+            if b64:
+                self.terminal._pending_image = {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{b64}"},
+                }
+            if HAS_RICH:
+                console.print(Panel(
+                    f"[green]✓[/green]  [dim]{d['width']}×{d['height']}  ·  {d['size_kb']} KB[/dim]\n"
+                    f"[dim]Screenshot queued — ask your question now[/dim]",
+                    border_style="dim", box=rich_box.ROUNDED, padding=(0, 1),
+                ))
+            else:
+                print(f"Screenshot {d['width']}×{d['height']} ({d['size_kb']} KB) — send your question")
+        else:
+            _print_error(result.get("error", "Screenshot failed"), "screenshot")
+
+    def cmd_input(self, args: str):
+        raw = args.strip().lower()
+        cfg = self.terminal.config
+        valid_styles = {"panel", "box", "plain"}
+        valid_themes = {"auto", "dark", "light"}
+
+        def _save_and_show(message: str) -> None:
+            save_config(cfg)
+            if HAS_RICH:
+                console.print(f"[green]✓[/green] {message}")
+                console.print(
+                    f"  [dim]style[/dim] {cfg.get('input_style', 'panel')}  "
+                    f"[dim]theme[/dim] {cfg.get('input_theme', 'auto')}"
+                )
+            else:
+                print(message)
+                print(f"  style {cfg.get('input_style', 'panel')}  theme {cfg.get('input_theme', 'auto')}")
+
+        if not raw or raw in {"status", "show"}:
+            style = cfg.get("input_style", "panel")
+            theme = cfg.get("input_theme", "auto")
+            if HAS_RICH:
+                console.print(Panel(
+                    f"[bold]style[/bold]  {style}\n"
+                    f"[bold]theme[/bold]  {theme}\n\n"
+                    "[dim]Use[/dim] /input panel [dim]for the Codex-style input block[/dim]\n"
+                    "[dim]Use[/dim] /input theme auto [dim]to follow the terminal/system theme[/dim]",
+                    title="Input UI",
+                    border_style="dim",
+                    box=rich_box.ROUNDED,
+                    padding=(0, 1),
+                ))
+            else:
+                print(f"input style: {style}")
+                print(f"input theme: {theme}")
+                print("Usage: /input panel|box|plain | /input theme auto|dark|light")
+            return
+
+        if raw == "reset":
+            cfg["input_style"] = "panel"
+            cfg["input_theme"] = "auto"
+            _save_and_show("input UI reset to panel · auto")
+            return
+
+        parts = raw.split()
+        if parts[0] == "theme":
+            if len(parts) != 2 or parts[1] not in valid_themes:
+                msg = "Usage: /input theme auto|dark|light"
+                console.print(f"[red]{msg}[/red]" if HAS_RICH else msg)
+                return
+            cfg["input_theme"] = parts[1]
+            _save_and_show(f"input theme set to {parts[1]}")
+            return
+
+        if parts[0] in valid_themes and len(parts) == 1:
+            cfg["input_theme"] = parts[0]
+            _save_and_show(f"input theme set to {parts[0]}")
+            return
+
+        if parts[0] in valid_styles and len(parts) == 1:
+            cfg["input_style"] = parts[0]
+            _save_and_show(f"input style set to {parts[0]}")
+            return
+
+        msg = "Usage: /input panel|box|plain | /input theme auto|dark|light | /input reset"
+        console.print(f"[red]{msg}[/red]" if HAS_RICH else msg)
+
+    def cmd_context(self, args: str):
+        cfg = self.terminal.config
+        conv = self.terminal.conversation
+        conv_len = len(conv)
+        model_id = cfg.get("model", "qwen2.5:7b")
+        thinking = cfg.get("thinking_mode", "auto")
+        has_auth = bool(cfg.get("auth_token"))
+        local_mode = cfg.get("local_mode", False)
+        auto_compact = bool(cfg.get("auto_compact_context", True))
+        try:
+            auto_compact_threshold = float(cfg.get("auto_compact_threshold", 0.78))
+        except Exception:
+            auto_compact_threshold = 0.78
+        auto_compact_count = int(getattr(self.terminal, "_auto_compact_count", 0) or 0)
+
+        total_chars = sum(len(m.get("content", "")) for m in conv)
+        est_tokens = total_chars // 3
+        max_ctx = get_model_cfg(model_id).get("num_ctx", 16384)
+        ctx_pct = min(100, int(est_tokens / max_ctx * 100))
+        ctx_color = "green" if ctx_pct < 60 else ("yellow" if ctx_pct < 85 else "red")
+
+        if HAS_RICH:
+            console.print()
+            console.print("[bold]Current Context[/bold]")
+            console.print()
+            console.print(f"  [dim]{'Model':<20s}[/dim]{model_id}")
+            console.print(f"  [dim]{'Provider':<20s}[/dim]{'[green]Local (Ollama)[/green]' if local_mode else 'AWS → Ollama fallback'}")
+            console.print(f"  [dim]{'Thinking':<20s}[/dim]{thinking}")
+            console.print(f"  [dim]{'Messages':<20s}[/dim]{conv_len}")
+            console.print(f"  [dim]{'Est. tokens':<20s}[/dim][{ctx_color}]{est_tokens:,} / {max_ctx:,} ({ctx_pct}%)[/{ctx_color}]")
+            console.print(f"  [dim]{'Authenticated':<20s}[/dim]{'yes' if has_auth else 'no'}")
+            console.print(
+                f"  [dim]{'Auto compact':<20s}[/dim]"
+                f"{'on' if auto_compact else 'off'}"
+                f" · threshold {int(auto_compact_threshold * 100)}%"
+                f" · runs {auto_compact_count}"
+            )
+            console.print(f"  [dim]{'Session':<20s}[/dim]{self.terminal.session_id}")
+            console.print(f"  [dim]{'Project context':<20s}[/dim]{'loaded' if _PROJECT_CONTEXT else 'none'}")
+            wl = cfg.get("watchlist", [])
+            if wl:
+                console.print(f"  [dim]{'Watchlist':<20s}[/dim]{', '.join(wl)}")
+            if ctx_pct >= 80:
+                console.print(f"\n  [yellow]⚠ Context {ctx_pct}% full — use /compact to free space[/yellow]")
+            console.print()
+        else:
+            print(f"  Model: {model_id}  ({'local' if local_mode else 'aws'})")
+            print(f"  Messages: {conv_len}  Tokens: ~{est_tokens:,}/{max_ctx:,} ({ctx_pct}%)")
+            print(f"  Auto compact: {'on' if auto_compact else 'off'}  threshold={int(auto_compact_threshold * 100)}%  runs={auto_compact_count}")
+            print(f"  Session: {self.terminal.session_id}")

apps/cli/commands/workflow_cmds.py

@@ -0,0 +1,279 @@
+"""WorkflowCommandsMixin — hooks, regen, undo, retry, note, review commands."""
+
+from __future__ import annotations
+
+import os
+import pathlib
+from datetime import datetime
+
+
+class WorkflowCommandsMixin:
+    """Mixin: interactive workflow and edit-review commands."""
+
+    def cmd_hooks(self, args: str):
+        global _JSON_HOOKS
+        hooks_dirs = [
+            CONFIG_DIR / "hooks",
+            pathlib.Path.cwd() / ".aria" / "hooks",
+        ]
+        parts = args.strip().split(maxsplit=1)
+        sub = parts[0].lower() if parts else "list"
+        rest = parts[1].strip() if len(parts) > 1 else ""
+
+        if sub == "reload":
+            if _HAS_JSON_HOOKS:
+                try:
+                    _JSON_HOOKS = _load_hooks()
+                    n = sum(len(v) for v in _JSON_HOOKS.values())
+                    if HAS_RICH:
+                        console.print(f"  [green]✓[/green] [dim]hooks.json reloaded ({n} entries)[/dim]")
+                    else:
+                        print(f"  hooks.json reloaded ({n} entries)")
+                except Exception as exc:
+                    if HAS_RICH:
+                        console.print(f"  [red]✗ reload failed: {exc}[/red]")
+                    else:
+                        print(f"  reload failed: {exc}")
+            return
+
+        if sub == "list":
+            if _HAS_JSON_HOOKS:
+                try:
+                    from apps.cli.hooks import list_hooks as _list_json_hooks
+                    _json_rows = _list_json_hooks()
+                    if _json_rows:
+                        if HAS_RICH:
+                            console.print()
+                            console.print("  [bold]JSON Hooks[/bold]  [dim](~/.arthera/hooks.json)[/dim]")
+                            for r in _json_rows:
+                                _block = " [red][blocking][/red]" if r["blocking"] else ""
+                                _tool = f"[{r['tool']}]" if r["tool"] != "*" else ""
+                                console.print(
+                                    f"  [cyan]{r['event']:<16}[/cyan]{_tool:<14}  "
+                                    f"[dim]{r['command']}[/dim]{_block}"
+                                )
+                        else:
+                            for r in _json_rows:
+                                print(f"  {r['event']:<16} {r['tool']:<12} {r['command']}")
+                except Exception:
+                    pass
+
+            found: list[tuple] = []
+            for hdir in hooks_dirs:
+                if hdir.exists():
+                    for f in sorted(hdir.iterdir()):
+                        if f.is_file() and not f.name.startswith("."):
+                            found.append((str(hdir), f.name, str(f)))
+            if not found:
+                if HAS_RICH:
+                    console.print(f"  [dim]No hooks found.[/dim]")
+                    console.print(f"  [dim]Hook dirs:[/dim]")
+                    for d in hooks_dirs:
+                        console.print(f"    [dim]{_display_path(d, fallback='hook dir')}[/dim]")
+                    console.print(f"  [dim]Events: prompt_submit  response_done  tool_use  compact[/dim]")
+                else:
+                    print("No hooks. Dirs:", [str(d) for d in hooks_dirs])
+                return
+            if HAS_RICH:
+                console.print()
+                for hdir, name, path in found:
+                    console.print(f"  [dim]{name:<28}[/dim]  {_display_path(path, fallback='hook')}")
+                console.print()
+            else:
+                for hdir, name, path in found:
+                    print(f"  {name}  {_display_path(path, fallback='hook')}")
+
+        elif sub == "edit":
+            if not rest:
+                if _HAS_JSON_HOOKS:
+                    from apps.cli.hooks import hooks_file_path, create_example_hooks
+                    _hpath = hooks_file_path("global")
+                    create_example_hooks(_hpath)
+                    editor = os.getenv("EDITOR", "nano")
+                    try:
+                        import subprocess as _sp
+                        _sp.run([editor, str(_hpath)])
+                        _JSON_HOOKS = _load_hooks()
+                    except Exception as exc:
+                        if HAS_RICH:
+                            console.print(f"[red]Could not open editor: {exc}[/red]")
+                        else:
+                            print(f"Could not open editor: {exc}")
+                return
+            event = rest
+            hdir = CONFIG_DIR / "hooks"
+            hdir.mkdir(parents=True, exist_ok=True)
+            script = hdir / f"{event}.sh"
+            if not script.exists():
+                script.write_text(
+                    f"#!/bin/bash\n# Aria hook: {event}\n# "
+                    f"Env vars: ARIA_EVENT ARIA_TOOL ARIA_TOOL_PARAMS ARIA_RESPONSE ARIA_SESSION\n\n"
+                    f'echo "Hook {event} fired"\n',
+                    encoding="utf-8"
+                )
+                script.chmod(0o755)
+            editor = os.getenv("EDITOR", "nano")
+            try:
+                import subprocess as _sp
+                _sp.run([editor, str(script)])
+            except Exception as exc:
+                console.print(f"[red]Could not open editor: {exc}[/red]" if HAS_RICH else str(exc))
+
+        elif sub == "run":
+            event = rest or "ResponseDone"
+            if _HAS_JSON_HOOKS:
+                _fire_json_hook(event, session_id=getattr(self.terminal, "session_id", ""), hooks=_JSON_HOOKS)
+            _run_event_hook(event, {"ARIA_EVENT": event, "ARIA_SESSION": getattr(self.terminal, "session_id", "")})
+            if HAS_RICH:
+                console.print(f"  [dim]Hook '{event}' triggered[/dim]")
+            else:
+                print(f"Hook '{event}' triggered")
+
+        else:
+            if HAS_RICH:
+                console.print("[dim]Usage: /hooks list|edit [event]|reload|run [event][/dim]")
+            else:
+                print("Usage: /hooks list|edit [event]|reload|run [event]")
+
+    async def cmd_regen(self, args: str):
+        last_user_msg = None
+        for i in range(len(self.terminal.conversation) - 1, -1, -1):
+            if self.terminal.conversation[i]["role"] == "assistant":
+                self.terminal.conversation.pop(i)
+                break
+        for msg in reversed(self.terminal.conversation):
+            if msg["role"] == "user":
+                last_user_msg = msg["content"]
+                break
+        if last_user_msg:
+            for i in range(len(self.terminal.conversation) - 1, -1, -1):
+                if self.terminal.conversation[i]["role"] == "user" and self.terminal.conversation[i]["content"] == last_user_msg:
+                    self.terminal.conversation.pop(i)
+                    break
+            console.print("[dim]Regenerating...[/dim]" if HAS_RICH else "Regenerating...")
+            await self.terminal.send_message(last_user_msg)
+        else:
+            console.print("[dim]No message to regenerate[/dim]" if HAS_RICH else "Nothing to regenerate")
+
+    def cmd_undo(self, args: str):
+        if len(self.terminal.conversation) < 2:
+            console.print("[dim]Nothing to undo[/dim]" if HAS_RICH else "Nothing to undo")
+            return
+        removed = 0
+        for role in ("assistant", "user"):
+            for i in range(len(self.terminal.conversation) - 1, -1, -1):
+                if self.terminal.conversation[i]["role"] == role:
+                    self.terminal.conversation.pop(i)
+                    removed += 1
+                    break
+        if HAS_RICH:
+            console.print(f"[dim]Undone ({removed} messages removed, {len(self.terminal.conversation)} remaining)[/dim]")
+        else:
+            print(f"Undone ({removed} removed)")
+
+    async def cmd_retry(self, args: str):
+        last_user_msg = None
+        for i in range(len(self.terminal.conversation) - 1, -1, -1):
+            if self.terminal.conversation[i]["role"] == "assistant":
+                self.terminal.conversation.pop(i)
+                break
+        for msg in reversed(self.terminal.conversation):
+            if msg["role"] == "user":
+                last_user_msg = msg["content"]
+                break
+        if not last_user_msg:
+            console.print("[dim]No message to retry[/dim]" if HAS_RICH else "Nothing to retry")
+            return
+        for i in range(len(self.terminal.conversation) - 1, -1, -1):
+            if self.terminal.conversation[i]["role"] == "user" and self.terminal.conversation[i]["content"] == last_user_msg:
+                self.terminal.conversation.pop(i)
+                break
+        orig_model_key = resolve_model_key(self.terminal.config.get("model", "qwen2.5:7b"))
+        _fallback_model = MODELS.get("qwen-fast") or MODELS.get("qwen7b") or next(iter(MODELS.values()))
+        orig_temp = MODELS.get(orig_model_key, _fallback_model).get("temperature", 0.3)
+        MODELS[orig_model_key]["temperature"] = min(0.9, orig_temp + 0.3)
+        if HAS_RICH:
+            console.print(f"[dim]Retrying with temperature {MODELS[orig_model_key]['temperature']:.1f}...[/dim]")
+        else:
+            print(f"Retrying (temp +0.3)...")
+        try:
+            await self.terminal.send_message(last_user_msg)
+        finally:
+            MODELS[orig_model_key]["temperature"] = orig_temp
+
+    def cmd_note(self, args: str):
+        text = args.strip()
+        if not text:
+            console.print("[dim]Usage: /note <text>[/dim]" if HAS_RICH else "Usage: /note <text>")
+            return
+        aria_md = pathlib.Path.cwd() / "ARIA.md"
+        now_str = datetime.now().strftime("%Y-%m-%d %H:%M")
+        entry = f"\n- [{now_str}] {text}"
+        if aria_md.exists():
+            content = aria_md.read_text(encoding="utf-8")
+            if "## Notes" not in content:
+                content += "\n\n## Notes\n"
+            content += entry
+        else:
+            content = f"# Aria Project Notes\n\n## Notes\n{entry}\n"
+        aria_md.write_text(content, encoding="utf-8")
+        global _PROJECT_CONTEXT
+        _PROJECT_CONTEXT = _load_project_context()
+        if HAS_RICH:
+            console.print(f"[dim]Note saved to {aria_md.name}[/dim]")
+        else:
+            print(f"Saved to {aria_md.name}")
+
+    async def cmd_review(self, args: str):
+        raw = args.strip()
+        policy = self.terminal.config.get("command_policy", "safe")
+
+        if raw and not raw.startswith("--"):
+            p = pathlib.Path(raw).expanduser()
+            if not p.exists():
+                msg = f"File not found: {raw}"
+                console.print(f"[red]{msg}[/red]") if HAS_RICH else print(msg)
+                return
+            _print_phase("Reading file")
+            try:
+                content = p.read_text(errors="replace")[:12000]
+            except Exception as e:
+                console.print(f"[red]Cannot read file: {e}[/red]") if HAS_RICH else print(f"Cannot read: {e}")
+                return
+            line_count = content.count("\n")
+            if HAS_RICH:
+                console.print(f"  [dim]↳ {p.name}  ·  {line_count} lines[/dim]")
+            _print_phase("AI Review")
+            prompt = (
+                f"请对以下 `{p.name}` 的代码进行专业审查，查找 Bug、安全问题和改进点。\n"
+                f"每条发现用严重程度标签开头：**BUG**、**IMPROVEMENT**、**NIT**。\n"
+                f"按文件组织输出，直接给结论，不要重复贴出全部代码。\n\n"
+                f"```\n{content}\n```"
+            )
+        else:
+            diff_cmd = "git diff --staged" if raw.startswith("--staged") else "git diff HEAD"
+            _print_phase("Reading diff")
+            tr = _tool_run_command({"command": diff_cmd})
+            if not tr.get("success"):
+                msg = tr.get("error", "git diff failed")
+                console.print(f"[red]{msg}[/red]") if HAS_RICH else print(msg)
+                return
+            diff_text = (tr.get("data") or {}).get("stdout", "").strip()
+            if not diff_text:
+                console.print("[dim]No changes to review.[/dim]") if HAS_RICH else print("No changes to review.")
+                return
+            _adds = diff_text.count("\n+") - diff_text.count("\n+++")
+            _dels = diff_text.count("\n-") - diff_text.count("\n---")
+            _files = diff_text.count("\ndiff --git")
+            if HAS_RICH:
+                console.print(f"  [dim]↳ {_files} files  ·  +{_adds} −{_dels} lines[/dim]")
+            diff_text = diff_text[:12000]
+            _print_phase("AI Review")
+            prompt = (
+                "请审查以下 git diff，找出 Bug、潜在回归、安全问题和代码质量问题。\n"
+                "每条发现用严重程度标签开头：**BUG**、**IMPROVEMENT**、**NIT**。\n"
+                "按文件分组，直接给出结论。\n\n"
+                f"```diff\n{diff_text}\n```"
+            )
+
+        await self.terminal.send_message(prompt)