devobin 1.0.0__py3-none-any.whl

devobin/cli/chat.py

@@ -0,0 +1,831 @@
+"""Interactive chat system for DevObin AI."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.history import InMemoryHistory
+
+from devobin.cli.slash_menu import SlashMenu
+from devobin.cli.terminal import (
+    console,
+    render_banner,
+    render_status_bar,
+    render_divider,
+    render_action_menu,
+)
+from devobin.cli.ui import (
+    print_detected,
+    print_error,
+    print_success,
+    print_warning,
+    print_status,
+)
+from devobin.config.settings import get_config
+from devobin.core.analyzer import analyze_input
+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.rtl import smart_display
+from devobin.storage.database import ProjectStorage
+
+SYSTEM_PROMPT = """You are DevObin — an AI Prompt Engineering System.
+
+Your ROLE has changed. You are a PROMPT ARCHITECT, not a CODER.
+You create instructions FOR other AI agents to implement. You do NOT write the implementation yourself.
+
+## STRICT RULES
+
+1. NEVER generate complete source code
+2. NEVER generate complete files
+3. NEVER generate full applications
+4. NEVER provide production-ready implementations
+5. NEVER output code blocks (```html, ```css, ```js, ```python, etc.)
+
+## ALLOWED
+
+- Architecture explanations
+- Technical requirements
+- Engineering instructions
+- Design patterns
+- Short educational snippets (max 3 lines)
+- Pseudocode
+- Feature descriptions
+- Responsive design specs
+- UI/UX requirements
+- Performance rules
+- Security rules
+
+## FORBIDDEN
+
+- Full HTML files
+- Full CSS files
+- Full JavaScript files
+- Full Python files
+- Complete React/Vue/Angular components
+- Complete projects
+- Multi-file implementations
+- Any code that could be directly executed
+
+## IF USER REQUESTS CODE
+
+Do NOT comply.
+
+Instead respond:
+"I am DevObin — a prompt engineering tool. I create engineering instructions for AI coding agents. I do NOT write code.
+
+Use /export to generate your engineering document, then give it to Codex/Claude/Cursor to implement."
+
+## OUTPUT FORMAT
+
+Your output must be structured text with these sections:
+- Role (who the coding agent should be)
+- Project Goal
+- Technical Constraints
+- Required Sections
+- Implementation Details
+- Responsive Design
+- UI/UX Quality
+- Performance Rules
+
+Your output is optimized as a PROMPT for coding agents, NOT as code itself.
+
+## AVAILABLE COMMANDS
+
+User commands: /run, /read, /write, /ls, /export, /connect, /model, /project, /memory"""
+
+
+class DevObinCompleter(Completer):
+    """Autocomplete for slash commands."""
+
+    COMMANDS = [
+        "/connect", "/model", "/models", "/project", "/memory",
+        "/history", "/export", "/research", "/settings", "/clear",
+        "/help", "/exit", "/quit",
+        "/run", "/exec", "/read", "/cat", "/write", "/create",
+        "/ls", "/dir", "/tree", "/cwd", "/cd", "/rm", "/delete",
+        "/touch", "/mkdir", "/env", "/pip", "/npm", "/git", "/python",
+    ]
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if text.startswith("/"):
+            word = text.lower()
+            for cmd in self.COMMANDS:
+                if cmd.startswith(word):
+                    yield Completion(cmd, start_position=-len(text))
+
+
+class ChatSession:
+    """Manages an interactive chat session with the AI."""
+
+    def __init__(self) -> None:
+        self.config = get_config()
+        self.project = self.config.get("active_project")
+        self.memory = MemoryManager(self.project)
+        self.storage = ProjectStorage(self.project) if self.project else None
+        self.running = False
+        self.slash_menu = SlashMenu()
+        self._last_ai_response: str = ""
+        self._register_commands()
+        self._session = PromptSession(
+            completer=DevObinCompleter(),
+            history=InMemoryHistory(),
+        )
+
+    def _register_commands(self) -> None:
+        """Register all slash commands."""
+        self.slash_menu.register("/help", "Show commands", self._cmd_help)
+        self.slash_menu.register("/connect", "Connect AI provider", self._cmd_connect)
+        self.slash_menu.register("/models", "List models", self._cmd_models)
+        self.slash_menu.register("/model", "Change model", self._cmd_model, requires_args=True)
+        self.slash_menu.register("/project", "Manage projects", self._cmd_project)
+        self.slash_menu.register("/memory", "View memory", self._cmd_memory)
+        self.slash_menu.register("/export", "Generate prompt file", self._cmd_export)
+        self.slash_menu.register("/settings", "Settings", self._cmd_settings)
+        self.slash_menu.register("/clear", "Clear chat", self._cmd_clear)
+        self.slash_menu.register("/exit", "Exit DevObin", self._cmd_exit)
+        self.slash_menu.register("/quit", "Exit DevObin", self._cmd_exit)
+        # Shell & file commands
+        self.slash_menu.register("/run", "Run shell command", self._cmd_run)
+        self.slash_menu.register("/exec", "Run shell command", self._cmd_run)
+        self.slash_menu.register("/read", "Read file", self._cmd_read)
+        self.slash_menu.register("/cat", "Read file", self._cmd_read)
+        self.slash_menu.register("/write", "Write/create file", self._cmd_write)
+        self.slash_menu.register("/create", "Write/create file", self._cmd_write)
+        self.slash_menu.register("/ls", "List directory", self._cmd_ls)
+        self.slash_menu.register("/dir", "List directory", self._cmd_ls)
+        self.slash_menu.register("/tree", "Show file tree", self._cmd_tree)
+        self.slash_menu.register("/cwd", "Show current directory", self._cmd_cwd)
+        self.slash_menu.register("/cd", "Change directory", self._cmd_cd)
+        self.slash_menu.register("/rm", "Delete file", self._cmd_rm)
+        self.slash_menu.register("/delete", "Delete file", self._cmd_rm)
+        self.slash_menu.register("/touch", "Create empty file", self._cmd_touch)
+        self.slash_menu.register("/mkdir", "Create directory", self._cmd_mkdir)
+        self.slash_menu.register("/env", "Show environment", self._cmd_env)
+        self.slash_menu.register("/pip", "Pip commands", self._cmd_pip)
+        self.slash_menu.register("/npm", "Npm commands", self._cmd_npm)
+        self.slash_menu.register("/git", "Git commands", self._cmd_git)
+        self.slash_menu.register("/python", "Run Python", self._cmd_python)
+
+    def start(self) -> None:
+        """Start the interactive chat loop."""
+        render_banner()
+        render_status_bar()
+        render_divider()
+        console.print()
+
+        if not self.config.active_provider:
+            console.print("  [bold cyan]Welcome to DevObin AI![/]")
+            console.print("  [dim]Type /connect to set up your AI model.[/]")
+            console.print("  [dim]Type / to see all commands.[/]")
+            console.print()
+        else:
+            console.print("  [bold cyan]Ready![/]")
+            console.print("  [dim]Type your project idea or / for commands.[/]")
+            console.print()
+
+        self.running = True
+
+        while self.running:
+            try:
+                user_input = self._get_input()
+                if user_input is None:
+                    continue
+
+                user_input = user_input.strip()
+                if not user_input:
+                    continue
+
+                if user_input.startswith("/"):
+                    self._execute_command(user_input)
+                    self._refresh_state()
+                    continue
+
+                self._process_message(user_input)
+
+            except KeyboardInterrupt:
+                console.print()
+                print_status("Use [bold]/exit[/] to quit.")
+            except EOFError:
+                self.running = False
+
+    def _get_input(self) -> str | None:
+        """Get user input using prompt-toolkit."""
+        try:
+            return self._session.prompt("\n  You › ")
+        except (KeyboardInterrupt, EOFError):
+            return None
+
+    def _execute_command(self, input_text: str) -> None:
+        """Execute a slash command synchronously."""
+        parts = input_text.strip().split(maxsplit=1)
+        cmd = parts[0].lower() if parts else ""
+        args = parts[1] if len(parts) > 1 else ""
+
+        command = self.slash_menu.get_command(cmd)
+        if command:
+            if asyncio.iscoroutinefunction(command.handler):
+                asyncio.run(command.handler(args))
+            else:
+                command.handler(args)
+        elif cmd == "/":
+            self.slash_menu.show_menu()
+        else:
+            print_error(f"Unknown command: {cmd}")
+
+    def _refresh_state(self) -> None:
+        """Refresh project and memory references after commands."""
+        self.project = self.config.get("active_project")
+        self.memory = MemoryManager(self.project)
+        self.storage = ProjectStorage(self.project) if self.project else None
+
+    def _process_message(self, user_input: str) -> None:
+        """Process a user message through the AI pipeline."""
+        if self.storage:
+            self.storage.add_message("user", user_input)
+
+        analysis = analyze_input(user_input)
+
+        if analysis.detected_techs:
+            tech_names = list(set(t.name for t in analysis.detected_techs))
+            print_detected(tech_names, "Detected")
+            console.print()
+
+        if self.config.active_provider:
+            self._chat_with_ai(user_input, analysis)
+        else:
+            self._local_analysis(user_input, analysis)
+
+    def _chat_with_ai(self, user_input: str, analysis) -> None:
+        """Chat with the configured AI provider."""
+        from devobin.providers import get_provider
+
+        try:
+            provider = get_provider()
+        except ValueError as e:
+            print_error(str(e))
+            return
+
+        messages = []
+        if self.storage:
+            messages = self.storage.get_context_messages(max_messages=20)
+
+        memory_ctx = self.memory.get_memory_context()
+        system = SYSTEM_PROMPT
+        if memory_ctx:
+            system += f"\n\n## User Preferences & Context\n{memory_ctx}"
+
+        messages = compress_context(messages, max_tokens=6000)
+
+        console.print("  [bold green]DevObin[/] ", end="")
+
+        async def _stream():
+            full_response = ""
+            async for chunk in provider.chat_stream(
+                messages=messages,
+                system=system,
+                temperature=0.7,
+                max_tokens=8192,
+            ):
+                full_response += chunk
+                # Show raw during streaming
+                print(chunk, end="", flush=True)
+            # After streaming, reshape RTL text
+            reshaped = smart_display(full_response)
+            if reshaped != full_response:
+                # Clear and reprint reshaped version
+                print()
+                print(f"  {reshaped}")
+            return full_response
+
+        try:
+            full_response = asyncio.run(_stream())
+            console.print()
+            console.print()
+
+            self._last_ai_response = full_response
+
+            if self.storage:
+                self.storage.add_message("assistant", full_response)
+
+            self._extract_memories(user_input, full_response)
+
+            render_action_menu([
+                ("Export Prompt", "Generate project_prompt.md"),
+                ("Continue", "Keep refining context"),
+                ("Add Rules", "Add architecture/security rules"),
+            ])
+            console.print()
+
+        except Exception as e:
+            console.print()
+            print_error(f"AI request failed: {e}")
+
+    def _local_analysis(self, user_input: str, analysis) -> None:
+        """Perform local analysis without an AI provider."""
+        console.print()
+
+        if analysis.detected_techs:
+            from devobin.core.researcher import research_analysis
+            research = research_analysis(analysis)
+
+            for name, topic in research.items():
+                if topic.best_practices:
+                    console.print(f"  [bold cyan]{name}[/] best practices:")
+                    for bp in topic.best_practices[:3]:
+                        console.print(f"    • {bp}")
+                    console.print()
+
+            if analysis.requirements:
+                console.print("  [bold]Key Requirements:[/]")
+                for req in analysis.requirements:
+                    console.print(f"    → {req}")
+                console.print()
+
+            print_status("Connect an AI model with [bold]/connect[/] for full interactive experience.")
+            print_status("Use [bold]/export[/] to generate the project_prompt.md file.")
+        else:
+            print_status("I can help you define your project. Try describing:")
+            console.print("    • What you want to build")
+            console.print("    • Technologies you want to use")
+            console.print("    • Scale requirements")
+            console.print()
+            print_status("Example: [bold]I want to create a Django ecommerce platform with React[/]")
+
+        console.print()
+
+    def _extract_memories(self, user_input: str, response: str) -> None:
+        """Extract and save memories from conversation."""
+        preference_patterns = [
+            "i prefer", "i always use", "i like to use", "my preferred",
+            "i want to use", "let's use", "we should use", "i use",
+        ]
+
+        lower_input = user_input.lower()
+        for pattern in preference_patterns:
+            if pattern in lower_input:
+                self.memory.remember(user_input, scope="global", category="preference")
+                break
+
+        analysis = analyze_input(user_input)
+        if analysis.detected_techs:
+            for tech in analysis.detected_techs:
+                if any(kw in lower_input for kw in ["use", "with", "using", "built with", "stack"]):
+                    self.memory.remember(
+                        f"Technology choice: {tech.name} ({tech.category})",
+                        scope="project",
+                        category="technology",
+                    )
+
+    # ── Slash Command Handlers ────────────────────────────────────
+
+    def _cmd_help(self, args: str) -> None:
+        from devobin.cli.ui import print_help
+        print_help()
+
+    def _cmd_connect(self, args: str) -> None:
+        """Interactive provider connection wizard."""
+        from rich.prompt import Prompt
+
+        config = get_config()
+
+        console.print()
+        console.print("  [bold cyan]Connect AI Provider[/]")
+        console.print()
+
+        provider_types = ["openai", "anthropic", "google", "ollama", "openai-compatible"]
+        console.print("  Provider types:")
+        for i, pt in enumerate(provider_types, 1):
+            console.print(f"    {i}. {pt}")
+        console.print()
+
+        choice = Prompt.ask("  Select", choices=[str(i) for i in range(1, 6)], default="1")
+        provider_type = provider_types[int(choice) - 1]
+
+        console.print()
+        name = Prompt.ask("  Name", default=provider_type)
+        api_key = Prompt.ask("  API key", password=True, default="")
+
+        base_url = ""
+        if provider_type == "openai-compatible":
+            base_url = Prompt.ask("  Base URL", default="https://api.openai.com/v1")
+        elif provider_type == "ollama":
+            base_url = Prompt.ask("  Ollama URL", default="http://localhost:11434")
+
+        temp_config = {
+            "api_key": api_key,
+            "base_url": base_url or None,
+            "model": "",
+            "type": provider_type,
+        }
+
+        model = ""
+        try:
+            if provider_type in ("openai", "openai-compatible"):
+                from devobin.providers.openai_provider import OpenAIProvider
+                temp_config["model"] = "gpt-4o"
+                p = OpenAIProvider(temp_config)
+                models = p.available_models()
+            elif provider_type == "anthropic":
+                from devobin.providers.anthropic_provider import AnthropicProvider
+                temp_config["model"] = "claude-sonnet-4-20250514"
+                p = AnthropicProvider(temp_config)
+                models = p.available_models()
+            elif provider_type == "google":
+                from devobin.providers.google_provider import GoogleProvider
+                temp_config["model"] = "gemini-2.0-flash"
+                p = GoogleProvider(temp_config)
+                models = p.available_models()
+            elif provider_type == "ollama":
+                from devobin.providers.ollama_provider import OllamaProvider
+                temp_config["model"] = "llama3"
+                p = OllamaProvider(temp_config)
+                models = p.available_models()
+            else:
+                models = []
+        except Exception:
+            models = []
+
+        if models:
+            console.print()
+            console.print("  Available models:")
+            for i, m in enumerate(models, 1):
+                console.print(f"    {i}. {m}")
+            console.print()
+            model_choice = Prompt.ask("  Select model (number or name)", default="1")
+            try:
+                idx = int(model_choice) - 1
+                model = models[idx] if 0 <= idx < len(models) else model_choice
+            except ValueError:
+                model = model_choice
+        else:
+            model = Prompt.ask("  Model name", default="gpt-4o")
+
+        provider_config = {
+            "type": provider_type,
+            "api_key": api_key,
+            "base_url": base_url or None,
+            "model": model,
+        }
+
+        config.add_provider(name, provider_config)
+        config.active_provider = name
+        config.active_model = model
+
+        console.print()
+        print_success(f"Connected to {name} ({provider_type}) — model: {model}")
+        console.print()
+
+    def _cmd_models(self, args: str) -> None:
+        from devobin.cli.ui import print_provider_table
+        config = get_config()
+        providers = config.list_providers()
+        if not providers:
+            print_warning("No providers configured. Use /connect to set one up.")
+            return
+        print_provider_table(providers)
+
+    def _cmd_model(self, args: str) -> None:
+        config = get_config()
+        if not args:
+            current = config.active_model or "None"
+            print_status(f"Current model: [bold]{current}[/]")
+            return
+        config.active_model = args.strip()
+        print_success(f"Switched to model: {args.strip()}")
+
+    def _cmd_project(self, args: str) -> None:
+        config = get_config()
+        parts = args.strip().split(maxsplit=1)
+        sub = parts[0].lower() if parts else ""
+        proj_name = parts[1].strip() if len(parts) > 1 else ""
+
+        if sub == "create":
+            if not proj_name:
+                print_error("Usage: /project create <name>")
+                return
+            ProjectStorage(proj_name)
+            config.set("active_project", proj_name)
+            print_success(f"Created project: {proj_name}")
+
+        elif sub == "switch":
+            if not proj_name:
+                print_error("Usage: /project switch <name>")
+                return
+            projects = [p.name for p in config.projects_dir().iterdir() if p.is_dir()]
+            if proj_name not in projects:
+                print_error(f"Project '{proj_name}' not found.")
+                return
+            config.set("active_project", proj_name)
+            print_success(f"Switched to project: {proj_name}")
+
+        elif sub == "list":
+            projects = [p.name for p in config.projects_dir().iterdir() if p.is_dir()]
+            if not projects:
+                print_status("No projects yet. Use /project create <name> to start.")
+            else:
+                console.print()
+                console.print("  [bold cyan]Projects:[/]")
+                active = config.get("active_project")
+                for p in sorted(projects):
+                    marker = " [green]← active[/]" if p == active else ""
+                    console.print(f"    • {p}{marker}")
+                console.print()
+        else:
+            console.print("  [bold]Project Commands:[/]")
+            console.print("    /project create <name>")
+            console.print("    /project switch <name>")
+            console.print("    /project list")
+
+    def _cmd_memory(self, args: str) -> None:
+        global_mems = self.memory.get_global_memories()
+        project_mems = self.memory.get_project_memories()
+
+        if not global_mems and not project_mems:
+            print_status("No memories saved yet.")
+            return
+
+        if global_mems:
+            console.print()
+            console.print("  [bold cyan]Global Memories:[/]")
+            for m in global_mems[-15:]:
+                cat = m.get("category", "general")
+                console.print(f"    [dim][{cat}][/dim] {m['content'][:100]}")
+
+        if project_mems:
+            console.print()
+            console.print("  [bold cyan]Project Memories:[/]")
+            for m in project_mems[-15:]:
+                cat = m.get("category", "general")
+                console.print(f"    [dim][{cat}][/dim] {m['content'][:100]}")
+
+        console.print()
+
+    def _cmd_export(self, args: str) -> None:
+        """Generate the project prompt file. Supports /export [filename]."""
+        from devobin.cli.ui import render_markdown
+
+        config = get_config()
+        project = config.get("active_project")
+        custom_name = args.strip() if args.strip() else None
+
+        # Use the actual AI response if available
+        if self._last_ai_response and self._last_ai_response.strip():
+            prompt_content = self._last_ai_response.strip()
+            name = custom_name or project or "project"
+            slug = name.lower().strip()
+            slug = slug.replace(" ", "_").replace("-", "_")
+            slug = "".join(c for c in slug if c.isalnum() or c == "_")
+            filename = f"{slug}_prompt.md"
+        else:
+            # Fallback to prompt_builder template
+            if not project:
+                print_warning("No active project. Use /project create <name> first.")
+                return
+
+            storage = ProjectStorage(project)
+            history = storage.get_history()
+
+            if not history:
+                print_warning("No conversation history to export.")
+                return
+
+            from devobin.core.researcher import research_analysis
+            from devobin.core.prompt_builder import build_prompt
+
+            user_msgs = " ".join(m["content"] for m in history if m["role"] == "user")
+            analysis = analyze_input(user_msgs)
+            research = research_analysis(analysis)
+
+            memory_ctx = self.memory.get_memory_context()
+            filename, prompt_content = build_prompt(
+                analysis, research,
+                memory_context=memory_ctx,
+                project_name=custom_name or project,
+            )
+
+        # Save to current working directory (where CLI was opened)
+        cwd = os.getcwd()
+        output_path = os.path.join(cwd, filename)
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(prompt_content)
+
+        print_success(f"Created: {output_path}")
+        console.print()
+        render_markdown(prompt_content[:2000])
+        if len(prompt_content) > 2000:
+            console.print("\n  [dim]... (truncated preview)[/]")
+        console.print()
+
+    def _cmd_settings(self, args: str) -> None:
+        from devobin.config.settings import CONFIG_DIR
+        config = get_config()
+
+        console.print()
+        console.print("  [bold cyan]Settings:[/]")
+        console.print(f"    Provider: [bold]{config.active_provider or 'None'}[/]")
+        console.print(f"    Model:    [bold]{config.active_model or 'None'}[/]")
+        console.print(f"    Project:  [bold]{config.get('active_project') or 'None'}[/]")
+        console.print(f"    Config:   [dim]{CONFIG_DIR}[/]")
+        console.print()
+
+    def _cmd_clear(self, args: str) -> None:
+        if self.storage:
+            self.storage.clear_history()
+            print_success("Conversation cleared.")
+        else:
+            print_warning("No active project to clear.")
+
+    def _cmd_exit(self, args: str) -> None:
+        console.print()
+        print_success("Goodbye!")
+        console.print()
+        self.running = False
+
+    # ── Shell & File Commands ──────────────────────────────────────
+
+    def _cmd_run(self, args: str) -> None:
+        """Execute a shell command."""
+        if not args.strip():
+            print_error("Usage: /run <command>")
+            return
+        executor = get_executor()
+        console.print(f"  [dim]$ {escape(args)}[/]")
+        result = executor.run(args)
+        if result.stdout.strip():
+            console.print(f"  {result.stdout.strip()}")
+        if result.stderr.strip():
+            console.print(f"  [red]{result.stderr.strip()}[/]")
+        if result.timed_out:
+            console.print("  [red]Command timed out after 30s[/]")
+        if self.storage:
+            self.storage.add_message("user", f"/run {args}")
+            self.storage.add_message("assistant", f"[command output]\n{result.output}")
+        console.print()
+
+    def _cmd_read(self, args: str) -> None:
+        """Read a file."""
+        if not args.strip():
+            print_error("Usage: /read <file_path>")
+            return
+        files = get_file_manager()
+        result = files.read(args.strip())
+        if result.success:
+            console.print(f"  [dim]{result.path}[/] ({result.size} bytes)")
+            console.print()
+            for line in result.content.split("\n")[:50]:
+                console.print(f"  {line}")
+            if result.content.count("\n") > 50:
+                console.print(f"\n  [dim]... ({result.content.count(chr(10)) - 50} more lines)[/]")
+        else:
+            print_error(result.error)
+        if self.storage and result.success:
+            self.storage.add_message("user", f"/read {args}")
+        console.print()
+
+    def _cmd_write(self, args: str) -> None:
+        """Write content to a file."""
+        if not args.strip():
+            print_error("Usage: /write <file_path> <content>")
+            return
+        parts = args.strip().split("\n", 1)
+        filepath = parts[0].strip()
+        content = parts[1] if len(parts) > 1 else ""
+        if not content:
+            print_error(f"Provide content after the filename.\nUsage: /write {filepath}\n<your content here>")
+            return
+        files = get_file_manager()
+        result = files.write(filepath, content)
+        if result.success:
+            print_success(f"Written {result.size} bytes to {result.path}")
+        else:
+            print_error(result.error)
+        console.print()
+
+    def _cmd_ls(self, args: str) -> None:
+        """List directory contents."""
+        files = get_file_manager()
+        result = files.list_dir(args.strip() or ".")
+        if result.success:
+            console.print(f"  [bold]{result.path}[/] ({len(result.files)} items)")
+            for f in result.files:
+                icon = "[blue]📁[/]" if f.endswith("/") else "📄"
+                console.print(f"    {icon} {f}")
+        else:
+            print_error(result.error)
+        console.print()
+
+    def _cmd_tree(self, args: str) -> None:
+        """Show project file tree."""
+        executor = get_executor()
+        path = args.strip() or "."
+        result = executor.run(
+            f'find "{path}" -not -path "*/.git/*" -not -path "*/__pycache__/*" '
+            f'-not -path "*/node_modules/*" -not -path "*/.venv/*" | head -50'
+        )
+        if result.stdout.strip():
+            console.print(f"  [bold]{path}[/]")
+            for line in result.stdout.strip().split("\n"):
+                console.print(f"    {line}")
+        else:
+            self._cmd_ls(args)
+        console.print()
+
+    def _cmd_cwd(self, _args: str = "") -> None:
+        """Show current working directory."""
+        import os
+        console.print(f"  [bold]cwd:[/] {os.getcwd()}")
+        console.print()
+
+    def _cmd_cd(self, args: str) -> None:
+        """Change working directory."""
+        import os
+        if not args.strip():
+            print_error("Usage: /cd <path>")
+            return
+        try:
+            os.chdir(args.strip())
+            print_success(f"cwd: {os.getcwd()}")
+        except Exception as e:
+            print_error(f"cd failed: {e}")
+        console.print()
+
+    def _cmd_rm(self, args: str) -> None:
+        """Delete a file."""
+        if not args.strip():
+            print_error("Usage: /rm <file_or_dir>")
+            return
+        files = get_file_manager()
+        result = files.delete(args.strip())
+        if result.success:
+            print_success(f"Deleted: {result.path}")
+        else:
+            print_error(result.error)
+        console.print()
+
+    def _cmd_touch(self, args: str) -> None:
+        """Create an empty file."""
+        if not args.strip():
+            print_error("Usage: /touch <file_path>")
+            return
+        files = get_file_manager()
+        result = files.write(args.strip(), "")
+        if result.success:
+            print_success(f"Created: {args.strip()}")
+        else:
+            print_error(result.error)
+        console.print()
+
+    def _cmd_mkdir(self, args: str) -> None:
+        """Create a directory."""
+        import os
+        if not args.strip():
+            print_error("Usage: /mkdir <directory>")
+            return
+        try:
+            os.makedirs(args.strip(), exist_ok=True)
+            print_success(f"Created directory: {args.strip()}")
+        except Exception as e:
+            print_error(f"mkdir failed: {e}")
+        console.print()
+
+    def _cmd_env(self, args: str) -> None:
+        """Show environment variables."""
+        import os
+        if args.strip():
+            val = os.environ.get(args.strip().upper(), "not set")
+            console.print(f"  {args.strip().upper()}={val}")
+        else:
+            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)}
+            for k, v in sorted(env_vars.items()):
+                console.print(f"  [bold]{k}[/]={v}")
+        console.print()
+
+    def _cmd_pip(self, args: str) -> None:
+        """Run pip command."""
+        self._cmd_run(f"pip {args}" if args.strip() else "pip --version")
+
+    def _cmd_npm(self, args: str) -> None:
+        """Run npm command."""
+        self._cmd_run(f"npm {args}" if args.strip() else "npm --version")
+
+    def _cmd_git(self, args: str) -> None:
+        """Run git command."""
+        self._cmd_run(f"git {args}" if args.strip() else "git --version")
+
+    def _cmd_python(self, args: str) -> None:
+        """Run Python code."""
+        if not args.strip():
+            self._cmd_run("python --version")
+        elif args.strip().endswith(".py"):
+            self._cmd_run(f"python {args}")
+        else:
+            import shlex
+            self._cmd_run(f'python -c {shlex.quote(args)}')