devobin 1.0.0__py3-none-any.whl

devobin/ui/command_palette.py

@@ -0,0 +1,131 @@
+"""Command palette modal for DevObin AI."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, OptionList
+from textual.containers import Vertical
+from textual.binding import Binding
+from textual import on
+
+
+class CommandPalette(ModalScreen[None]):
+    """Command palette modal with keyboard navigation."""
+
+    CSS = """
+    CommandPalette {
+        align: center middle;
+    }
+    #palette-container {
+        width: 50;
+        max-height: 30;
+        background: $surface;
+        border: tall $primary;
+        padding: 1 2;
+    }
+    #palette-title {
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+    #command-list {
+        height: auto;
+        max-height: 20;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+    ]
+
+    COMMANDS = [
+        ("connect", "Connect AI Provider", "🔌"),
+        ("model", "Select Model", "🤖"),
+        ("project", "Manage Projects", "📂"),
+        ("memory", "View Memory", "🧠"),
+        ("history", "Chat History", "📜"),
+        ("export", "Export Prompt", "📤"),
+        ("scan", "Scan Workspace", "🔍"),
+        ("settings", "Settings", "⚙"),
+        ("run", "Run Shell Command", "▶"),
+        ("read", "Read File", "📄"),
+        ("write", "Write / Create File", "✏"),
+        ("ls", "List Directory", "📁"),
+        ("tree", "Show File Tree", "🌲"),
+        ("git", "Git Commands", "🔀"),
+        ("pip", "Pip Commands", "📦"),
+        ("python", "Run Python", "🐍"),
+        ("clear", "Clear Chat", "🗑"),
+        ("exit", "Exit DevObin", "🚪"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="palette-container"):
+            yield Static("DevObin Commands", id="palette-title")
+            labels = [f"{icon}  {label}" for _, label, icon in self.COMMANDS]
+            yield OptionList(*labels, id="command-list")
+
+    def on_mount(self) -> None:
+        self.query_one("#command-list", OptionList).focus()
+
+    @on(OptionList.OptionSelected, "#command-list")
+    def on_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle command selection."""
+        idx = event.option_index
+        if 0 <= idx < len(self.COMMANDS):
+            cmd = self.COMMANDS[idx][0]
+            self.dismiss()
+            self.execute_command(cmd)
+
+    def execute_command(self, cmd: str) -> None:
+        """Execute the selected command."""
+        from devobin.ui.connect_modal import ConnectModal
+        from devobin.ui.model_modal import ModelModal
+        from devobin.ui.project_modal import ProjectModal
+        from devobin.ui.memory_modal import MemoryModal
+        from devobin.ui.history_modal import HistoryModal
+        from devobin.ui.export_modal import ExportModal
+        from devobin.ui.settings_modal import SettingsModal
+
+        modals = {
+            "connect": ConnectModal,
+            "model": ModelModal,
+            "project": ProjectModal,
+            "memory": MemoryModal,
+            "history": HistoryModal,
+            "export": ExportModal,
+            "settings": SettingsModal,
+        }
+
+        # Commands that go to the chat input
+        input_cmds = {
+            "run": "/run ", "read": "/read ", "write": "/write ",
+            "ls": "/ls ", "tree": "/tree ", "git": "/git ",
+            "pip": "/pip ", "python": "/python ", "npm": "/npm ",
+            "scan": "/scan",
+        }
+
+        if cmd == "clear":
+            screen = self.app.screen
+            if hasattr(screen, "cmd_clear"):
+                screen.cmd_clear("")
+        elif cmd == "exit":
+            self.app.exit()
+        elif cmd in modals:
+            self.app.push_screen(modals[cmd]())
+        elif cmd in input_cmds:
+            # Focus the chat input and pre-fill the command
+            try:
+                chat_screen = self.app.screen
+                if hasattr(chat_screen, "query_one"):
+                    inp = chat_screen.query_one("#chat-input")
+                    inp.value = input_cmds[cmd]
+                    inp.focus()
+            except Exception:
+                pass
+
+    def action_close(self) -> None:
+        """Close the palette."""
+        self.dismiss()

devobin/ui/connect_modal.py

@@ -0,0 +1,166 @@
+"""Connect modal for DevObin AI."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, Input, Select, Button
+from textual.containers import Vertical
+from textual.binding import Binding
+from textual import on
+
+from devobin.config.settings import get_config
+
+
+class ConnectModal(ModalScreen[None]):
+    """Modal for connecting AI provider."""
+
+    CSS = """
+    ConnectModal {
+        align: center middle;
+    }
+    #connect-container {
+        width: 60;
+        max-height: 35;
+        background: $surface;
+        border: tall $primary;
+        padding: 2;
+    }
+    #connect-title {
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+    .field-label {
+        color: $text-muted;
+        margin-top: 1;
+    }
+    #provider-select {
+        width: 100%;
+    }
+    #base-url-input, #api-key-input, #model-input {
+        width: 100%;
+    }
+    #save-btn {
+        width: 100%;
+        margin-top: 2;
+    }
+    #status-message {
+        margin-top: 1;
+        text-align: center;
+    }
+    .success {
+        color: $success;
+    }
+    .error {
+        color: $error;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+    ]
+
+    PROVIDERS = [
+        ("openai", "OpenAI"),
+        ("anthropic", "Anthropic Claude"),
+        ("google", "Google Gemini"),
+        ("ollama", "Ollama (Local)"),
+        ("openai-compatible", "OpenAI Compatible"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.config = get_config()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="connect-container"):
+            yield Static("Connect AI Provider", id="connect-title")
+
+            yield Static("Provider:", classes="field-label")
+            yield Select(
+                [(label, value) for value, label in self.PROVIDERS],
+                id="provider-select",
+                prompt="Select provider...",
+            )
+
+            yield Static("Base URL:", classes="field-label")
+            yield Input(placeholder="https://api.openai.com/v1", id="base-url-input")
+
+            yield Static("API Key:", classes="field-label")
+            yield Input(placeholder="sk-...", password=True, id="api-key-input")
+
+            yield Static("Model:", classes="field-label")
+            yield Input(placeholder="gpt-4o", id="model-input")
+
+            yield Button("Save", id="save-btn", variant="primary")
+            yield Static("", id="status-message")
+
+    @on(Select.Changed, "#provider-select")
+    def on_provider_changed(self, event: Select.Changed) -> None:
+        """Update placeholder based on provider."""
+        provider = event.value
+        base_url_input = self.query_one("#base-url-input", Input)
+        model_input = self.query_one("#model-input", Input)
+
+        defaults = {
+            "openai": ("https://api.openai.com/v1", "gpt-4o"),
+            "anthropic": ("", "claude-sonnet-4-20250514"),
+            "google": ("", "gemini-2.0-flash"),
+            "ollama": ("http://localhost:11434", "llama3"),
+            "openai-compatible": ("", ""),
+        }
+
+        if provider in defaults:
+            url, model = defaults[provider]
+            base_url_input.placeholder = url
+            model_input.placeholder = model
+
+    @on(Button.Pressed, "#save-btn")
+    def on_save_pressed(self, event: Button.Pressed) -> None:
+        """Save provider configuration."""
+        provider = self.query_one("#provider-select", Select).value
+        if provider is Select.BLANK:
+            self.update_status("Please select a provider", "error")
+            return
+
+        base_url = self.query_one("#base-url-input", Input).value.strip()
+        api_key = self.query_one("#api-key-input", Input).value.strip()
+        model = self.query_one("#model-input", Input).value.strip()
+
+        if not api_key and provider != "ollama":
+            self.update_status("API key is required", "error")
+            return
+
+        if not model:
+            self.update_status("Model is required", "error")
+            return
+
+        provider_config = {
+            "type": provider,
+            "api_key": api_key,
+            "base_url": base_url or None,
+            "model": model,
+        }
+
+        self.config.add_provider(provider, provider_config)
+        self.config.active_provider = provider
+        self.config.active_model = model
+
+        self.update_status(f"Connected to {provider} — {model}", "success")
+        self.set_timer(0.9, self.dismiss)
+
+    def update_status(self, message: str, style: str) -> None:
+        """Update status message."""
+        from rich.markup import escape as _escape
+        status = self.query_one("#status-message", Static)
+        safe = _escape(str(message))
+        if style == "success":
+            status.update(f"[green]✓[/] {safe}")
+        else:
+            status.update(f"[red]✗[/] {safe}")
+
+    def action_close(self) -> None:
+        """Close the modal."""
+        self.dismiss()

devobin/ui/export_modal.py

@@ -0,0 +1,159 @@
+"""Export modal for DevObin AI."""
+
+from __future__ import annotations
+
+import os
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, Button
+from textual.containers import Vertical
+from textual.binding import Binding
+from textual import on
+from rich.markup import escape
+
+from devobin.config.settings import get_config
+from devobin.storage.database import ProjectStorage
+from devobin.core.analyzer import analyze_input
+from devobin.core.researcher import research_analysis
+from devobin.core.prompt_builder import build_prompt
+from devobin.core.memory import MemoryManager
+
+
+class ExportModal(ModalScreen[None]):
+    """Modal for exporting project prompt."""
+
+    CSS = """
+    ExportModal {
+        align: center middle;
+    }
+    #export-container {
+        width: 70;
+        max-height: 40;
+        background: $surface;
+        border: tall $primary;
+        padding: 2;
+    }
+    #export-title {
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+    #export-content {
+        height: auto;
+        max-height: 25;
+        overflow-y: auto;
+    }
+    #status-message {
+        margin-top: 1;
+        text-align: center;
+    }
+    #close-btn {
+        width: 100%;
+        margin-top: 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+    ]
+
+    def __init__(self, custom_filename: str = "", ai_response: str = "") -> None:
+        super().__init__()
+        self.config = get_config()
+        self._custom_filename = custom_filename
+        self._ai_response = ai_response
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="export-container"):
+            yield Static("Export Prompt", id="export-title")
+            yield Static("[dim]Generating...[/]", id="export-content")
+            yield Static("", id="status-message")
+            yield Button("Close", id="close-btn", variant="default")
+
+    def on_mount(self) -> None:
+        """Generate prompt after the modal is shown."""
+        self.set_timer(0.05, self.generate_prompt)
+
+    def generate_prompt(self) -> None:
+        """Generate the project prompt and save to workspace."""
+        project = self.config.get("active_project")
+        filename = "devobin_prompt.md"
+
+        # If we have the actual AI response, use it directly
+        if self._ai_response and self._ai_response.strip():
+            prompt_content = self._ai_response.strip()
+        else:
+            # Fallback to prompt_builder template
+            if not project:
+                self.update_status("No active project. Create one with /project.", "error")
+                self.query_one("#export-content", Static).update("[dim]Nothing to export.[/]")
+                return
+
+            storage = ProjectStorage(project)
+            history = storage.get_history()
+
+            if not history:
+                self.update_status("No conversation history yet.", "error")
+                self.query_one("#export-content", Static).update("[dim]Chat first, then export.[/]")
+                return
+
+            try:
+                user_msgs = " ".join(m["content"] for m in history if m["role"] == "user")
+                analysis = analyze_input(user_msgs)
+                research = research_analysis(analysis)
+
+                memory_ctx = MemoryManager(project).get_memory_context()
+
+                # Scan the workspace so the exported document is grounded
+                from devobin.core.scanner import scan_workspace
+                pm = scan_workspace()
+
+                filename, prompt_content = build_prompt(
+                    analysis, research,
+                    memory_context=memory_ctx,
+                    project_name=self._custom_filename or project,
+                    project_map=pm,
+                )
+            except Exception as e:
+                self.update_status(f"Export failed: {e}", "error")
+                return
+
+        try:
+            # 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)
+        except Exception as e:
+            self.update_status(f"Export failed: {e}", "error")
+            return
+
+        content = self.query_one("#export-content", Static)
+        preview = prompt_content[:2000]
+        if len(prompt_content) > 2000:
+            preview += "\n\n... (truncated)"
+        content.update(escape(preview))
+
+        self.update_status(
+            f"Created: {output_path}",
+            "success",
+        )
+
+    def update_status(self, message: str, style: str) -> None:
+        """Update status message."""
+        status = self.query_one("#status-message", Static)
+        safe = escape(str(message))
+        if style == "success":
+            status.update(f"[green]✓[/] {safe}")
+        else:
+            status.update(f"[red]✗[/] {safe}")
+
+    @on(Button.Pressed, "#close-btn")
+    def on_close_pressed(self) -> None:
+        """Close the modal."""
+        self.dismiss()
+
+    def action_close(self) -> None:
+        """Close the modal."""
+        self.dismiss()

