hanuscode 1.0.0__py3-none-any.whl

hanus/ui.py

@@ -0,0 +1,939 @@
+# hanus/ui.py — Professional Terminal Interface
+from __future__ import annotations
+import sys
+import textwrap as _tw
+import time
+import re
+from typing import List, Dict, Optional, TYPE_CHECKING
+
+try:
+    from colorama import Fore, Style
+except ImportError:
+    # Fallback for environments without colorama
+    class _FallbackFore:
+        CYAN = BLUE = GREEN = YELLOW = RED = MAGENTA = WHITE = ""
+    class _FallbackStyle:
+        RESET_ALL = DIM = BRIGHT = ""
+        BRIGHT = ""
+    Fore = _FallbackFore()
+    Style = _FallbackStyle()
+
+if TYPE_CHECKING:
+    from hanus.config import HanusConfig
+    from hanus.plugin_manager import PluginManager
+    from hanus.session_manager import SessionData
+    from hanus.permissions import RiskLevel, PermissionDecision
+
+# ═══════════════════════════════════════════════════════════════════════════
+# PROFESSIONAL COLOR PALETTE
+# ═══════════════════════════════════════════════════════════════════════════
+
+class P:
+    R     = Style.RESET_ALL
+    DIM   = Style.DIM
+    BOLD  = Style.BRIGHT
+
+    # Primary colors
+    CYAN    = Fore.CYAN + Style.BRIGHT
+    BLUE    = Fore.BLUE + Style.BRIGHT
+    GREEN   = Fore.GREEN + Style.BRIGHT
+    YELLOW  = Fore.YELLOW + Style.BRIGHT
+    RED     = Fore.RED + Style.BRIGHT
+    MAGENTA = Fore.MAGENTA + Style.BRIGHT
+    WHITE   = Fore.WHITE + Style.BRIGHT
+
+    # Semantic colors
+    HEADER  = Fore.CYAN + Style.BRIGHT
+    ACCENT  = Fore.BLUE + Style.BRIGHT
+    LABEL   = Fore.WHITE + Style.BRIGHT
+    OK      = Fore.GREEN + Style.BRIGHT
+    WARN    = Fore.YELLOW + Style.BRIGHT
+    ERR     = Fore.RED + Style.BRIGHT
+    MUTED   = Fore.WHITE + Style.DIM
+    DIM_C   = Fore.CYAN + Style.DIM
+    TOOL    = Fore.CYAN + Style.BRIGHT
+    PLUG    = Fore.MAGENTA + Style.BRIGHT
+    AGENT   = Fore.BLUE + Style.BRIGHT
+    INPUT   = Fore.WHITE + Style.BRIGHT
+
+    # Aliases for clarity
+    SUCCESS = Fore.GREEN + Style.BRIGHT
+    INFO    = Fore.CYAN + Style.DIM
+
+
+W = 88  # UI width
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ICONS
+# ═══════════════════════════════════════════════════════════════════════════
+
+class Icon:
+    # Status
+    SUCCESS = "✓"
+    ERROR   = "✗"
+    WARNING = "⚠"
+    INFO    = "ℹ"
+    LOADING = "◐"
+    RUNNING = "▶"
+    DONE    = "■"
+
+    # File operations
+    READ    = "📖"
+    WRITE   = "📝"
+    EDIT    = "✏️"
+    CREATE  = "📄"
+    DELETE  = "🗑️"
+
+    # Execution
+    EXEC    = "⚡"
+    CMD     = "⟩"
+    GIT     = "📦"
+    SEARCH  = "🔍"
+    GLOB    = "📁"
+    GREP    = "🔎"
+
+    # Tasks
+    TASK_NEW  = "⊕"
+    TASK_DONE = "☑"
+    TASK_TODO = "☐"
+    TASK_LIST = "☰"
+
+    # Memory
+    MEM_SAVE = "💾"
+    MEM_LOAD = "📂"
+    MEM_LIST = "📋"
+
+    # Web
+    WEB_FETCH  = "🌐"
+    WEB_SEARCH = "🔎"
+
+    # Tools
+    TOOL     = "🔧"
+    PLUGIN   = "🔌"
+    BINARY   = "⚙"
+    NOTEBOOK = "📓"
+    OUTPUT   = "📊"
+
+    # UI elements
+    ARROW   = "→"
+    BULLET  = "•"
+    DIVIDER = "─"
+    CORNER  = "┌┐└┘├┤"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# HELPERS
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _sec(label: str, icon: str = "") -> str:
+    """Create a section header."""
+    fill = max(0, W - len(label) - len(icon) - 6)
+    prefix = f"{icon} " if icon else ""
+    return f"── {prefix}{label} {'─' * fill}"
+
+
+def _tool_label(name: str) -> str:
+    """Get icon and label for a tool."""
+    mapping = {
+        "read_file":        f"{Icon.READ} READ   ",
+        "write_file":       f"{Icon.WRITE} WRITE  ",
+        "create_file":      f"{Icon.CREATE} CREATE ",
+        "append_to_file":   f"{Icon.WRITE} APPEND ",
+        "file_edit":        f"{Icon.EDIT} EDIT   ",
+        "edit_file":        f"{Icon.EDIT} EDIT   ",
+        "exec_cmd":         f"{Icon.EXEC} EXEC   ",
+        "exec_file":        f"{Icon.RUNNING} RUN    ",
+        "glob_search":      f"{Icon.GLOB} GLOB   ",
+        "grep_search":      f"{Icon.GREP} GREP   ",
+        "list_files":       f"{Icon.GLOB} LIST   ",
+        "git_status":       f"{Icon.GIT} GIT    ",
+        "git_diff":         f"{Icon.GIT} DIFF   ",
+        "git_log":          f"{Icon.GIT} LOG    ",
+        "git_commit":       f"{Icon.GIT} COMMIT ",
+        "git_push":         f"{Icon.GIT} PUSH   ",
+        "git_reset":        f"{Icon.GIT} RESET  ",
+        "git_branch":       f"{Icon.GIT} BRANCH ",
+        "web_fetch":        f"{Icon.WEB_FETCH} FETCH  ",
+        "web_search":       f"{Icon.WEB_SEARCH} SEARCH ",
+        "structured_output":f"{Icon.OUTPUT} OUTPUT ",
+        "notebook_edit":    f"{Icon.NOTEBOOK} NOTE   ",
+        "binsmasher":       f"{Icon.BINARY} BINARY ",
+        "task_create":      f"{Icon.TASK_NEW} TASK+  ",
+        "task_update":      f"{Icon.TASK_DONE} TASK✓  ",
+        "task_list":        f"{Icon.TASK_LIST} TASKS  ",
+        "task_get":         f"{Icon.TASK_TODO} TASK?  ",
+        "memory_save":      f"{Icon.MEM_SAVE} MEM+   ",
+        "memory_search":    f"{Icon.MEM_LOAD} MEM?   ",
+        "memory_list":      f"{Icon.MEM_LIST} MEMS   ",
+        "run_plugin":       f"{Icon.PLUGIN} PLUGIN ",
+        "ask_user":         f"❓ ASK   ",
+    }
+
+    # Handle plugin: prefix (e.g., "plugin:hackerone" -> "🔌 HACKERONE")
+    if name.startswith("plugin:"):
+        plugin_name = name[7:].upper()  # Remove "plugin:" prefix
+        return f"{Icon.PLUGIN} {plugin_name:<8}"
+
+    return mapping.get(name, f"{Icon.TOOL} TOOL   ")
+
+
+def _fmt_tool_desc(tool_name: str, args: Dict) -> str:
+    """Generate a readable description of what the tool does."""
+    from pathlib import Path
+
+    # Handle plugin: prefix
+    if tool_name.startswith("plugin:"):
+        plugin_args = args.get("args", "")
+        if plugin_args:
+            return plugin_args[:60]
+        return ""
+
+    if tool_name in ("write_file", "create_file", "append_to_file"):
+        path = args.get("path", "?")
+        filename = Path(path).name if path else "?"
+        content = args.get("content", "")
+        ext = Path(path).suffix.lower() if path else ""
+
+        size = len(content)
+        lang_map = {
+            ".py": "Python", ".js": "JavaScript", ".ts": "TypeScript",
+            ".sh": "Shell", ".bash": "Bash", ".zsh": "Zsh",
+            ".c": "C", ".cpp": "C++", ".h": "Header",
+            ".md": "Markdown", ".rst": "reStructuredText",
+            ".yaml": "YAML", ".yml": "YAML", ".json": "JSON", ".toml": "TOML",
+            ".html": "HTML", ".css": "CSS", ".scss": "SCSS",
+            ".sql": "SQL", ".go": "Go", ".rs": "Rust", ".rb": "Ruby",
+        }
+        lang = lang_map.get(ext, "File")
+        return f"{filename} ({size:,} chars) • {lang}"
+
+    if tool_name in ("edit_file", "file_edit"):
+        path = args.get("path", "?")
+        filename = Path(path).name if path else "?"
+        old = args.get("old_str", args.get("search", ""))
+        new = args.get("new_str", args.get("replace", ""))
+        old_preview = old[:30].replace("\n", " ") if old else "?"
+        new_preview = new[:30].replace("\n", " ") if new else "?"
+        if old and new:
+            return f"{filename} • '{old_preview}...' → '{new_preview}...'"
+        return f"{filename} • Editing"
+
+    if tool_name == "read_file":
+        path = args.get("path", "?")
+        filename = Path(path).name if path else "?"
+        start = args.get("start_line")
+        end = args.get("end_line")
+        if start and end:
+            return f"{filename} (lines {start}-{end})"
+        return filename
+
+    if tool_name == "exec_cmd":
+        cmd = args.get("cmd", "?")
+        if len(cmd) > 60:
+            cmd = cmd[:57] + "..."
+        return cmd
+
+    if tool_name in ("grep_search", "glob_search"):
+        pattern = args.get("pattern", "?")
+        directory = args.get("dir", ".")
+        return f"'{pattern}' in {directory}"
+
+    if tool_name == "binsmasher":
+        binary = args.get("binary", "?")
+        action = args.get("action", "analyze")
+        filename = Path(binary).name if binary else "?"
+        return f"{filename} • {action}"
+
+    if tool_name == "task_create":
+        subject = args.get("subject", "?")
+        return f"New: {subject[:50]}"
+
+    if tool_name == "task_update":
+        task_id = args.get("taskId", "?")
+        status = args.get("status", "?")
+        status_icon = {"completed": "✓", "in_progress": "○", "pending": "·"}.get(status, "?")
+        return f"Task {task_id} → {status_icon} {status}"
+
+    if tool_name == "run_plugin":
+        name = args.get("name", "?")
+        plugin_args = args.get("args", "")
+        if plugin_args:
+            return f"{name}: {plugin_args[:40]}"
+        return name
+
+    if tool_name.startswith("memory_"):
+        name = args.get("name", args.get("query", "?"))
+        return name[:50]
+
+    if tool_name == "ask_user":
+        question = args.get("question", "?")
+        options = args.get("options", [])
+        multi = args.get("multiSelect", False)
+        mode = "multi" if multi else "single"
+        num_opts = len(options)
+        q_preview = question[:30] + "..." if len(question) > 30 else question
+        return f"{q_preview} ({num_opts} opts, {mode})"
+
+    # Default: show main arguments
+    parts = []
+    for k, v in list(args.items())[:2]:
+        if k in ("content", "old_str", "new_str", "search", "replace"):
+            continue
+        s = str(v)
+        if len(s) > 40:
+            s = s[:37] + "..."
+        parts.append(f"{k}={s!r}")
+    return "  ".join(parts) if parts else ""
+
+
+def _strip_xml(text: str) -> str:
+    """Remove XML tool blocks from text."""
+    BLOCK = (r"write_file|create_file|append_to_file|exec_cmd|exec_file|"
+             r"read_file|file_edit|add_note|read_note|list_note|run_plugin")
+    text = re.sub(rf'<({BLOCK})\b[^>]*>.*?</\1>', '', text, flags=re.DOTALL | re.I)
+    text = re.sub(rf'<({BLOCK})\b[^>]*/?>',       '', text, flags=re.I)
+    return "\n".join(l for l in text.splitlines() if l.strip())
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# UI CLASS
+# ═══════════════════════════════════════════════════════════════════════════
+
+class UI:
+
+    def __init__(self):
+        self._streaming: bool = False
+        self._stream_line_len: int = 0
+        self._streaming_enabled: bool = False
+        self._multiline_mode: bool = False
+        self._processing: bool = False
+        self._processing_thread = None
+
+    def toggle_streaming(self) -> bool:
+        """Toggle streaming mode. Returns new state."""
+        self._streaming_enabled = not self._streaming_enabled
+        return self._streaming_enabled
+
+    def is_streaming_enabled(self) -> bool:
+        """Check if streaming is enabled."""
+        return self._streaming_enabled
+
+    def start_processing(self):
+        """Start processing indicator (when streaming is OFF)."""
+        if self._streaming_enabled:
+            return
+
+        self._processing = True
+        self._show_processing_animation()
+
+    def _show_processing_animation(self):
+        """Show processing animation - static to allow background typing."""
+        import threading
+        import time
+
+        def animate():
+            # Show a static message that doesn't clear the line
+            # This allows the user to type while agent works
+            print(f"\n{P.CYAN}  ⏳ Working... {P.DIM}(type to queue input for next turn){P.R}\n")
+            # Just wait until processing is done
+            while self._processing:
+                time.sleep(0.2)
+            # Clear when done
+            print("\r" + " " * 60 + "\r", end="", flush=True)
+
+        self._processing_thread = threading.Thread(target=animate, daemon=True)
+        self._processing_thread.start()
+
+    def stop_processing(self):
+        """Stop processing indicator."""
+        self._processing = False
+        if self._processing_thread:
+            self._processing_thread.join(timeout=0.5)
+            self._processing_thread = None
+
+    # ── Banner ─────────────────────────────────────────────────────────────────
+
+    def banner(self):
+        """Display startup banner."""
+        print()
+        print(f"{P.HEADER}{'═' * W}{P.R}")
+
+        # Title
+        title = "HANUSCODE"
+        print(f"{P.HEADER}║{P.R}  {P.LABEL}{title.center(W - 4)}{P.R}  {P.HEADER}║{P.R}")
+
+        print(f"{P.HEADER}║{P.R}  {P.MUTED}{'─' * (W - 4)}{P.R}  {P.HEADER}║{P.R}")
+        print(f"{P.HEADER}║{P.R}  {P.CYAN}{'Autonomous Programming Agent'.center(W - 4)}{P.R}  {P.HEADER}║{P.R}")
+        print(f"{P.HEADER}{'═' * W}{P.R}")
+        print()
+
+    # ── Status ─────────────────────────────────────────────────────────────────
+
+    def show_status(self, config: "HanusConfig", pm: "PluginManager",
+                    session: Optional["SessionData"] = None):
+        """Display current status."""
+        print(f"{P.HEADER}{'─' * 20} STATUS {'─' * (W - 29)}{P.R}")
+
+        # Model info with icon
+        model_icon = "🤖"
+        print(f"  {P.ACCENT}{model_icon} Model:{P.R}      {P.LABEL}{config.provider}{P.R}/{P.WHITE}{config.model_id}{P.R}")
+
+        # Permissions with icon
+        perm_icon = {"bypass": "🔓", "default": "🔒", "plan": "📋"}.get(config.permission_mode, "⚙")
+        print(f"  {P.ACCENT}{perm_icon} Permissions:{P.R}  {P.LABEL}{config.permission_mode.upper()}{P.R}")
+
+        # Directory with icon
+        print(f"  {P.ACCENT}📁 Directory:{P.R}  {P.MUTED}{str(config.root_dir)[:50]}{P.R}")
+
+        # Session info
+        if session:
+            cost = session.total_cost_usd
+            tokens = session.total_input_tokens + session.total_output_tokens
+            print(f"  {P.ACCENT}💾 Session:{P.R}    {P.LABEL}{session.name}{P.R}")
+            print(f"  {P.ACCENT}💰 Cost:{P.R}       {P.GREEN}${cost:.4f}{P.R} {P.MUTED}({tokens:,} tokens){P.R}")
+        print()
+
+    def show_commands(self, pm: "PluginManager", skill_mgr=None):
+        """Display available commands."""
+        print(f"{P.HEADER}{'─' * 20} COMMANDS {'─' * (W - 31)}{P.R}")
+        print()
+
+        # Main commands
+        print(f"  {P.LABEL}⚡ Main:{P.R}")
+        print(f"    {P.INPUT}/profile{P.R}      View/switch profile")
+        print(f"    {P.INPUT}/model{P.R}       Change model")
+        print(f"    {P.INPUT}/stream{P.R}      Toggle streaming")
+        print(f"    {P.INPUT}/ask{P.R}         Simple chat (no tools)")
+        print()
+
+        # Plugins
+        print(f"  {P.LABEL}🔌 Plugins:{P.R}")
+        print(f"    {P.INPUT}/plugins{P.R}      List all plugins")
+        print(f"    {P.INPUT}/plugins enable/disable/toggle <name>{P.R}")
+        print(f"    {P.INPUT}/plugins reload{P.R}")
+        print()
+
+        # Tasks
+        print(f"  {P.LABEL}📋 Tasks:{P.R}")
+        print(f"    {P.INPUT}/tasks{P.R}        List tasks")
+        print(f"    {P.INPUT}/task_create{P.R}  Create task")
+        print()
+
+        # Session
+        print(f"  {P.LABEL}💾 Session:{P.R}")
+        print(f"    {P.INPUT}/clear{P.R}        Clear conversation")
+        print(f"    {P.INPUT}/new{P.R}         New session")
+        print(f"    {P.INPUT}/save{P.R}         Save session")
+        print(f"    {P.INPUT}/sessions{P.R}     List sessions")
+        print(f"    {P.INPUT}/resume{P.R}      Resume session")
+        print()
+
+        # Utilities
+        print(f"  {P.LABEL}🔧 Utilities:{P.R}")
+        print(f"    {P.INPUT}/files{P.R}        List files")
+        print(f"    {P.INPUT}/status{P.R}       Show status")
+        print(f"    {P.INPUT}/logs{P.R}         View logs")
+        print(f"    {P.INPUT}/budget{P.R}       View budget")
+        print(f"    {P.INPUT}/multiline{P.R}    Multi-line input")
+        print()
+
+        # Skills
+        print(f"  {P.LABEL}🎯 Skills:{P.R}")
+        print(f"    {P.INPUT}/skill list{P.R}     List skills")
+        print(f"    {P.INPUT}/skill install{P.R}  Install from URL")
+        print(f"    {P.INPUT}/skill create{P.R}   Create new")
+        print(f"    {P.INPUT}/skill info{P.R}     Show details")
+        print(f"    {P.MUTED}  Use /skillname to invoke directly{P.R}")
+        print()
+
+        # Monitor
+        print(f"  {P.LABEL}📊 Monitor:{P.R}")
+        print(f"    {P.INPUT}/monitor start{P.R}  Start process")
+        print(f"    {P.INPUT}/monitor list{P.R}   List active")
+        print()
+
+        # Exit hint
+        print(f"  {P.MUTED}Type 'exit' or 'q' to quit{P.R}")
+
+        # Plugins section
+        if pm.plugins:
+            print()
+            enabled_plugins = [n for n, p in pm.plugins.items() if p.enabled]
+            disabled_plugins = [n for n, p in pm.plugins.items() if not p.enabled]
+
+            if enabled_plugins:
+                plugins_list = ", ".join(f"{P.PLUG}{name}{P.R}" for name in enabled_plugins)
+                print(f"  {P.PLUG}🔌 Enabled:{P.R} {plugins_list}")
+
+            if disabled_plugins:
+                plugins_list = ", ".join(f"{P.DIM}{name}{P.R}" for name in disabled_plugins)
+                print(f"  {P.DIM}⊘ Disabled:{P.R} {plugins_list}")
+
+        # Skills section
+        if skill_mgr and skill_mgr.skills:
+            skills = skill_mgr.list_skills()
+            shown = sorted(skills, key=lambda s: s.name)[:8]
+            skill_names = [f"/{s.name}" for s in shown]
+            more = f" {P.MUTED}(+{len(skills)-8} more){P.R}" if len(skills) > 8 else ""
+            skills_str = ", ".join(f"{P.CYAN}{n}{P.R}" for n in skill_names)
+            print(f"  {P.CYAN}🎯 Skills:{P.R} {skills_str}{more}")
+        print()
+
+    def show_profile(self, profile, all_profiles=None):
+        """Display profile information."""
+        from hanus.profiles import ProfileMeta
+
+        if all_profiles is not None:
+            # List all profiles
+            print(f"{P.HEADER}{'─' * 20} PROFILES {'─' * (W - 30)}{P.R}")
+            if not all_profiles:
+                print(f"  {P.MUTED}No profiles found.{P.R}")
+                return
+
+            active_name = profile.name if profile else ""
+            for meta in all_profiles:
+                marker = f"{P.OK}●{P.R}" if meta.name == active_name else f"{P.DIM}○{P.R}"
+                print(f"  {marker} {P.LABEL}{meta.name}{P.R}  {P.MUTED}— {meta.display}{P.R}")
+                if meta.tags:
+                    tags = " ".join(f"[{t}]" for t in meta.tags[:4])
+                    print(f"      {P.DIM}{tags}{P.R}")
+            print()
+            print(f"  {P.MUTED}Use '/profile <name>' to switch.{P.R}")
+            print(f"  {P.MUTED}Use '/profile new <name>' to create.{P.R}")
+            print()
+            return
+
+        if not profile:
+            print(f"  {P.ERR}No active profile.{P.R}")
+            return
+
+        m = profile.meta
+        print()
+        print(f"{P.HEADER}{'─' * 20} PROFILE: {m.display} {'─' * (W - 32 - len(m.display))}{P.R}")
+        print(f"  {P.ACCENT}📛 Name:{P.R}        {m.name}")
+        print(f"  {P.ACCENT}📝 Description:{P.R} {m.description}")
+        if m.tags:
+            print(f"  {P.ACCENT}🏷️ Tags:{P.R}        {', '.join(m.tags)}")
+        if m.provider:
+            prov_str = f"{m.provider}" + (f"/{m.model_id}" if m.model_id else "")
+            print(f"  {P.ACCENT}🤖 Model:{P.R}       {prov_str}")
+        if m.permission_mode:
+            print(f"  {P.ACCENT}🔒 Permissions:{P.R}  {m.permission_mode}")
+        print()
+        prompt_preview = profile.system_prompt.strip().replace("\n", " ")[:100]
+        print(f"  {P.DIM}Prompt:{P.R} {P.MUTED}{prompt_preview}...{P.R}")
+        print(f"  {P.DIM}File:{P.R}    ~/.hanus/profiles/{m.name}/system_prompt.txt")
+        print()
+
+    def show_streaming_status(self):
+        """Display streaming status."""
+        status = f"{P.OK}ON{P.R}" if self._streaming_enabled else f"{P.ERR}OFF{P.R}"
+        print(f"  Streaming: {status}")
+        print(f"  {P.MUTED}Use /stream to toggle{P.R}")
+
+    # ── Agent Response (streaming) ─────────────────────────────────────────────
+
+    def stream_start(self):
+        """Start streaming mode."""
+        if not self._streaming_enabled:
+            return
+        self._streaming = True
+        self._stream_line_len = 0
+        print()
+        print(f"{P.AGENT}┌{'─' * W}┐{P.R}")
+        print(f"{P.AGENT}│{P.R}")
+        print(f"{P.AGENT}├{'─' * W}┤{P.R}")
+
+    def stream_token(self, token: str):
+        """Display streaming token."""
+        if not self._streaming_enabled:
+            return
+        if not self._streaming:
+            self.stream_start()
+        print(token, end="", flush=True)
+
+    def stream_end(self):
+        """End streaming mode."""
+        if self._streaming:
+            print()
+            print(f"{P.AGENT}└{'─' * W}┘{P.R}")
+            print()
+        self._streaming = False
+        self._stream_line_len = 0
+
+    def thinking(self, text: str):
+        """Display thinking/explanation text before tool execution."""
+        # Clean the text from XML tags
+        clean = _strip_xml(text)
+        if not clean.strip():
+            return
+
+        print()
+        print(f"{P.CYAN}💭 Thinking...{P.R}")
+        print(f"{P.DIM}{'─' * 40}{P.R}")
+
+        # Show the cleaned text, wrapped
+        for line in (clean.strip().splitlines() or [""]):
+            if line.strip():
+                wrapped = _tw.wrap(line, W - 4)
+                for wl in wrapped:
+                    print(f"  {P.MUTED}{wl}{P.R}")
+            else:
+                print()
+
+    def agent_response(self, text: str):
+        """Display complete response when streaming is off."""
+        print()
+        print(f"{P.AGENT}┌{'─' * W}┐{P.R}")
+        print(f"{P.AGENT}│{P.R}")
+        print(f"{P.AGENT}├{'─' * W}┤{P.R}")
+        clean = _strip_xml(text)
+        for line in (clean.strip().splitlines() or [""]):
+            wrapped = _tw.wrap(line, W - 4) if line.strip() else [""]
+            for wl in wrapped:
+                print(f"  {wl}")
+        print(f"{P.AGENT}└{'─' * W}┘{P.R}")
+        print()
+
+    # ── Cost Bar ───────────────────────────────────────────────────────────────
+
+    def show_cost_bar(self, cost: float, inp: int, out: int,
+                      session_cost: float, budget: float):
+        """Display cost information bar."""
+        print()
+        cost_color = P.OK
+        if budget > 0:
+            pct = session_cost / budget
+            cost_color = P.WARN if pct > 0.5 else P.OK
+            if pct > 0.8:
+                cost_color = P.ERR
+
+        print(f"  {P.DIM}┌{'─' * 40}┐{P.R}")
+        print(f"  {P.DIM}│{P.R} {P.ACCENT}📊 Tokens:{P.R} ↑{inp:,} ↓{out:,}")
+        print(f"  {P.DIM}│{P.R} {P.ACCENT}💰 Cost:{P.R}   ${cost:.5f} (session: {cost_color}${session_cost:.4f}{P.R})")
+        if budget > 0:
+            remaining = budget - session_cost
+            print(f"  {P.DIM}│{P.R} {P.ACCENT}💵 Budget:{P.R}  ${budget:.2f} (${remaining:.2f} left)")
+        print(f"  {P.DIM}└{'─' * 40}┘{P.R}")
+
+    # ── Tools ─────────────────────────────────────────────────────────────────
+
+    def tool_start(self, name: str, args: Dict):
+        """Display tool execution start."""
+        label = _tool_label(name)
+        desc = _fmt_tool_desc(name, args)
+        print()
+        print(f"  {P.TOOL}▶ {label}{P.R}  {P.MUTED}{desc}{P.R}")
+
+    def tool_end(self, name: str, result: str, success: bool):
+        """Display tool execution end."""
+        lines = result.strip().splitlines()
+
+        if len(lines) > 5:
+            lines = lines[:5]
+            lines.append(f"{P.MUTED}... ({len(result.strip().splitlines()) - 5} more lines){P.R}")
+
+        if success:
+            print(f"  {P.OK}✓{P.R}  {lines[0][:70]}")
+            for l in lines[1:5]:
+                print(f"     {P.MUTED}{l[:75]}{P.R}")
+        else:
+            print(f"  {P.ERR}✗{P.R}  {lines[0][:70]}")
+            for l in lines[1:5]:
+                print(f"     {P.ERR}{l[:75]}{P.R}")
+
+    def plugin_result(self, name: str, result: str):
+        """Display plugin result."""
+        print()
+        print(f"  {P.PLUG}🔌 PLUGIN: {name}{P.R}")
+        print(f"  {P.DIM}{'─' * 40}{P.R}")
+
+        # No truncation - show full output for plugin results
+        for line in result.strip().splitlines():
+            print(f"  {line}")
+        print()
+
+    # ── Permission Dialog ─────────────────────────────────────────────────────
+
+    def ask_permission(self, tool: str, description: str, risk, args: Dict) -> "PermissionDecision":
+        """Ask user for permission."""
+        from hanus.permissions import PermissionDecision, RiskLevel
+
+        rc = {RiskLevel.LOW: P.OK, RiskLevel.MEDIUM: P.WARN, RiskLevel.HIGH: P.ERR}.get(risk, P.WARN)
+        rn = {RiskLevel.LOW: "LOW", RiskLevel.MEDIUM: "MEDIUM", RiskLevel.HIGH: "HIGH"}.get(risk, "?")
+        W2 = 54
+
+        print(f"\n  {P.WARN}┌{'─' * W2}┐{P.R}")
+        print(f"  {P.WARN}│{P.R}  ⚠️  PERMISSION REQUIRED{' ' * (W2 - 23)}{P.WARN}│{P.R}")
+        print(f"  {P.WARN}├{'─' * W2}┤{P.R}")
+        print(f"  {P.WARN}│{P.R}  🔧 Tool      {P.LABEL}{tool:<(W2 - 15)}{P.R}{P.WARN}│{P.R}")
+        print(f"  {P.WARN}│{P.R}  ⚡ Risk      {rc}{rn:<(W2 - 15)}{P.R}{P.WARN}│{P.R}")
+        desc_s = description[:(W2 - 15)]
+        print(f"  {P.WARN}│{P.R}  📝 Action    {P.MUTED}{desc_s:<(W2 - 15)}{P.R}{P.WARN}│{P.R}")
+        print(f"  {P.WARN}├{'─' * W2}┤{P.R}")
+        opts = "[y] Yes   [n] No   [Y] Always"
+        print(f"  {P.WARN}│{P.R}  {opts}{' ' * (W2 - len(opts) - 2)}{P.WARN}│{P.R}")
+        print(f"  {P.WARN}└{'─' * W2}┘{P.R}")
+
+        try:
+            ans = input(f"  Choice [y/n/Y]: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            ans = "n"
+
+        if ans == "Y":
+            return PermissionDecision(True, "Approved always in session", remember=True)
+        if ans.lower() == "y":
+            return PermissionDecision(True, "Approved by user")
+        return PermissionDecision(False, "Rejected by user")
+
+    # ── Ask User Question (Interactive) ───────────────────────────────────────
+
+    def ask_user_question(self, question: str, header: str, options: List[Dict], multi_select: bool) -> Dict:
+        """
+        Muestra una pregunta interactiva con opciones seleccionables.
+
+        Args:
+            question: La pregunta completa
+            header: Etiqueta corta (opcional)
+            options: Lista de dicts con 'label' y 'description'
+            multi_select: Si permitir múltiples selecciones
+
+        Returns:
+            Dict con 'selected' (lista), 'custom_input' (str), 'cancelled' (bool)
+        """
+        W2 = min(80, max(60, len(question) + 10))
+
+        print()
+        print(f"  {P.CYAN}┌{'─' * W2}┐{P.R}")
+
+        # Header
+        if header:
+            header_pad = (W2 - len(header) - 4) // 2
+            print(f"  {P.CYAN}│{P.R}  {P.LABEL}{' ' * header_pad}[{header}]{P.R}{' ' * (W2 - header_pad - len(header) - 6)}  {P.CYAN}│{P.R}")
+            print(f"  {P.CYAN}├{'─' * W2}┤{P.R}")
+
+        # Question (wrapped)
+        print(f"  {P.CYAN}│{P.R}")
+        wrapped = _tw.wrap(question, W2 - 4)
+        for line in wrapped:
+            print(f"  {P.CYAN}│{P.R}  {P.WHITE}{line}{P.R}")
+        print(f"  {P.CYAN}│{P.R}")
+        print(f"  {P.CYAN}├{'─' * W2}┤{P.R}")
+
+        # Options
+        for i, opt in enumerate(options, 1):
+            label = opt.get("label", f"Option {i}")
+            desc = opt.get("description", "")
+
+            # Marca para multi-select
+            checkbox = "☐" if multi_select else "○"
+            print(f"  {P.CYAN}│{P.R}  {P.ACCENT}{checkbox} {i}.{P.R}  {P.LABEL}{label}{P.R}")
+            if desc:
+                desc_wrap = _tw.wrap(desc, W2 - 10)
+                for dline in desc_wrap:
+                    print(f"  {P.CYAN}│{P.R}      {P.MUTED}{dline}{P.R}")
+
+        # Other option
+        other_num = len(options) + 1
+        print(f"  {P.CYAN}│{P.R}")
+        print(f"  {P.CYAN}│{P.R}  {P.DIM}○ {other_num}. Other (custom input){P.R}")
+
+        # Instructions
+        print(f"  {P.CYAN}│{P.R}")
+        if multi_select:
+            print(f"  {P.CYAN}│{P.R}  {P.DIM}Enter numbers separated by comma (e.g., '1,3') or '{other_num}' for custom{P.R}")
+        else:
+            print(f"  {P.CYAN}│{P.R}  {P.DIM}Enter a number (1-{other_num}) or type your answer{P.R}")
+        print(f"  {P.CYAN}└{'─' * W2}┘{P.R}")
+
+        # Get input
+        try:
+            ans = input(f"  {P.INPUT}Your answer: {P.R}").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return {"selected": [], "custom_input": "", "cancelled": True}
+
+        # Parse input
+        if not ans:
+            return {"selected": [], "custom_input": "", "cancelled": True}
+
+        # Check if it's a number selection
+        try:
+            if multi_select:
+                # Parse comma-separated numbers
+                nums = [int(x.strip()) for x in ans.split(",")]
+                selected = []
+                for n in nums:
+                    if 1 <= n <= len(options):
+                        selected.append(options[n-1]["label"])
+                    elif n == other_num:
+                        # Ask for custom input
+                        try:
+                            custom = input(f"  {P.INPUT}Enter your input: {P.R}").strip()
+                        except (EOFError, KeyboardInterrupt):
+                            custom = ""
+                        return {"selected": [], "custom_input": custom, "cancelled": False}
+                if selected:
+                    return {"selected": selected, "custom_input": "", "cancelled": False}
+            else:
+                # Single selection
+                n = int(ans)
+                if 1 <= n <= len(options):
+                    return {"selected": [options[n-1]["label"]], "custom_input": "", "cancelled": False}
+                elif n == other_num:
+                    try:
+                        custom = input(f"  {P.INPUT}Enter your input: {P.R}").strip()
+                    except (EOFError, KeyboardInterrupt):
+                        custom = ""
+                    return {"selected": [], "custom_input": custom, "cancelled": False}
+        except ValueError:
+            pass
+
+        # Non-numeric input - treat as custom input
+        return {"selected": [], "custom_input": ans, "cancelled": False}
+
+    # ── Listings ──────────────────────────────────────────────────────────────
+
+    def show_files(self, files: list):
+        """Display file list."""
+        print(f"\n{P.HEADER}{_sec(f'FILES ({len(files)})', Icon.GLOB)}{P.R}")
+        for f in files[:100]:
+            print(f"  {P.MUTED}{Icon.BULLET}{P.R}  {f}")
+        if len(files) > 100:
+            print(f"  {P.MUTED}... and {len(files) - 100} more{P.R}")
+        print()
+
+    def show_plugins(self, pm: "PluginManager"):
+        """Display plugin list with status."""
+        print(f"\n{P.HEADER}{_sec('PLUGINS', Icon.PLUGIN)}{P.R}")
+        if not pm.plugins:
+            print(f"  {P.MUTED}No plugins in '{pm.plugins_dir}'{P.R}")
+            print()
+
+        # Separate enabled and disabled
+        enabled = [(n, p) for n, p in pm.plugins.items() if p.enabled]
+        disabled = [(n, p) for n, p in pm.plugins.items() if not p.enabled]
+
+        if enabled:
+            print(f"  {P.OK}✓ Enabled:{P.R}")
+            for name, p in sorted(enabled):
+                print(f"    {P.PLUG}{Icon.PLUGIN}  {name:<20}{P.R}  {P.MUTED}{p.description}{P.R}")
+                if p.usage:
+                    print(f"       {P.DIM}Usage: {p.usage}{P.R}")
+
+        if disabled:
+            print(f"\n  {P.ERR}✗ Disabled:{P.R}")
+            for name, p in sorted(disabled):
+                print(f"    {P.DIM}{Icon.PLUGIN}  {name:<20}  {p.description}{P.R}")
+
+        print(f"\n  {P.DIM}Use '/plugins enable/disable <name>' to manage{P.R}")
+        print()
+
+    def show_history(self, messages: List[Dict]):
+        """Display message history."""
+        print(f"\n{P.HEADER}{_sec(f'HISTORY ({len(messages)} messages)', '📜')}{P.R}")
+        for i, m in enumerate(messages):
+            color = {
+                "system":    P.MUTED,
+                "user":      P.ACCENT,
+                "assistant": P.AGENT,
+            }.get(m["role"], P.LABEL)
+            content = str(m.get("content", ""))
+            preview = content.replace("\n", " ")[:90]
+            if len(content) > 90:
+                preview += "..."
+            print(f"  {color}[{i:02d}] {m['role']:<11}{P.R}  {P.MUTED}{preview}{P.R}")
+        print()
+
+    def show_sessions(self, sessions: List[Dict]):
+        """Display saved sessions."""
+        print(f"\n{P.HEADER}{_sec('SAVED SESSIONS', '💾')}{P.R}")
+        if not sessions:
+            print(f"  {P.MUTED}No saved sessions.{P.R}")
+        for s in sessions:
+            print(f"  {P.LABEL}{s['id']}{P.R}")
+            print(f"    {P.MUTED}{s['name']}  │  {s['model']}  │  ${s['cost']:.4f}  │  {s['messages']} msgs  │  {s['updated']}{P.R}")
+        print()
+
+    def show_audit(self, log: List[Dict]):
+        """Display permission audit log."""
+        print(f"\n{P.HEADER}{_sec('PERMISSION LOG', '📋')}{P.R}")
+        if not log:
+            print(f"  {P.MUTED}No entries.{P.R}")
+        for e in log[-25:]:
+            icon = f"{P.OK}✓{P.R}" if e["approved"] else f"{P.ERR}✗{P.R}"
+            ts = time.strftime("%H:%M:%S", time.localtime(e["ts"]))
+            print(f"  {icon}  {ts}  {e['tool']:<22}  {P.MUTED}{e['reason']}{P.R}")
+        print()
+
+    def show_stats(self, session: Optional["SessionData"]):
+        """Display session statistics."""
+        if not session:
+            self.info("No active session.")
+            return
+        print(f"\n{P.HEADER}{_sec('STATISTICS', '📊')}{P.R}")
+        rows = [
+            ("📁 Session",         session.name),
+            ("🤖 Model",           f"{session.model_provider}/{session.model_id}"),
+            ("↑ Input tokens",     f"{session.total_input_tokens:,}"),
+            ("↓ Output tokens",    f"{session.total_output_tokens:,}"),
+            ("💰 Total cost",      f"${session.total_cost_usd:.4f} USD"),
+            ("💬 Messages",        str(len(session.messages))),
+            ("📝 Files modified",  str(len(session.files_modified))),
+            ("⚡ Commands",        str(len(session.commands_executed))),
+        ]
+        for label, val in rows:
+            print(f"  {P.ACCENT}{label:<20}{P.R}  {val}")
+        for f in session.files_modified[:10]:
+            print(f"    {P.MUTED}{Icon.BULLET}  {f}{P.R}")
+        print()
+
+    def show_models(self, connector):
+        """Display available models."""
+        print(f"\n{P.HEADER}{_sec(f'MODELS — {connector.provider_name}', '🤖')}{P.R}")
+        for m in connector.available_models:
+            if m == connector.model_id:
+                print(f"  {P.OK}►{P.R}  {P.LABEL}{m}{P.R}  {P.MUTED}← active{P.R}")
+            else:
+                print(f"     {m}")
+        print()
+
+    # ── Messages ──────────────────────────────────────────────────────────────
+
+    def success(self, msg: str):
+        """Display success message."""
+        print(f"  {P.OK}{Icon.SUCCESS}{P.R} {msg}")
+
+    def error(self, msg: str):
+        """Display error message."""
+        print(f"  {P.ERR}{Icon.ERROR} ERROR:{P.R} {msg}")
+
+    def warning(self, msg: str):
+        """Display warning message."""
+        print(f"  {P.WARN}{Icon.WARNING}{P.R} {msg}")
+
+    def info(self, msg: str):
+        """Display info message."""
+        print(f"  {P.INFO}{Icon.INFO}{P.R} {P.MUTED}{msg}{P.R}")
+
+    def goodbye(self):
+        """Display goodbye message."""
+        print()
+        print(f"  {P.HEADER}{'─' * 20}{P.R}")
+        print(f"  {P.HEADER}👋 Goodbye!{P.R}")
+        print(f"  {P.HEADER}{'─' * 20}{P.R}")
+        print()
+
+    def prompt(self) -> str:
+        """Read user input."""
+        from hanus.terminal_prompt import get_prompt
+        tp = get_prompt()
+        tp.streaming_enabled = self._streaming_enabled
+        return tp.read_line()
+
+    def prompt_multiline(self, prompt_text: str = "") -> str:
+        """Read multiline input."""
+        from hanus.terminal_prompt import get_prompt
+        tp = get_prompt()
+        return tp.read_multiline(prompt_text)