ghostcode-canary 0.1.25-canary.0

package/src/ghostcode/tui/screens.py

@@ -0,0 +1,799 @@
+import asyncio
+import os
+from pathlib import Path
+
+import httpx
+from ghostcode._version import get_version
+from rich.table import Table
+from rich.text import Text
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal
+from textual.reactive import reactive
+from textual.screen import Screen
+from textual.widgets import Footer, Input, RichLog, Static
+
+from ghostcode.ai.factory import create_client
+from ghostcode.ai.registry import PROVIDERS, provider_status
+from ghostcode.agents import AGENTS
+from ghostcode.core.file_ops import autosave_code_blocks
+from ghostcode.core.prompt import build_messages, detect_greeting
+from ghostcode.core.commands import dispatch as cmd_dispatch, list_commands
+from ghostcode.core.memory import memory_summary, count_memories, list_memories, delete_memory
+from ghostcode.core.security import list_deny_rules
+from ghostcode.core.hooks import hook_registry
+from ghostcode.core.tasks import task_manager
+from ghostcode.tools import TOOL_DEFINITIONS
+from ghostcode.tui.dialogs import ApiKeyDialog, DevMenu, PermissionDialog, UpdateDialog
+from ghostcode.tui.widgets import dim_text, render_chat_content
+from ghostcode.utils.config_loader import (
+    get_api_key,
+    get_default_provider,
+    get_last_model,
+    set_api_key,
+    set_default_provider,
+    set_last_model,
+)
+
+
+class StatusBar(Static):
+    provider = reactive("nvidia")
+    model = reactive("")
+    cwd = reactive("")
+    agent = reactive("code")
+
+    def __init__(self, provider: str = "nvidia", model: str = "", cwd: str = "", agent: str = "code"):
+        super().__init__()
+        self.provider = provider
+        self.model = model
+        self.cwd = cwd
+        self.agent = agent
+        self._build()
+
+    def _build(self):
+        t = Text()
+        t.append(" GhostCode ", style="bold cyan")
+        t.append("│", style="dim")
+        pid = self.provider
+        has = bool(get_api_key(pid))
+        status = provider_status(pid, has)
+        color = {"connected": "green", "needs key": "yellow", "coming soon": "dim"}.get(status, "dim")
+        t.append(f" {self.provider.upper()} ", style=f"bold {color}")
+        if has:
+            t.append("[key] ", style="dim")
+        t.append("│", style="dim")
+        t.append(f" {self.model} ", style="cyan")
+        t.append("│", style="dim")
+        ainfo = AGENTS.get(self.agent, {})
+        aname = ainfo.get("name", self.agent.upper())
+        t.append(f" {aname} ", style="bold magenta")
+        t.append("│", style="dim")
+        t.append(f" {self.cwd} ", style="dim")
+        self.update(t)
+
+    def watch_provider(self, val):
+        self._build()
+
+    def watch_model(self, val):
+        self._build()
+
+    def watch_cwd(self, val):
+        self._build()
+
+    def watch_agent(self, val):
+        self._build()
+
+    def refresh_status(self):
+        self._build()
+
+
+class ChatScreen(Screen):
+    MAX_HISTORY = 100
+    TRIM_TO = 50
+
+    BINDINGS = [
+        Binding("ctrl+l", "clear", "Clear"),
+        Binding("ctrl+q", "quit", "Quit"),
+        Binding("escape", "cancel_stream", "Cancel"),
+        Binding("tab", "switch_agent", "Agent"),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self._provider = get_default_provider()
+        last_model = get_last_model(self._provider)
+        self._model = last_model
+        self._client = create_client(self._provider, self._model)
+        self._history: list[dict] = []
+        self._streaming = False
+        self._agent = "code"
+        self._agent_order = list(AGENTS.keys())
+        self._agent_index = 0
+        self._cmd_suggestions = [
+            ("/init", "create GHOST.md for this project"),
+            ("/api connect", "show / set API keys"),
+            ("/api connect <provider>", "enter API key for a provider"),
+            ("/api connect <provider> <key>", "set API key directly"),
+            ("/provider", "list providers"),
+            ("/provider <name>", "switch provider"),
+            ("/model", "list models for current provider"),
+            ("/model <name>", "switch model"),
+            ("/clear", "clear chat history"),
+            ("/help", "show this help"),
+            ("/memory", "list/manage persistent memories"),
+            ("/memory save <name> <content>", "save a memory"),
+            ("/memory search <query>", "search memories"),
+            ("/memory delete <name>", "delete a memory"),
+            ("/memory summary", "show memory stats"),
+            ("/tasks", "list subagent tasks"),
+            ("/tasks stop <id>", "stop a task"),
+            ("/deny", "list security deny rules"),
+            ("/deny add <pattern>", "add a deny rule"),
+            ("/deny remove <pattern>", "remove a deny rule"),
+            ("/hooks", "list active hooks"),
+            ("/plan", "enter plan mode"),
+            ("/review", "run code review"),
+            ("/summary", "summarize session"),
+            ("/ask", "ask a structured question"),
+            ("/brief", "toggle brief output mode"),
+        ]
+
+    def on_mount(self):
+        asyncio.create_task(self._check_update())
+
+    async def _check_update(self):
+        try:
+            async with httpx.AsyncClient() as client:
+                r = await client.get(
+                    "https://registry.npmjs.org/ghostcode-canary/latest",
+                    timeout=5,
+                )
+                if r.status_code == 200:
+                    latest = r.json().get("version", "")
+                    current = get_version()
+                    if latest and self._is_newer(latest, current):
+                        await self.app.push_screen(UpdateDialog(current, latest))
+        except Exception:
+            pass
+
+    @staticmethod
+    def _is_newer(latest: str, current: str) -> bool:
+        try:
+            lp = tuple(int(x) for x in latest.split("."))
+            cp = tuple(int(x) for x in current.split("."))
+            return lp > cp
+        except ValueError:
+            return False
+
+    @on(Input.Submitted, "#prompt-input")
+    async def on_input_submit(self):
+        await self.action_submit()
+
+    def _trim_history(self):
+        if len(self._history) <= self.MAX_HISTORY:
+            return
+        self._history = self._history[-self.TRIM_TO:]
+        try:
+            log = self.query_one("#chat-log", RichLog)
+            log.clear()
+            for msg in self._history:
+                role = msg["role"]
+                content = msg["content"]
+                label = "[bold cyan]▎ You[/bold cyan]" if role == "user" else "[bold green]▎ GhostCode[/bold green]"
+                log.write(f"\n{label}")
+                log.write(render_chat_content(content))
+        except Exception:
+            pass
+
+    def compose(self) -> ComposeResult:
+        yield StatusBar(
+            provider=self._provider,
+            model=self._client.model_name,
+            cwd=os.getcwd(),
+            agent=self._agent,
+        )
+        yield RichLog(id="chat-log", highlight=True, markup=True)
+        yield Static(id="stream-area")
+        with Horizontal(id="input-area"):
+            yield Input(id="prompt-input", placeholder="Type a message... (Enter to send)")
+        yield Static(id="cmd-suggestions")
+        yield Footer()
+
+    CSS = """
+    Screen {
+        background: $background;
+    }
+    StatusBar {
+        background: $surface;
+        padding: 1 2;
+        dock: top;
+        border-bottom: tall $primary;
+    }
+    #chat-log {
+        height: 1fr;
+        border: none;
+        background: $background;
+        padding: 1 2;
+        overflow-y: auto;
+    }
+    #input-area {
+        height: 4;
+        background: $surface;
+        border-top: tall $primary;
+        padding: 0 1;
+        align: center middle;
+    }
+    #prompt-input {
+        width: 1fr;
+        height: 3;
+        background: $surface;
+        color: $text;
+        border: round $primary;
+        margin: 0;
+    }
+    #prompt-input:focus {
+        border: round $accent;
+    }
+    #stream-area {
+        display: none;
+        height: auto;
+        max-height: 12;
+        background: $surface;
+        border-top: tall $primary;
+        padding: 1 2;
+        margin: 0;
+        overflow-y: auto;
+    }
+    #stream-area.visible {
+        display: block;
+    }
+    #cmd-suggestions {
+        display: none;
+        height: auto;
+        max-height: 10;
+        background: $surface;
+        border: tall $primary;
+        padding: 0 1;
+        margin: 0 1;
+        overflow-y: auto;
+    }
+    #cmd-suggestions.visible {
+        display: block;
+    }
+    Footer {
+        background: $surface;
+        dock: bottom;
+    }
+    """
+
+    def _log(self, text: str):
+        self.query_one("#chat-log", RichLog).write(text)
+
+    def _show_info(self, text: str):
+        self._log(f"\n[dim]{text}[/dim]")
+
+    def _persist_state(self):
+        set_default_provider(self._provider)
+        set_last_model(self._provider, self._client.model_name)
+
+    @on(Input.Changed, "#prompt-input")
+    def on_input_changed(self, event: Input.Changed):
+        widget = self.query_one("#cmd-suggestions", Static)
+        val = event.value.strip()
+        if not val.startswith("/"):
+            widget.classes = ""
+            return
+
+        query = val.lower()
+        lines = []
+        for cmd, desc in self._cmd_suggestions:
+            if query == "/" or cmd.lower().startswith(query):
+                lines.append(f"  [bold cyan]{cmd}[/bold cyan] [dim]{desc}[/dim]")
+
+        if lines:
+            widget.update("\n".join(lines))
+            widget.classes = "visible"
+        else:
+            widget.classes = ""
+
+    def action_quit(self):
+        self.app.exit()
+
+    async def action_clear(self):
+        self._history.clear()
+        self._streaming = False
+        self.query_one("#chat-log", RichLog).clear()
+        self.query_one("#stream-area", Static).classes = ""
+        self._show_info("Chat cleared.")
+
+    async def action_submit(self):
+        if self._streaming:
+            return
+        inp = self.query_one("#prompt-input", Input)
+        prompt = inp.value.strip()
+        if not prompt:
+            return
+        inp.value = ""
+        self._streaming = True
+
+        if prompt.startswith("/"):
+            if prompt.strip() == "/":
+                self._show_help()
+                self._streaming = False
+                inp.focus()
+                return
+            await self._handle_command(prompt)
+            self._streaming = False
+            return
+
+        has = bool(get_api_key(self._provider))
+        info = PROVIDERS.get(self._provider, {})
+        if info.get("needs_key") and not has:
+            self._log(f"\n[bold yellow]Provider {self._provider.upper()} needs an API key.[/bold yellow]")
+            self._log("Type [bold]/api connect[/bold] to see options.")
+            self._streaming = False
+            return
+
+        self._history.append({"role": "user", "content": prompt})
+        self._trim_history()
+        self._log(f"\n[bold cyan]▎ You[/bold cyan]")
+        self._log(render_chat_content(prompt))
+
+        greeting = detect_greeting(prompt)
+        if greeting:
+            self._log(f"\n[bold green]▎ GhostCode[/bold green]")
+            self._log(greeting)
+            self._history.append({"role": "assistant", "content": greeting})
+            self._trim_history()
+            self._streaming = False
+            inp.focus()
+            return
+
+        self._log(f"\n[bold green]▎ GhostCode[/bold green]")
+
+        stream_widget = self.query_one("#stream-area", Static)
+        info = PROVIDERS.get(self._provider, {})
+        pname = info.get("name", self._provider.upper())
+        stream_widget.update(f"[bold cyan]{pname} · {self._client.model_name}[/bold cyan]\n[dim]...thinking[/dim]")
+        stream_widget.classes = "visible"
+        self._streaming = True
+
+        messages = build_messages(self._history[:-1], prompt, agent=self._agent)
+        full = ""
+        has_tools = self._client.supports_tools
+        status = ""
+
+        async def _permission_callback(tool_name: str, args: dict) -> bool:
+            result = await self.app.push_screen(PermissionDialog(tool_name, args))
+            return bool(result)
+
+        try:
+            gen = (
+                self._client.chat(messages, tools=TOOL_DEFINITIONS, permission_callback=_permission_callback)
+                if has_tools
+                else self._client.generate(messages, stream=True)
+            )
+
+            async for chunk in gen:
+                if chunk.startswith("[dim]"):
+                    status = dim_text(chunk).strip()
+                    stream_widget.update(
+                        f"[bold cyan]{pname} · {self._client.model_name}[/bold cyan]\n[dim]{status}[/dim]"
+                    )
+                    continue
+                full += chunk
+                stream_widget.update(f"[bold green]{full}[/bold green]")
+                stream_widget.scroll_visible()
+
+            if full:
+                self._log(render_chat_content(full))
+                stream_widget.classes = ""
+                self._history.append({"role": "assistant", "content": full})
+                self._trim_history()
+                saved = autosave_code_blocks(full)
+                for s in saved:
+                    self._log(f"\n[dim]auto-saved -> {s['path']} ({s['size']} B)[/dim]")
+        except Exception as e:
+            stream_widget.update(f"[bold red]Error: {e}[/bold red]")
+        finally:
+            self._streaming = False
+
+        inp.focus()
+
+    async def action_cancel_stream(self):
+        if self._streaming:
+            self._streaming = False
+            sw = self.query_one("#stream-area", Static)
+            sw.classes = ""
+            self._show_info("Cancelled.")
+
+    def action_switch_agent(self):
+        agents = self._agent_order
+        self._agent_index = (self._agent_index + 1) % len(agents)
+        self._agent = agents[self._agent_index]
+        sb = self.query_one(StatusBar)
+        sb.agent = self._agent
+        self._show_info(f"Agent → {AGENTS[self._agent]['name']}")
+
+    async def _cmd_init(self):
+        inp = self.query_one("#prompt-input", Input)
+        stream_widget = self.query_one("#stream-area", Static)
+        stream_widget.update("[bold cyan]Analyzing codebase for GHOST.md...[/bold cyan]")
+        stream_widget.classes = "visible"
+        self._streaming = True
+
+        init_prompt = (
+            "Analyze this codebase and create a GHOST.md file at the project root. "
+            "This file will be given to future AI coding assistants to help them operate in this repository.\n\n"
+            "What to include:\n"
+            "1. Commands: how to build, lint, test, run a single test, and develop.\n"
+            "2. Architecture: high-level code structure so future AIs can be productive quickly.\n"
+            "3. Key files: README, configs, and any existing documentation.\n\n"
+            "Rules:\n"
+            "- Do not repeat yourself or include obvious instructions.\n"
+            "- Avoid listing every component or file — focus on the big picture.\n"
+            "- Don't make up information. Only include what you find by reading files.\n"
+            "- If a GHOST.md already exists, suggest improvements instead of overwriting.\n\n"
+            "Prefix the file with:\n"
+            "# GHOST.md\n\n"
+            "This file provides guidance to GhostCode when working with code in this repository."
+        )
+
+        messages = build_messages([], init_prompt, agent=self._agent)
+        full = ""
+        try:
+            if self._client.supports_tools:
+                async for chunk in self._client.chat(messages, tools=TOOL_DEFINITIONS):
+                    if chunk.startswith("[dim]"):
+                        stream_widget.update(f"[bold cyan]Exploring...[/bold cyan]\n[dim]{dim_text(chunk)}[/dim]")
+                        continue
+                    full += chunk
+                    stream_widget.update(f"[bold green]{full}[/bold green]")
+                    stream_widget.scroll_visible()
+            else:
+                async for chunk in self._client.generate(messages, stream=True):
+                    full += chunk
+                    stream_widget.update(f"[bold green]{full}[/bold green]")
+                    stream_widget.scroll_visible()
+
+            if full:
+                saved = autosave_code_blocks(full)
+                stream_widget.classes = ""
+                for s in saved:
+                    self._log(f"\n[dim]GHOST.md saved -> {s['path']} ({s['size']} B)[/dim]")
+                if not saved:
+                    self._log(f"\n[dim]GHOST.md created (check project root)[/dim]")
+        except Exception as e:
+            stream_widget.update(f"[bold red]Error: {e}[/bold red]")
+        finally:
+            self._streaming = False
+        inp.focus()
+
+    async def _handle_command(self, cmd: str):
+        parts = cmd.split()
+        root = parts[0].lower()
+
+        if root == "/clear":
+            await self.action_clear()
+
+        elif root == "/help" or root == "/?":
+            self._show_help()
+
+        elif root == "/model":
+            if len(parts) == 1:
+                self._show_model_list()
+            else:
+                self._model = parts[1]
+                self._client = create_client(self._provider, self._model)
+                sb = self.query_one(StatusBar)
+                sb.model = self._client.model_name
+                self._persist_state()
+                self._show_info(f"Model → {self._client.model_name}")
+
+        elif root == "/provider":
+            if len(parts) == 1:
+                self._show_api_list()
+            else:
+                pid = parts[1].lower()
+                if pid not in PROVIDERS:
+                    self._show_info(f"Unknown provider: {pid}")
+                    return
+                self._client = create_client(pid, PROVIDERS[pid]["default_model"])
+                self._provider = pid
+                self._model = self._client.model_name
+                sb = self.query_one(StatusBar)
+                sb.provider = pid
+                sb.model = self._client.model_name
+                self._persist_state()
+                self._show_model_list()
+
+        elif root == "/api":
+            await self._handle_api(parts[1:])
+
+        elif root == "/dev":
+            await self._show_dev_menu()
+
+        elif root == "/update":
+            await self._check_update()
+
+        elif root == "/init":
+            await self._cmd_init()
+
+        elif root == "/memory":
+            await self._cmd_memory(parts[1:])
+
+        elif root == "/tasks":
+            await self._cmd_tasks(parts[1:])
+
+        elif root == "/deny":
+            await self._cmd_deny(parts[1:])
+
+        elif root == "/hooks":
+            self._cmd_hooks()
+
+        elif root == "/plan":
+            await self._cmd_plan()
+
+        elif root == "/review":
+            await self._cmd_review()
+
+        elif root == "/summary":
+            await self._cmd_summary()
+
+        elif root == "/ask":
+            self._log(
+                "\n"
+                "[bold]Ask a question:[/bold]\n"
+                "  [dim]Usage: simply type your question directly. If you want multiple-choice options, list them like:[/dim]\n"
+                "  [dim]  Option A: ...[/dim]\n"
+                "  [dim]  Option B: ...[/dim]"
+            )
+
+        elif root == "/brief":
+            self._log("\n[dim]Brief mode toggled. (Placeholder — brief output preference not yet persisted.)[/dim]")
+
+        else:
+            self._show_info(f"Unknown: {root}  (/help)")
+
+    async def _handle_api(self, args: list[str]):
+        if not args or args[0] != "connect":
+            self._show_api_list()
+            return
+
+        if len(args) == 1:
+            self._show_api_list()
+        elif len(args) == 2:
+            pid = args[1].lower()
+            if pid not in PROVIDERS:
+                self._show_info(f"Unknown provider: {pid}")
+                return
+            info = PROVIDERS[pid]
+            if info.get("status") == "coming_soon":
+                self._show_info(f"[dim]{info['name']} is coming soon.[/dim]")
+                return
+            if not info["needs_key"]:
+                self._show_info(f"[dim]{info['name']} doesn't need an API key (local).[/dim]")
+                return
+            dialog = ApiKeyDialog(pid, info["name"])
+            key = await self.app.push_screen(dialog)
+            if key:
+                set_api_key(pid, key)
+                self._provider = pid
+                self._client = create_client(pid, self._model)
+                sb = self.query_one(StatusBar)
+                sb.provider = pid
+                sb.model = self._client.model_name
+                self._persist_state()
+                self._show_info(f"[green]{info['name']} API key saved.[/green]")
+        elif len(args) >= 3:
+            pid = args[1].lower()
+            key = " ".join(args[2:])
+            if pid not in PROVIDERS:
+                self._show_info(f"Unknown provider: {pid}")
+                return
+            set_api_key(pid, key)
+            self._provider = pid
+            self._client = create_client(pid, self._model)
+            sb = self.query_one(StatusBar)
+            sb.provider = pid
+            sb.model = self._client.model_name
+            self._persist_state()
+            info = PROVIDERS[pid]
+            self._show_info(f"[green]{info['name']} API key saved.[/green]")
+
+    async def _show_dev_menu(self):
+        await self.app.push_screen(DevMenu())
+
+    def _show_api_list(self):
+        table = Table(show_edge=False, show_header=False, padding=(0, 1))
+        table.add_column(style="bold", width=14)
+        table.add_column(width=30)
+        table.add_column(width=14)
+
+        for pid, info in PROVIDERS.items():
+            key = bool(get_api_key(pid))
+            st = provider_status(pid, key)
+            status_colors = {
+                "connected": "green",
+                "needs key": "yellow",
+                "coming soon": "dim",
+                "ready": "green",
+            }
+            sc = status_colors.get(st, "dim")
+            name = info["name"]
+            desc = info["description"]
+            table.add_row(
+                f"[bold]{name}[/bold]",
+                f"[dim]{desc}[/dim]",
+                f"[{sc}]{st}[/{sc}]",
+            )
+
+        self._log("\n" + "[bold]Available providers:[/bold]")
+        self._log(table)
+        self._log("[dim]Usage: /api connect <provider>  or  /api connect <provider> <key>[/dim]")
+
+    async def _cmd_memory(self, args: list[str]):
+        if not args:
+            mems = list_memories()
+            if not mems:
+                self._show_info("No memories saved. Use /memory save <name> <content> to create one.")
+            else:
+                self._log("\n" + "[bold]Memories:[/bold]")
+                for m in mems:
+                    meta = m.get("metadata", {})
+                    mtype = meta.get("type", "?")
+                    pinned = " [dim]📌[/dim]" if meta.get("pinned") else ""
+                    self._log(f"  [bold cyan]{m['name']}[/bold cyan] [dim]({mtype}{pinned})[/dim] — {m.get('description', '')[:80]}")
+            return
+
+        sub = args[0].lower()
+        if sub == "save" and len(args) >= 3:
+            name = args[1]
+            content = " ".join(args[2:])
+            from ghostcode.core.memory import save_memory
+            result = save_memory(name, content)
+            self._show_info(f"Memory saved: [bold cyan]{result['slug']}[/bold cyan] ({result['type']}, {result['bytes']}B)")
+        elif sub == "search" and len(args) >= 2:
+            query = " ".join(args[1:])
+            from ghostcode.core.memory import search_memory
+            results = search_memory(query)
+            if not results:
+                self._show_info(f"No memories matching '{query}'")
+            else:
+                self._log(f"\n[bold]Memories matching '{query}':[/bold]")
+                for r in results:
+                    self._log(f"  [bold cyan]{r['name']}[/bold cyan] — {r.get('description', '')[:100]}")
+        elif sub == "delete" and len(args) >= 2:
+            name = args[1]
+            ok = delete_memory(name)
+            self._show_info(f"Memory '{name}' {'deleted' if ok else 'not found'}")
+        elif sub == "summary":
+            s = memory_summary()
+            self._log(f"\n[bold]Memory Summary:[/bold] {s['total']} total")
+            for t, c in s.get("by_type", {}).items():
+                self._log(f"  [cyan]{t}:[/cyan] {c}")
+        else:
+            self._show_info("Usage: /memory [save|search|delete|summary] ...")
+
+    async def _cmd_tasks(self, args: list[str]):
+        if args and args[0] == "stop" and len(args) >= 2:
+            tid = args[1]
+            ok = task_manager.stop(tid)
+            self._show_info(f"Task {tid} {'stopped' if ok else 'not found or already complete'}")
+            return
+
+        tasks = task_manager.list_tasks()
+        if not tasks:
+            self._show_info("No tasks. Tasks are created automatically when the AI spawns subagents.")
+        else:
+            self._log("\n" + "[bold]Tasks:[/bold]")
+            for t in tasks:
+                color = {"completed": "green", "running": "cyan", "pending": "yellow", "failed": "red", "stopped": "dim"}.get(t["status"], "dim")
+                dur = f" ({t['duration_ms']}ms)" if t["duration_ms"] else ""
+                self._log(f"  [{color}]{t['id']}[/{color}] {t['description']} [dim]{t['status']}{dur}[/dim]")
+
+    async def _cmd_deny(self, args: list[str]):
+        if not args:
+            rules = list_deny_rules()
+            if not rules:
+                self._show_info("No deny rules configured.")
+            else:
+                self._log("\n" + "[bold]Deny rules:[/bold]")
+                for r in rules:
+                    self._log(f"  [bold yellow]{r['pattern']}[/bold yellow] [dim]{r.get('reason', '')}[/dim]")
+            return
+
+        sub = args[0].lower()
+        if sub == "add" and len(args) >= 2:
+            pattern = args[1]
+            reason = " ".join(args[2:]) if len(args) > 2 else ""
+            from ghostcode.core.security import add_deny_rule
+            add_deny_rule(pattern, reason)
+            self._show_info(f"Deny rule added: [bold yellow]{pattern}[/bold yellow]")
+        elif sub == "remove" and len(args) >= 2:
+            pattern = args[1]
+            from ghostcode.core.security import remove_deny_rule
+            ok = remove_deny_rule(pattern)
+            self._show_info(f"Deny rule {'removed' if ok else 'not found'}: {pattern}")
+        else:
+            self._show_info("Usage: /deny [add <pattern> [reason]|remove <pattern>]")
+
+    def _cmd_hooks(self):
+        s = hook_registry.summary()
+        self._log(f"\n[bold]Hooks:[/bold]")
+        self._log(f"  Before tool: {s['before_tool']}")
+        self._log(f"  After tool: {s['after_tool']}")
+        self._log(f"  Stop hook: {s['stop_hook']}")
+        self._log("[dim]Configure via .ghostcode/hooks.json[/dim]")
+
+    async def _cmd_plan(self):
+        self.action_switch_agent()
+        self._show_info("[bold cyan]Plan mode[/bold cyan] — explore, analyze, and design before implementing.")
+        self._log("[dim]Use the Plan agent to search code, analyze architecture, and create implementation plans. Switch back with Tab.[/dim]")
+
+    async def _cmd_review(self):
+        self._log("\n[bold]Code Review[/bold]")
+        self._log("[dim]Run /init to create GHOST.md, then ask the AI to review specific code or files.[/dim]")
+
+    async def _cmd_summary(self):
+        total_msgs = len(self._history)
+        mems = count_memories()
+        self._log(f"\n[bold]Session Summary[/bold]")
+        self._log(f"  Messages: {total_msgs}")
+        self._log(f"  Memories: {mems}")
+        self._log(f"  Agent: {AGENTS[self._agent]['name']}")
+        self._log(f"  Provider: {self._provider.upper()} · {self._client.model_name}")
+
+    def _show_help(self):
+        self._log(
+            "\n"
+            "[bold]Commands:[/bold]\n"
+            "  [bold cyan]/init[/bold cyan]                              create GHOST.md for this project\n"
+            "  [bold cyan]/api connect[/bold cyan]                    show providers\n"
+            "  [bold cyan]/api connect[/bold cyan] [green]<provider>[/green]         enter API key\n"
+            "  [bold cyan]/api connect[/bold cyan] [green]<provider> <key>[/green]   set key directly\n"
+            "  [bold cyan]/model[/bold cyan]                            show models\n"
+            "  [bold cyan]/model[/bold cyan] [green]<name>[/green]                   switch model\n"
+            "  [bold cyan]/provider[/bold cyan]                          show providers\n"
+            "  [bold cyan]/provider[/bold cyan] [green]<name>[/green]                switch provider\n"
+            "  [bold cyan]/clear[/bold cyan]                            clear chat\n"
+            "  [bold cyan]/memory[/bold cyan]                            list/manage memories\n"
+            "  [bold cyan]/memory save[/bold cyan] [green]<name> <content>[/green]   save a memory\n"
+            "  [bold cyan]/memory search[/bold cyan] [green]<query>[/green]           search memories\n"
+            "  [bold cyan]/memory delete[/bold cyan] [green]<name>[/green]             delete a memory\n"
+            "  [bold cyan]/memory summary[/bold cyan]                    show memory stats\n"
+            "  [bold cyan]/tasks[/bold cyan]                             list subagent tasks\n"
+            "  [bold cyan]/tasks stop[/bold cyan] [green]<id>[/green]                stop a task\n"
+            "  [bold cyan]/deny[/bold cyan]                              list deny rules\n"
+            "  [bold cyan]/deny add[/bold cyan] [green]<pattern>[/green]               add deny rule\n"
+            "  [bold cyan]/deny remove[/bold cyan] [green]<pattern>[/green]            remove deny rule\n"
+            "  [bold cyan]/hooks[/bold cyan]                             show hook status\n"
+            "  [bold cyan]/plan[/bold cyan]                              enter plan mode (Tab)\n"
+            "  [bold cyan]/review[/bold cyan]                            init code review\n"
+            "  [bold cyan]/summary[/bold cyan]                           session summary\n"
+            "  [bold cyan]/ask[/bold cyan]                               show ask usage\n"
+            "  [bold cyan]/brief[/bold cyan]                             toggle brief output mode\n"
+            "  [bold cyan]/help[/bold cyan]                             this help" + "\n"
+            "\n"
+            "[dim]Tab — switch agent  |  Ctrl+L — clear  |  Ctrl+Q — quit  |  Esc — cancel[/dim]"
+        )
+
+    def _show_model_list(self):
+        info = PROVIDERS.get(self._provider, {})
+        models = info.get("models", [])
+        name = info.get("name", self._provider.upper())
+        current = self._client.model_name
+
+        self._log(f"\n[bold]{name} models[/bold] [dim](current: {current})[/dim]")
+
+        table = Table(show_edge=False, show_header=False, padding=(0, 1))
+        table.add_column(width=2)
+        table.add_column(width=50)
+
+        for m in models:
+            marker = "[green]→[/green]" if m == current else " "
+            table.add_row(marker, m)
+
+        self._log(table)
+        self._log("[dim]Usage: /model <model-name>[/dim]")