devobin/ui/history_modal.py

@@ -0,0 +1,137 @@
+"""History modal — shows past chat sessions for the active project."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, Button, ListItem, ListView
+from textual.containers import Vertical, Horizontal
+from textual.binding import Binding
+from textual import on
+from rich.markup import escape
+
+from devobin.config.settings import get_config
+from devobin.storage.database import ProjectStorage
+
+
+class HistoryModal(ModalScreen[None]):
+    """Modal that lists past chat sessions from the active project."""
+
+    CSS = """
+    HistoryModal {
+        align: center middle;
+    }
+    #hist-container {
+        width: 70;
+        height: 35;
+        background: $surface;
+        border: tall $primary;
+        padding: 1;
+    }
+    #hist-title {
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        height: 1;
+        margin-bottom: 1;
+    }
+    #hist-list {
+        height: 1fr;
+        overflow-y: auto;
+    }
+    #hist-list ListItem {
+        padding: 0 1;
+    }
+    #hist-detail {
+        height: 12;
+        overflow-y: auto;
+        border: solid $primary;
+        margin-top: 1;
+        padding: 1;
+    }
+    #hist-buttons {
+        height: auto;
+        margin-top: 1;
+    }
+    #hist-buttons Button {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.config = get_config()
+        self._project = self.config.get("active_project")
+        self._sessions: list[dict] = []
+        self._selected_index: int = -1
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="hist-container"):
+            yield Static("Chat History", id="hist-title")
+            yield ListView(id="hist-list")
+            yield Static("[dim]Select a session to view details[/]", id="hist-detail")
+            with Horizontal(id="hist-buttons"):
+                yield Button("Close", id="hist-close", variant="default")
+
+    def on_mount(self) -> None:
+        if not self._project:
+            self.query_one("#hist-title", Static).update(
+                "[dim]No active project. Use /project create first.[/]"
+            )
+            return
+
+        storage = ProjectStorage(self._project)
+        self._sessions = storage.list_sessions()
+
+        if not self._sessions:
+            self.query_one("#hist-title", Static).update(
+                "[dim]No sessions yet. Start chatting![/]"
+            )
+            return
+
+        lv = self.query_one("#hist-list", ListView)
+        for i, s in enumerate(self._sessions):
+            label = f"Session {i+1} — {s['count']} messages — {s['preview']}"
+            lv.append(ListItem(Static(escape(label))))
+
+        self.query_one("#hist-title", Static).update(
+            f"Chat History — {self._project} ({len(self._sessions)} sessions)"
+        )
+
+    @on(ListView.Selected)
+    def on_selected(self, event: ListView.Selected) -> None:
+        # Find the index by matching the item
+        lv = self.query_one("#hist-list", ListView)
+        idx = event.item_index if hasattr(event, "item_index") else -1
+        if idx < 0:
+            # Fallback: count items
+            for i, item in enumerate(lv.children):
+                if item is event.item:
+                    idx = i
+                    break
+
+        if 0 <= idx < len(self._sessions):
+            self._selected_index = idx
+            session = self._sessions[idx]
+            lines = []
+            for msg in session["messages"][:20]:
+                role = msg.get("role", "?")
+                content = msg.get("content", "")[:100]
+                lines.append(f"[bold]{role}[/bold]: {content}")
+            detail = "\n".join(lines)
+            if len(session["messages"]) > 20:
+                detail += f"\n\n... ({len(session['messages']) - 20} more messages)"
+            self.query_one("#hist-detail", Static).update(detail)
+
+    @on(Button.Pressed, "#hist-close")
+    def on_close_pressed(self) -> None:
+        self.dismiss()
+
+    def action_close(self) -> None:
+        self.dismiss()

