devobin 1.0.0__py3-none-any.whl

devobin/ui/chat_screen.py

@@ -0,0 +1,1029 @@
+"""Chat screen for DevObin AI."""
+
+from __future__ import annotations
+
+import os
+from rich.markup import escape
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Static, Input
+from textual.containers import Vertical, VerticalScroll
+from textual.binding import Binding
+from textual import on
+
+from devobin.config.settings import get_config
+from devobin.core.analyzer import analyze_input
+from devobin.core.researcher import research_analysis
+from devobin.core.memory import MemoryManager
+from devobin.core.optimizer import compress_context
+from devobin.core.executor import get_executor, get_file_manager
+from devobin.core.validator import validate_output, validate_grounding, build_rewrite_prompt, get_mode_message
+from devobin.core.rtl import smart_display, reshape_rtl
+from devobin.storage.database import ProjectStorage
+
+SYSTEM_PROMPT = """You are DevObin — an AI Prompt Engineering System.
+
+You are a PROMPT ARCHITECT, not a CODER.
+You create engineering instructions FOR other AI coding agents to implement.
+You do NOT deliver the implementation yourself.
+
+## HOW YOU WORK (Step by Step)
+
+1. **Understand**: The user describes WHAT they want to build/change. They do NOT tell you the tech stack — you figure that out yourself.
+2. **Explore**: Use tools to read the actual code. Read ALL key files. From the code, determine:
+   - What language(s) are used
+   - What frameworks/libraries are used
+   - What patterns are followed
+   - What the architecture looks like
+3. **Analyze**: Based on what you read, understand the REAL architecture. Do NOT guess — verify from the code.
+4. **Write**: Produce a CUSTOMIZED engineering prompt based on what you ACTUALLY found.
+   - Reference SPECIFIC files, SPECIFIC classes, SPECIFIC functions
+   - Use the REAL tech stack you discovered from reading the code
+   - Do NOT ask the user "what language do you use?" — you already know from reading the files
+   - Do NOT suggest technologies not in the project unless the user explicitly asked for them
+
+## YOUR ROLE: You are the detective, not the user
+
+- The user tells you the GOAL ("add caching", "fix the export", "add a new feature")
+- YOU discover the TECH by reading the code
+- YOU figure out the ARCHITECTURE by exploring the files
+- NEVER ask "what language is this?" or "what framework do you use?" — you can see it in the files
+- NEVER assume or guess — always verify from the actual code you read
+
+## TOOLS — EXPLORE AND CREATE
+
+[TOOL:glob:**/*.py]           — find files matching a glob pattern
+[TOOL:grep:regex]             — search file contents with a regex
+[TOOL:read:devobin/main.py]  — read a file's full content
+[TOOL:ls:devobin/core/]       — list a directory's entries
+[TOOL:write:my_prompt.md]     — create/update a .md prompt file
+
+## MANDATORY: YOU MUST WRITE THE FILE YOURSELF
+
+NEVER just produce the prompt as text in your response.
+ALWAYS use [TOOL:write:filename.md] to save the prompt to a file.
+
+The user should NEVER have to type /export. YOU create the file.
+
+### Complete workflow:
+1. [TOOL:ls:.] — see project structure
+2. [TOOL:glob:**/*.py] — find all source files
+3. [TOOL:read:path] — read EVERY important file
+4. [TOOL:read:existing_prompt.md] — check if prompt already exists
+5. [TOOL:write:my_feature_prompt.md] — CREATE THE FILE with your prompt
+
+### After writing the file, tell the user:
+"Created: my_feature_prompt.md"
+
+Do NOT dump the prompt content in your response text.
+Do NOT ask the user to run /export.
+Just write the file and confirm it was created.
+
+### When user gives a new request:
+1. [TOOL:glob:**/*_prompt.md] — find existing prompts
+2. [TOOL:read:old_prompt.md] — read the old prompt
+3. [TOOL:read:source_code.py] — read the code
+4. [TOOL:write:old_prompt.md] — UPDATE the existing prompt file
+
+## IF NO FILES EXIST
+
+If the workspace scan shows 0 files, do NOT call any tools.
+Work only from the user's description. Ask clarifying questions if needed.
+
+## CRITICAL: ONLY REFERENCE WHAT ACTUALLY EXISTS
+
+The "Detected Workspace" block below shows the REAL files, languages, and structure.
+- Read the code to DETERMINE the tech stack — don't guess
+- If there is NO database file → do NOT mention databases, PostgreSQL, MySQL, SQL, ORMs
+- If there is NO Dockerfile → do NOT mention Docker or containers
+- If there is NO frontend code → do NOT mention HTML, CSS, JavaScript, React
+- NEVER invent technologies not found in the code you read
+- NEVER ask the user "what language/framework?" — you already know from reading the files
+- ONLY suggest changes that extend what ALREADY EXISTS in the project
+
+## WHAT TO SHOW THE USER
+
+When reading files, do NOT dump the code to the user. The system shows only:
+- File name and line count
+- Key classes and functions found
+
+Your response to the user should be a summary of what you found, not the code itself.
+The full code is available to you internally — use it to build the prompt.
+
+## FORBIDDEN
+
+- Complete source files or full applications
+- Generic template prompts that could apply to any project
+- Inventing technologies not in the detected workspace
+- Code blocks longer than ~12 lines
+- Mentioning databases, ORMs, or SQL when the project has none
+
+## IF THE USER ASKS YOU TO BUILD / WRITE THE CODE
+
+Do NOT deliver the implementation. Say:
+"I'm DevObin — a prompt engineering tool. I craft the engineering prompt so a
+coding agent (Codex/Claude/Cursor) builds it for you.
+Use /export to save your engineering document."
+
+## OUTPUT FORMAT
+
+Write a CUSTOMIZED engineering prompt with these sections, but ONLY include
+sections relevant to THIS specific project:
+
+- **Role** — who the coding agent should be (based on the REAL stack)
+- **Project Context** — what the project ACTUALLY is (reference specific files)
+- **Current Architecture** — what you found when reading the code
+- **User Objective** — what the user wants to add/change
+- **Technical Requirements** — based on REAL patterns in the codebase
+- **Constraints** — based on REAL conventions in the project
+- **Security / Performance** — relevant to THIS stack
+
+Do NOT include sections that don't apply (e.g., no "Responsive Design" for a CLI tool).
+
+## AVAILABLE COMMANDS
+
+/run, /read, /write, /ls, /export, /connect, /model, /project, /memory, /scan
+When ready: tell user "Ready — use /export to save your engineering document." """
+
+LOGO = r"""[#00d4aa]
+   ___              ___  _    _
+  |   \ _____ __   / _ \| |__(_)_ _
+  | |) / -_) V /  | (_) | '_ \ | ' \
+  |___/\___|\_/    \___/|_.__/_|_||_|[/]
+[#4a4a4a]  Engineering Context Compiler · Prompt Architect[/]
+[#545d68]  by [bold #e6edf3]Mobin Hasanghasemi[/] · github.com/mobinhasanghasemi[/]"""
+
+
+class ChatScreen(Screen):
+    """Main chat screen."""
+
+    CSS = """
+    Screen { background: #0d1117; }
+
+    #header {
+        height: auto;
+        dock: top;
+        background: #0d1117;
+        padding: 1 2 0 2;
+    }
+    #logo { height: auto; }
+    #status-line {
+        height: 1;
+        color: #7d8590;
+        margin-top: 1;
+    }
+    #header-rule {
+        height: 1;
+        color: #1f2733;
+        background: #0d1117;
+    }
+
+    #chat-area {
+        height: 1fr;
+        padding: 1 2;
+        scrollbar-size-vertical: 1;
+        scrollbar-color: #2b3440;
+        scrollbar-color-hover: #00d4aa;
+    }
+
+    .msg {
+        height: auto;
+        margin: 0 0 1 0;
+        padding: 0 1;
+    }
+    .msg-user {
+        border-left: thick #00d4aa;
+        background: #11171f;
+    }
+    .msg-ai {
+        border-left: thick #2f81f7;
+    }
+    .msg-sys { border-left: thick #3a3a3a; }
+    .msg-err { border-left: thick #f85149; }
+    .msg-tech { border-left: thick #d29922; }
+    .msg-run { border-left: thick #a371f7; background: #161b22; }
+    .msg-output { border-left: thick #3fb950; background: #0d1117; }
+    .msg-file { border-left: thick #79c0ff; background: #0d1117; }
+
+    .role {
+        height: 1;
+        text-style: bold;
+        margin-bottom: 0;
+    }
+    .role-user { color: #00d4aa; }
+    .role-ai { color: #2f81f7; }
+    .role-sys { color: #7d8590; }
+    .role-err { color: #f85149; }
+    .role-tech { color: #d29922; }
+    .role-run { color: #a371f7; }
+    .role-output { color: #3fb950; }
+    .role-file { color: #79c0ff; }
+
+    .body { height: auto; color: #e6edf3; padding: 0; }
+    .body-sys { color: #7d8590; }
+    .body-err { color: #f85149; }
+    .body-tech { color: #d29922; }
+
+    #input-box {
+        height: auto;
+        dock: bottom;
+        background: #0d1117;
+        padding: 0 2 1 2;
+    }
+    #chat-input {
+        width: 100%;
+        background: #161b22;
+        color: #e6edf3;
+        border: round #2b3440;
+        padding: 0 1;
+    }
+    #chat-input:focus { border: round #00d4aa; }
+    #hint-bar {
+        height: 1;
+        color: #545d68;
+        margin-top: 0;
+    }
+    """
+
+    BINDINGS = [
+        Binding("ctrl+k", "show_commands", "Commands"),
+        Binding("ctrl+l", "clear_chat", "Clear"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.config = get_config()
+        project = self.config.get("active_project")
+        self.memory = MemoryManager(project)
+        self.storage = ProjectStorage(project) if project else None
+        if self.storage:
+            self.storage.new_session()  # Start a new session for this chat
+        self._loading = False
+        self._stream_body: Static | None = None
+        self._executor = get_executor()
+        self._files = get_file_manager()
+        self._last_ai_response: str = ""
+        self._project_map = None  # cached ProjectMap from scanning the workspace
+        self._scanned = False
+        self._last_update_len = 0  # throttle streaming updates
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="header"):
+            yield Static(LOGO, id="logo")
+            yield Static(self._status_text(), id="status-line")
+        yield Static("─" * 200, id="header-rule")
+
+        with VerticalScroll(id="chat-area"):
+            yield Static(
+                "[#00d4aa]DevObin AI — Prompt Architect Mode[/]\n"
+                "[#7d8590]Describe your project idea.[/]\n"
+                "[#545d68]I craft engineering prompts for AI coding agents.[/] [bold #e6edf3]No full code[/][#545d68] — only short snippets to sharpen the spec.[/]\n"
+                "[#545d68]Type[/] [bold]/[/] [ #545d68]for commands · /export to save[/]",
+                classes="msg msg-sys",
+            )
+
+        with Vertical(id="input-box"):
+            yield Input(placeholder="Describe your project or type / for commands…", id="chat-input")
+            yield Static(self._hint_text(), id="hint-bar")
+
+    # ── Header helpers ─────────────────────────────────────────────
+
+    def _status_text(self) -> str:
+        model = self.config.active_model or "not connected"
+        provider = self.config.active_provider or "none"
+        project = self.config.get("active_project") or "default"
+        dot = "[#3fb950]●[/]" if self.config.active_provider else "[#f85149]●[/]"
+        return (
+            f"{dot} [#e6edf3]{escape(provider)}[/] "
+            f"[#545d68]·[/] model [#e6edf3]{escape(model)}[/] "
+            f"[#545d68]·[/] project [#e6edf3]{escape(project)}[/]"
+        )
+
+    def _hint_text(self) -> str:
+        return "[#545d68]Prompt Architect Mode · Full Code Off · Snippets OK · /export to save[/]"
+
+    def _refresh_status(self) -> None:
+        try:
+            self.query_one("#status-line", Static).update(self._status_text())
+        except Exception:
+            pass
+
+    def on_mount(self) -> None:
+        self.query_one("#chat-input", Input).focus()
+
+    # ── Input handling ─────────────────────────────────────────────
+
+    @on(Input.Submitted, "#chat-input")
+    def on_submitted(self, event: Input.Submitted) -> None:
+        text = event.value.strip()
+        event.input.value = ""
+        if not text or self._loading:
+            return
+
+        if text == "/":
+            self.action_show_commands()
+        elif text.startswith("/"):
+            self._handle_cmd(text)
+        else:
+            self._process(text)
+
+    def action_show_commands(self) -> None:
+        from devobin.ui.command_palette import CommandPalette
+        self.app.push_screen(CommandPalette())
+
+    def action_clear_chat(self) -> None:
+        self.cmd_clear("")
+
+    def _handle_cmd(self, text: str) -> None:
+        parts = text.split(maxsplit=1)
+        cmd = parts[0].lower()
+        args = parts[1] if len(parts) > 1 else ""
+
+        def _open(module: str, klass: str):
+            mod = __import__(f"devobin.ui.{module}", fromlist=[klass])
+            self.app.push_screen(getattr(mod, klass)())
+
+        cmds = {
+            "/help": lambda a: _open("command_palette", "CommandPalette"),
+            "/connect": lambda a: _open("connect_modal", "ConnectModal"),
+            "/models": lambda a: _open("model_modal", "ModelModal"),
+            "/model": self._cmd_model,
+            "/project": lambda a: _open("project_modal", "ProjectModal"),
+            "/memory": lambda a: _open("memory_modal", "MemoryModal"),
+            "/export": self._cmd_export,
+            "/scan": self._cmd_scan,
+            "/history": self._cmd_history,
+            "/settings": lambda a: _open("settings_modal", "SettingsModal"),
+            "/clear": self.cmd_clear,
+            "/exit": lambda a: self.app.exit(),
+            "/quit": lambda a: self.app.exit(),
+            # Shell & file commands
+            "/run": self._cmd_run,
+            "/exec": self._cmd_run,
+            "/read": self._cmd_read,
+            "/cat": self._cmd_read,
+            "/write": self._cmd_write,
+            "/create": self._cmd_write,
+            "/ls": self._cmd_ls,
+            "/dir": self._cmd_ls,
+            "/tree": self._cmd_tree,
+            "/cwd": self._cmd_cwd,
+            "/cd": self._cmd_cd,
+            "/rm": self._cmd_rm,
+            "/delete": self._cmd_rm,
+            "/touch": self._cmd_touch,
+            "/mkdir": self._cmd_mkdir,
+            "/env": self._cmd_env,
+            "/pip": self._cmd_pip,
+            "/npm": self._cmd_npm,
+            "/git": self._cmd_git,
+            "/python": self._cmd_python,
+            "/paste": self._cmd_paste,
+        }
+
+        handler = cmds.get(cmd)
+        if handler:
+            handler(args)
+        else:
+            self._msg("sys", f"Unknown command: {escape(cmd)}")
+
+    def _cmd_model(self, args: str) -> None:
+        if args:
+            self.config.active_model = args.strip()
+            self._msg("sys", f"Model set to {args.strip()}")
+            self._refresh_status()
+        else:
+            self._msg("sys", f"Current model: {self.config.active_model or 'None'}")
+
+    def _cmd_export(self, args: str) -> None:
+        """Export prompt, optionally with a custom filename."""
+        from devobin.ui.export_modal import ExportModal
+        custom = args.strip() if args.strip() else ""
+        self.app.push_screen(ExportModal(
+            custom_filename=custom,
+            ai_response=self._last_ai_response,
+        ))
+
+    def cmd_clear(self, args: str = "") -> None:
+        if self.storage:
+            self.storage.clear_history()
+        area = self.query_one("#chat-area")
+        area.remove_children()
+        self._msg("sys", "Conversation cleared.")
+
+    # ── Workspace scanning ─────────────────────────────────────────
+
+    def _ensure_scan(self, announce: bool = False):
+        """Scan the workspace once and cache the project map."""
+        if self._scanned and self._project_map is not None:
+            return self._project_map
+        try:
+            from devobin.core.scanner import scan_workspace
+            self._project_map = scan_workspace()
+            self._scanned = True
+            if announce:
+                pm = self._project_map
+                self._msg(
+                    "tech",
+                    f"Scanned workspace: {pm.total_files} files · "
+                    f"primary {pm.primary_language} · {len(pm.dirs)} dirs",
+                )
+        except Exception as e:
+            self._msg("err", f"Scan failed: {escape(str(e))}")
+        return self._project_map
+
+    def _cmd_history(self, args: str) -> None:
+        """Open the chat history modal."""
+        from devobin.ui.history_modal import HistoryModal
+        self.app.push_screen(HistoryModal())
+
+    def _cmd_scan(self, args: str) -> None:
+        """Force a fresh scan of the current working directory."""
+        self._scanned = False
+        self._project_map = None
+        pm = self._ensure_scan(announce=True)
+        if pm is not None:
+            langs = ", ".join(f"{k} ({v})" for k, v in
+                              sorted(pm.languages.items(), key=lambda kv: kv[1], reverse=True)[:8])
+            entries = ", ".join(pm.entry_points[:6]) or "none detected"
+            manifests = ", ".join(pm.manifests.keys()) or "none"
+            self._msg(
+                "file",
+                f"[bold]Project map[/]\n"
+                f"root: {escape(pm.root)}\n"
+                f"languages: {escape(langs)}\n"
+                f"entry points: {escape(entries)}\n"
+                f"manifests: {escape(manifests)}",
+                styled=True,
+            )
+
+    # ── Shell & File Commands ──────────────────────────────────────
+
+    def _cmd_run(self, args: str) -> None:
+        """Execute a shell command."""
+        if not args.strip():
+            self._msg("sys", "Usage: /run <command>\nExample: /run python --version")
+            return
+        self._msg("run", f"$ {args}")
+        result = self._executor.run(args)
+        if result.success:
+            self._msg("output", result.output)
+        else:
+            self._msg("err", result.output)
+        if self.storage:
+            self.storage.add_message("user", f"/run {args}")
+            self.storage.add_message("assistant", f"[command output]\n{result.output}")
+
+    def _cmd_read(self, args: str) -> None:
+        """Read a file."""
+        if not args.strip():
+            self._msg("sys", "Usage: /read <file_path>\nExample: /read main.py")
+            return
+        result = self._files.read(args.strip())
+        self._msg("file", result.output)
+        if self.storage and result.success:
+            self.storage.add_message("user", f"/read {args}")
+
+    def _cmd_write(self, args: str) -> None:
+        """Write content to a file. Content is everything after the filename."""
+        parts = args.strip().split("\n", 1)
+        if not parts[0].strip():
+            self._msg("sys", "Usage: /write <file_path>\n<content>\n\nExample:\n/write hello.py\nprint('hello')")
+            return
+        filepath = parts[0].strip()
+        content = parts[1] if len(parts) > 1 else ""
+        if not content:
+            self._msg("sys", f"Provide content after the filename.\nUsage: /write {filepath}\n<your content here>")
+            return
+        result = self._files.write(filepath, content)
+        if result.success:
+            self._msg("file", result.output)
+        else:
+            self._msg("err", result.output)
+        if self.storage:
+            self.storage.add_message("user", f"/write {filepath}")
+
+    def _cmd_ls(self, args: str) -> None:
+        """List directory contents."""
+        path = args.strip() or "."
+        result = self._files.list_dir(path)
+        self._msg("file", result.output)
+
+    def _cmd_tree(self, args: str) -> None:
+        """Show project file tree."""
+        path = args.strip() or "."
+        result = self._executor.run(f'find "{path}" -not -path "*/.git/*" -not -path "*/__pycache__/*" -not -path "*/node_modules/*" -not -path "*/.venv/*" | head -50')
+        if result.stdout.strip():
+            self._msg("file", f"[bold]{escape(path)}[/]\n{escape(result.stdout.strip())}", styled=True)
+        else:
+            self._cmd_ls(args)
+
+    def _cmd_cwd(self, _args: str = "") -> None:
+        """Show current working directory."""
+        self._msg("sys", f"cwd: {os.getcwd()}")
+
+    def _cmd_cd(self, args: str) -> None:
+        """Change working directory."""
+        if not args.strip():
+            self._msg("sys", "Usage: /cd <path>")
+            return
+        try:
+            os.chdir(args.strip())
+            self._msg("sys", f"cwd: {os.getcwd()}")
+            self._executor = get_executor(os.getcwd())
+            self._files = get_file_manager(os.getcwd())
+        except Exception as e:
+            self._msg("err", f"cd failed: {e}")
+
+    def _cmd_rm(self, args: str) -> None:
+        """Delete a file or directory."""
+        if not args.strip():
+            self._msg("sys", "Usage: /rm <file_or_dir>")
+            return
+        result = self._files.delete(args.strip())
+        if result.success:
+            self._msg("file", result.output)
+        else:
+            self._msg("err", result.output)
+
+    def _cmd_touch(self, args: str) -> None:
+        """Create an empty file."""
+        if not args.strip():
+            self._msg("sys", "Usage: /touch <file_path>")
+            return
+        result = self._files.write(args.strip(), "")
+        if result.success:
+            self._msg("file", f"[green]✓[/] Created: [bold]{escape(args.strip())}[/]", styled=True)
+        else:
+            self._msg("err", result.output)
+
+    def _cmd_mkdir(self, args: str) -> None:
+        """Create a directory."""
+        if not args.strip():
+            self._msg("sys", "Usage: /mkdir <directory>")
+            return
+        try:
+            os.makedirs(args.strip(), exist_ok=True)
+            self._msg("file", f"[green]✓[/] Created directory: [bold]{escape(args.strip())}[/]", styled=True)
+        except Exception as e:
+            self._msg("err", f"mkdir failed: {e}")
+
+    def _cmd_env(self, args: str) -> None:
+        """Show environment variables (filtered)."""
+        safe_keys = ["PATH", "HOME", "USER", "SHELL", "PYTHON", "NODE", "PWD",
+                      "VIRTUAL_ENV", "CONDA_DEFAULT_ENV", "TERM", "LANG", "EDITOR"]
+        env_vars = {k: v for k, v in os.environ.items()
+                    if any(sk in k.upper() for sk in safe_keys)}
+        if args.strip():
+            val = os.environ.get(args.strip().upper(), "not set")
+            self._msg("sys", f"{args.strip().upper()}={val}")
+        else:
+            lines = "\n".join(f"  {k}={v}" for k, v in sorted(env_vars.items()))
+            self._msg("sys", f"Environment:\n{lines}")
+
+    def _cmd_pip(self, args: str) -> None:
+        """Run pip command."""
+        if not args.strip():
+            self._cmd_run("pip --version")
+        else:
+            self._cmd_run(f"pip {args}")
+
+    def _cmd_npm(self, args: str) -> None:
+        """Run npm command."""
+        if not args.strip():
+            self._cmd_run("npm --version")
+        else:
+            self._cmd_run(f"npm {args}")
+
+    def _cmd_git(self, args: str) -> None:
+        """Run git command."""
+        if not args.strip():
+            self._cmd_run("git --version")
+        else:
+            self._cmd_run(f"git {args}")
+
+    def _cmd_python(self, args: str) -> None:
+        """Run Python code or command."""
+        if not args.strip():
+            self._cmd_run("python --version")
+        elif args.strip().endswith(".py"):
+            self._cmd_run(f"python {args}")
+        else:
+            # Inline python code
+            self._msg("run", f"$ python -c \"{args}\"")
+            result = self._executor.run(f'python -c "{args}"')
+            if result.success:
+                self._msg("output", result.output)
+            else:
+                self._msg("err", result.output)
+
+    def _cmd_paste(self, _args: str = "") -> None:
+        """Paste text from clipboard and send it."""
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["powershell", "-command", "Get-Clipboard"],
+                capture_output=True, text=True, timeout=5
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                text = result.stdout.strip()
+                self._msg("user", text)
+                if self.storage:
+                    self.storage.add_message("user", text)
+                if self.config.active_provider:
+                    self._loading = True
+                    self._begin_stream()
+                    self.run_worker(self._ai_chat(text), exclusive=True)
+                else:
+                    analysis = analyze_input(text)
+                    self._local(analysis)
+            else:
+                self._msg("sys", "Clipboard is empty or not accessible.")
+        except Exception as e:
+            self._msg("err", f"Paste failed: {e}")
+
+    # ── Message pipeline ───────────────────────────────────────────
+
+    def _process(self, text: str) -> None:
+        self._msg("user", text)
+        if self.storage:
+            self.storage.add_message("user", text)
+
+        # Auto-explore the real workspace on the first message (like Claude Code).
+        if not self._scanned:
+            self._ensure_scan(announce=True)
+
+        analysis = analyze_input(text)
+        if analysis.detected_techs:
+            names = sorted({t.name for t in analysis.detected_techs})
+            self._msg("tech", f"Detected: {', '.join(names)}")
+
+        if self.config.active_provider:
+            self._loading = True
+            self._begin_stream()
+            self.run_worker(self._ai_chat(text), exclusive=True)
+        else:
+            self._local(analysis)
+
+    def _finalize_stream(self, text: str) -> None:
+        """Convert the current streaming block into a permanent AI message."""
+        if self._stream_body is not None:
+            self._stream_body.update(escape(smart_display(str(text))))
+            self._stream_body.parent.set_class(True, "msg-ai")
+            self._stream_body = None
+            self._last_update_len = 0
+        else:
+            self._msg("ai", text)
+
+    def _begin_stream(self) -> None:
+        """Mount the AI message block with a thinking placeholder."""
+        area = self.query_one("#chat-area", VerticalScroll)
+        block = Vertical(classes="msg msg-ai")
+        area.mount(block)
+        block.mount(Static("DevObin", classes="role role-ai"))
+        body = Static("[dim italic]thinking…[/]", classes="body")
+        block.mount(body)
+        self._stream_body = body
+        self._last_update_len = 0
+        area.scroll_end(animate=False)
+
+    async def _ai_chat(self, text: str) -> None:
+        from devobin.providers import get_provider
+        from devobin.core.tools import parse_tool_calls, strip_tool_calls, execute_tool_calls
+
+        msgs = self.storage.get_context_messages(max_messages=20) if self.storage else []
+
+        system = SYSTEM_PROMPT
+        mem = self.memory.get_memory_context()
+        if mem:
+            system += f"\n\n## User Preferences\n{mem}"
+
+        # Inject the real project map so DevObin reasons about the actual
+        # codebase in the working directory, not just the user's words.
+        pm = self._ensure_scan()
+        if pm is not None and pm.total_files:
+            system += (
+                "\n\n## Detected Workspace (scanned from the current directory)\n"
+                + pm.to_context(max_chars=8000)
+                + "\n\nTHIS IS THE AUTHORITATIVE SOURCE. Ground every instruction in "
+                "what is ACTUALLY here. Do NOT reference, suggest, or hallucinate "
+                "technologies that do not appear in the scan above. "
+                "If it's a Python project, write Python instructions. "
+                "If it's a Go project, write Go instructions. "
+                "Never default to frontend/React/Bootstrap unless the scan proves it."
+            )
+
+        max_out = int(self.config.get("max_output_tokens", 16000))
+        MAX_AGENT_ROUNDS = 10
+
+        # Permission state for this conversation turn
+        file_permission: str | None = None  # "all", "one", or None (denied)
+
+        resp = ""
+        try:
+            provider = get_provider()
+
+            for agent_round in range(MAX_AGENT_ROUNDS + 1):
+                compressed = compress_context(msgs, max_tokens=6000)
+                resp = ""
+                async for chunk in provider.chat_stream(
+                    messages=compressed, system=system, temperature=0.7, max_tokens=max_out
+                ):
+                    resp += chunk
+                    self._update(resp)
+
+                # Check for tool calls
+                tool_calls = parse_tool_calls(resp)
+                if not tool_calls:
+                    break  # No tool calls — this is the final response
+
+                # ── Permission check before first tool use ──
+                if file_permission is None:
+                    # Check if there are actually files to read
+                    if pm is None or pm.total_files == 0:
+                        self._msg("sys", "No project files found. Skipping file reading.")
+                        break
+
+                    # Show permission modal
+                    from devobin.ui.permission_modal import PermissionModal
+                    file_permission = await self.app.push_screen_wait(
+                        PermissionModal(file_count=pm.total_files)
+                    )
+
+                    if file_permission is None:
+                        # Denied — strip tool calls and continue without reading
+                        clean = strip_tool_calls(resp)
+                        if clean:
+                            self._finalize_stream(clean)
+                        self._msg("sys", "File reading denied. Working from description only.")
+                        # Tell the model to work without files
+                        msgs.append({"role": "assistant", "content": resp})
+                        msgs.append({"role": "user", "content": (
+                            "The user denied file access. Do NOT call any more tools. "
+                            "Write your engineering prompt based only on what the user "
+                            "told you and the workspace scan (file names and structure only)."
+                        )})
+                        self._begin_stream()
+                        continue
+
+                # ── For "ask one by one" permission, check each read ──
+                if file_permission == "one":
+                    allowed_calls = []
+                    for tc in tool_calls:
+                        if tc.tool == "read":
+                            from devobin.ui.ask_modal import AskModal
+                            answer = await self.app.push_screen_wait(
+                                AskModal(f"Allow reading: {tc.arg}?")
+                            )
+                            if answer is not None:  # user said yes (or typed something)
+                                allowed_calls.append(tc)
+                            else:
+                                self._msg("sys", f"Skipped reading: {tc.arg}")
+                        else:
+                            allowed_calls.append(tc)  # glob/grep/ls are always OK
+                    tool_calls = allowed_calls
+                    if not tool_calls:
+                        # All reads were denied, continue without tools
+                        clean = strip_tool_calls(resp)
+                        if clean:
+                            self._finalize_stream(clean)
+                        self._msg("sys", "All file reads skipped.")
+                        break
+
+                # ── Show brief status, not full process ──
+                read_count = sum(1 for tc in tool_calls if tc.tool == "read")
+                write_count = sum(1 for tc in tool_calls if tc.tool == "write")
+                if write_count:
+                    status = f"Creating prompt file... (round {agent_round + 1})"
+                elif read_count:
+                    status = f"Reading files... (round {agent_round + 1})"
+                else:
+                    status = f"Exploring... (round {agent_round + 1})"
+
+                # Finalize the current streaming block with status text
+                self._finalize_stream(status)
+
+                # Execute tools (full results go to model only)
+                results = execute_tool_calls(tool_calls)
+
+                # Show write results to user
+                for tc in tool_calls:
+                    if tc.tool == "write":
+                        self._msg("file", f"Created: {tc.arg}")
+
+                # Feed FULL results back into conversation for the model
+                msgs.append({"role": "assistant", "content": resp})
+                msgs.append({"role": "user", "content": (
+                    f"Tool results from round {agent_round + 1}:\n\n{results}\n\n"
+                    "IMPORTANT: You MUST read ALL important files before producing "
+                    "the final prompt. Do not stop after reading just a few files. "
+                    "Read every significant source file in the project. "
+                    "You may call more tools to continue reading, or if you have "
+                    "read enough, produce your final customized engineering prompt."
+                )})
+
+                # Start a new streaming block for the next round
+                self._begin_stream()
+
+            # Final response handling
+            if not resp.strip():
+                self._update("_(no response)_")
+            else:
+                # Check for <devobin-ask> tags — if the model wants to ask the user
+                # a question, show the modal and feed the answer back.
+                ask_match = self._extract_ask_tag(resp)
+                if ask_match is not None:
+                    resp_clean = self._strip_ask_tag(resp)
+                    self._last_ai_response = resp_clean
+                    if self.storage:
+                        self.storage.add_message("assistant", resp_clean)
+                    self.run_worker(self._handle_ask(ask_match, resp_clean, msgs, system, max_out), exclusive=True)
+                    return
+
+                # ── Grounding check: did the model hallucinate technologies? ──
+                grounding = validate_grounding(resp, pm)
+                if not grounding.is_grounded:
+                    warning_text = "; ".join(grounding.warnings)
+                    self._msg("err", f"[bold red]Grounding warning:[/] {warning_text}", styled=True)
+                    self._msg("sys", "Asking model to rewrite without hallucinated technologies...")
+
+                    msgs.append({"role": "assistant", "content": resp})
+                    msgs.append({"role": "user", "content": (
+                        "IMPORTANT: Your response mentions technologies that do NOT "
+                        f"exist in this project: {', '.join(grounding.hallucinations)}. "
+                        "The scanned workspace has NONE of these. "
+                        "Rewrite your response using ONLY technologies actually found "
+                        "in the project. Do NOT suggest adding new databases, frameworks, "
+                        "or tools unless the user explicitly asked for them. "
+                        "Reference ONLY files and patterns that exist in the codebase."
+                    )})
+                    self._begin_stream()
+                    compressed = compress_context(msgs, max_tokens=6000)
+                    resp = ""
+                    async for chunk in provider.chat_stream(
+                        messages=compressed, system=system, temperature=0.7, max_tokens=max_out
+                    ):
+                        resp += chunk
+                        self._update(resp)
+
+                self._last_ai_response = resp
+                if self.storage:
+                    self.storage.add_message("assistant", resp)
+
+            if resp.strip():
+                self._extract(text)
+        except Exception as e:
+            self._update(f"Error: {escape(str(e))}")
+            if self._stream_body is not None:
+                self._stream_body.parent.set_class(True, "msg-err")
+        finally:
+            self._loading = False
+            self._stream_body = None
+
+    def _local(self, analysis) -> None:
+        if analysis.detected_techs:
+            research = research_analysis(analysis)
+            parts = ["Based on your input:\n"]
+            for name, topic in research.items():
+                if topic.best_practices:
+                    parts.append(f"  {escape(name)}:")
+                    for bp in topic.best_practices[:3]:
+                        parts.append(f"    · {escape(bp)}")
+                    parts.append("")
+            parts.append("\nConnect a provider with /connect to enable AI.")
+            self._msg("ai", "\n".join(parts))
+        else:
+            self._msg(
+                "ai",
+                "Tell me about your project:\n\n"
+                "  · What do you want to build?\n"
+                "  · Which technologies?\n\n"
+                "Use /connect to set up an AI provider.",
+            )
+
+    def _extract_ask_tag(self, text: str) -> str | None:
+        """Extract the question from <devobin-ask>...</devobin-ask> if present."""
+        import re
+        m = re.search(r"<devobin-ask>(.*?)</devobin-ask>", text, re.DOTALL)
+        return m.group(1).strip() if m else None
+
+    def _strip_ask_tag(self, text: str) -> str:
+        """Remove <devobin-ask>...</devobin-ask> from the response."""
+        import re
+        cleaned = re.sub(r"\s*<devobin-ask>.*?</devobin-ask>\s*", "", text, flags=re.DOTALL)
+        return cleaned.strip()
+
+    async def _handle_ask(self, question: str, prior_resp: str, msgs: list, system: str, max_out: int) -> None:
+        """Show the AskModal, get the user's answer, and continue the conversation."""
+        from devobin.ui.ask_modal import AskModal
+
+        answer = await self.app.push_screen_wait(AskModal(question))
+        if answer is None:
+            self._msg("sys", "Skipped.")
+            self._loading = False
+            self._stream_body = None
+            return
+
+        # Feed the answer back as a new user message and continue streaming.
+        self._msg("user", answer)
+        if self.storage:
+            self.storage.add_message("user", answer)
+
+        msgs.append({"role": "assistant", "content": prior_resp})
+        msgs.append({"role": "user", "content": answer})
+
+        self._begin_stream()
+        resp = ""
+        try:
+            provider = get_provider()
+            async for chunk in provider.chat_stream(
+                messages=msgs, system=system, temperature=0.7, max_tokens=max_out
+            ):
+                resp += chunk
+                self._update(resp)
+
+            if resp.strip():
+                # Check for another ask tag (multi-turn clarification)
+                ask2 = self._extract_ask_tag(resp)
+                if ask2 is not None:
+                    resp_clean = self._strip_ask_tag(resp)
+                    self._last_ai_response = resp_clean
+                    if self.storage:
+                        self.storage.add_message("assistant", resp_clean)
+                    self.run_worker(self._handle_ask(ask2, resp_clean, msgs, system, max_out), exclusive=True)
+                    return
+
+                self._last_ai_response = resp
+                if self.storage:
+                    self.storage.add_message("assistant", resp)
+            else:
+                self._update("_(no response)_")
+        except Exception as e:
+            self._update(f"Error: {escape(str(e))}")
+            if self._stream_body is not None:
+                self._stream_body.parent.set_class(True, "msg-err")
+        finally:
+            self._loading = False
+            self._stream_body = None
+
+    def _extract(self, user_input: str) -> None:
+        lower = user_input.lower()
+        for p in ("i prefer", "i always use", "let's use", "i use"):
+            if p in lower:
+                self.memory.remember(user_input, scope="global", category="preference")
+                break
+
+        for tech in analyze_input(user_input).detected_techs:
+            self.memory.remember(f"Technology: {tech.name}", scope="project", category="technology")
+
+    # ── UI helpers ─────────────────────────────────────────────────
+
+    def _msg(self, role: str, text: str, styled: bool = False) -> None:
+        """Mount a message block. All text is RTL-reshaped.
+
+        If styled=True, Rich markup is preserved (for [bold], [dim], etc.).
+        If styled=False (default), all text is escaped for safety.
+        """
+        area = self.query_one("#chat-area", VerticalScroll)
+        labels = {
+            "user": "You", "ai": "DevObin", "sys": "System", "err": "Error",
+            "tech": "Detected", "run": "Shell", "output": "Output",
+            "file": "File",
+        }
+
+        block = Vertical(classes=f"msg msg-{role}")
+        area.mount(block)
+
+        if role in ("user", "ai"):
+            block.mount(Static(labels.get(role, role), classes=f"role role-{role}"))
+
+        if styled:
+            safe_text = smart_display(str(text))
+        else:
+            safe_text = escape(smart_display(str(text)))
+        body = Static(safe_text, classes=f"body body-{role}")
+        body.expand = True
+        block.mount(body)
+
+        area.scroll_end(animate=False)
+
+    def _update(self, text: str) -> None:
+        """Update the currently streaming AI body.
+
+        Throttles updates: only re-renders when the text has grown by at
+        least 8 characters or when called for the first time.  This keeps
+        the UI responsive even when tokens arrive faster than the renderer
+        can keep up.
+        """
+        if self._stream_body is None:
+            return
+        # Skip tiny incremental updates to avoid renderer overload
+        if len(text) - self._last_update_len < 8:
+            return
+        self._last_update_len = len(text)
+        self._stream_body.update(escape(smart_display(str(text))))
+        try:
+            self.query_one("#chat-area", VerticalScroll).scroll_end(animate=False)
+        except Exception:
+            pass