devobin/ui/memory_modal.py

@@ -0,0 +1,88 @@
+"""Memory modal for DevObin AI."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, Button, DataTable
+from textual.containers import Vertical
+from textual.binding import Binding
+from textual import on
+
+from devobin.config.settings import get_config
+from devobin.core.memory import MemoryManager
+
+
+class MemoryModal(ModalScreen[None]):
+    """Modal for viewing memories."""
+
+    CSS = """
+    MemoryModal {
+        align: center middle;
+    }
+    #memory-container {
+        width: 60;
+        max-height: 30;
+        background: $surface;
+        border: tall $primary;
+        padding: 2;
+    }
+    #memory-title {
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+    #memory-table {
+        height: auto;
+        max-height: 18;
+    }
+    #close-btn {
+        width: 100%;
+        margin-top: 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.config = get_config()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="memory-container"):
+            yield Static("Memory", id="memory-title")
+
+            table = DataTable(id="memory-table")
+            table.add_columns("Type", "Content")
+            yield table
+
+            yield Button("Close", id="close-btn", variant="default")
+
+    def on_mount(self) -> None:
+        """Load memories on mount."""
+        table = self.query_one("#memory-table", DataTable)
+        manager = MemoryManager()
+
+        global_mems = manager.get_global_memories()
+        project_mems = manager.get_project_memories()
+
+        for mem in global_mems[-10:]:
+            table.add_row("Global", mem.get("content", "")[:60])
+
+        for mem in project_mems[-10:]:
+            table.add_row("Project", mem.get("content", "")[:60])
+
+        if not global_mems and not project_mems:
+            table.add_row("-", "No memories saved yet")
+
+    @on(Button.Pressed, "#close-btn")
+    def on_close_pressed(self) -> None:
+        """Close the modal."""
+        self.dismiss()
+
+    def action_close(self) -> None:
+        """Close the modal."""
+        self.dismiss()