devobin 1.0.0__py3-none-any.whl

devobin/cli/commands.py

@@ -0,0 +1,362 @@
+"""Slash command handler for DevObin AI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from devobin.cli.ui import (
+    console,
+    print_error,
+    print_help,
+    print_provider_table,
+    print_model_table,
+    print_success,
+    print_status,
+    print_warning,
+)
+from devobin.config.settings import get_config, CONFIG_DIR
+
+
+@dataclass
+class CommandResult:
+    """Result of processing a command."""
+
+    handled: bool = False
+    should_exit: bool = False
+    message: str = ""
+
+
+async def handle_command(command: str) -> CommandResult:
+    """Process a slash command and return the result."""
+    parts = command.strip().split(maxsplit=1)
+    cmd = parts[0].lower() if parts else ""
+    args = parts[1] if len(parts) > 1 else ""
+
+    handlers = {
+        "/help": _cmd_help,
+        "/connect": _cmd_connect,
+        "/models": _cmd_models,
+        "/model": _cmd_model,
+        "/memory": _cmd_memory,
+        "/project": _cmd_project,
+        "/export": _cmd_export,
+        "/settings": _cmd_settings,
+        "/clear": _cmd_clear,
+        "/quit": _cmd_quit,
+        "/exit": _cmd_quit,
+    }
+
+    handler = handlers.get(cmd)
+    if handler:
+        return await handler(args)
+
+    print_error(f"Unknown command: {cmd}. Type /help to see available commands.")
+    return CommandResult(handled=True)
+
+
+async def _cmd_help(args: str) -> CommandResult:
+    print_help()
+    return CommandResult(handled=True)
+
+
+async def _cmd_connect(args: str) -> CommandResult:
+    """Interactive provider connection wizard."""
+    from rich.prompt import Prompt, Confirm
+
+    config = get_config()
+
+    console.print()
+    console.print("  [bold cyan]AI Provider Setup[/]", style="bold")
+    console.print()
+
+    provider_types = ["openai", "anthropic", "google", "ollama", "openai-compatible"]
+    console.print("  Available provider types:")
+    for i, pt in enumerate(provider_types, 1):
+        console.print(f"    {i}. {pt}")
+    console.print()
+
+    choice = Prompt.ask("  Select provider type", choices=[str(i) for i in range(1, 6)], default="1")
+    provider_type = provider_types[int(choice) - 1]
+
+    console.print()
+    name = Prompt.ask("  Provider name", default=provider_type)
+    api_key = Prompt.ask("  API key", password=True, default="")
+
+    base_url = ""
+    if provider_type == "openai-compatible":
+        base_url = Prompt.ask("  API base URL", default="https://api.openai.com/v1")
+    elif provider_type == "ollama":
+        base_url = Prompt.ask("  Ollama URL", default="http://localhost:11434")
+
+    # Get available models
+    from devobin.providers import AIProvider
+
+    temp_config = {
+        "api_key": api_key,
+        "base_url": base_url or None,
+        "model": "",
+        "type": provider_type,
+    }
+
+    # Try to get models from provider
+    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 type 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")
+
+    # Save
+    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()
+    return CommandResult(handled=True)
+
+
+async def _cmd_models(args: str) -> CommandResult:
+    """List available models from current provider."""
+    config = get_config()
+    providers = config.list_providers()
+
+    if not providers:
+        print_warning("No providers configured. Use /connect to set one up.")
+        return CommandResult(handled=True)
+
+    print_provider_table(providers)
+    return CommandResult(handled=True)
+
+
+async def _cmd_model(args: str) -> CommandResult:
+    """Switch to a different model."""
+    config = get_config()
+
+    if not args:
+        current = config.active_model or "None"
+        print_status(f"Current model: [bold]{current}[/]")
+        return CommandResult(handled=True)
+
+    config.active_model = args.strip()
+    print_success(f"Switched to model: {args.strip()}")
+    return CommandResult(handled=True)
+
+
+async def _cmd_memory(args: str) -> CommandResult:
+    """Show saved memories."""
+    from devobin.core.memory import MemoryManager
+
+    config = get_config()
+    manager = MemoryManager()
+
+    global_mems = manager.get_global_memories()
+    project_mems = manager.get_project_memories()
+
+    if not global_mems and not project_mems:
+        print_status("No memories saved yet. Chat with DevObin to build context.")
+        return CommandResult(handled=True)
+
+    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()
+    return CommandResult(handled=True)
+
+
+async def _cmd_project(args: str) -> CommandResult:
+    """Manage projects."""
+    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 CommandResult(handled=True)
+
+        from devobin.storage.database import ProjectStorage
+        ProjectStorage(proj_name)  # creates dirs
+        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 CommandResult(handled=True)
+
+        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. Available: {', '.join(projects)}")
+            return CommandResult(handled=True)
+
+        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>  — Create a new project")
+        console.print("    /project switch <name>  — Switch to a project")
+        console.print("    /project list           — List all projects")
+
+    return CommandResult(handled=True)
+
+
+async def _cmd_export(args: str) -> CommandResult:
+    """Generate the project_prompt.md file."""
+    from devobin.cli.ui import render_markdown
+
+    config = get_config()
+    project = config.get("active_project")
+
+    if not project:
+        print_warning("No active project. Use /project create <name> first.")
+        return CommandResult(handled=True)
+
+    from devobin.storage.database import ProjectStorage
+
+    storage = ProjectStorage(project)
+    history = storage.get_history()
+
+    if not history:
+        print_warning("No conversation history to export.")
+        return CommandResult(handled=True)
+
+    # Re-analyze and build prompt from history
+    from devobin.core.analyzer import analyze_input
+    from devobin.core.researcher import research_analysis
+    from devobin.core.prompt_builder import build_prompt
+
+    # Combine all user messages for analysis
+    user_msgs = " ".join(m["content"] for m in history if m["role"] == "user")
+    analysis = analyze_input(user_msgs)
+    research = research_analysis(analysis)
+
+    from devobin.core.memory import MemoryManager
+    mm = MemoryManager(project)
+    memory_ctx = mm.get_memory_context()
+
+    from devobin.core.scanner import scan_workspace
+    pm = scan_workspace()
+
+    _, prompt_content = build_prompt(analysis, research, memory_context=memory_ctx, project_map=pm)
+
+    # Save to CWD with the canonical filename
+    import os
+    output_path = os.path.join(os.getcwd(), "devobin_prompt.md")
+    output_path.write_text(prompt_content, encoding="utf-8")
+
+    print_success(f"Generated: {output_path}")
+    console.print()
+    render_markdown(prompt_content[:2000])
+    if len(prompt_content) > 2000:
+        console.print("\n  [dim]... (truncated preview)[/]")
+    console.print()
+
+    return CommandResult(handled=True)
+
+
+async def _cmd_settings(args: str) -> CommandResult:
+    """Show current settings."""
+    config = get_config()
+
+    console.print()
+    console.print("  [bold cyan]Current Settings:[/]")
+    console.print(f"    Active provider: [bold]{config.active_provider or 'None'}[/]")
+    console.print(f"    Active model:    [bold]{config.active_model or 'None'}[/]")
+    console.print(f"    Active project:  [bold]{config.get('active_project') or 'None'}[/]")
+    console.print(f"    Config dir:      [dim]{CONFIG_DIR}[/]")
+    console.print()
+    return CommandResult(handled=True)
+
+
+async def _cmd_clear(args: str) -> CommandResult:
+    """Clear current conversation."""
+    from devobin.storage.database import ProjectStorage
+    config = get_config()
+    project = config.get("active_project")
+    if project:
+        storage = ProjectStorage(project)
+        storage.clear_history()
+        print_success("Conversation cleared.")
+    else:
+        print_warning("No active project to clear.")
+    return CommandResult(handled=True)
+
+
+async def _cmd_quit(args: str) -> CommandResult:
+    console.print()
+    print_success("Goodbye! Happy coding!")
+    console.print()
+    return CommandResult(handled=True, should_exit=True)

devobin/cli/slash_menu.py

@@ -0,0 +1,74 @@
+"""Slash command menu system for DevObin AI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from devobin.cli.terminal import console, render_slash_menu
+
+
+@dataclass
+class SlashCommand:
+    """A slash command definition."""
+
+    name: str
+    description: str
+    handler: Callable[..., None]
+    requires_args: bool = False
+
+
+class SlashMenu:
+    """Manages slash commands and their display."""
+
+    def __init__(self) -> None:
+        self._commands: dict[str, SlashCommand] = {}
+
+    def register(
+        self,
+        name: str,
+        description: str,
+        handler: Callable[..., None],
+        requires_args: bool = False,
+    ) -> None:
+        """Register a slash command."""
+        self._commands[name] = SlashCommand(
+            name=name,
+            description=description,
+            handler=handler,
+            requires_args=requires_args,
+        )
+
+    def get_command(self, name: str) -> SlashCommand | None:
+        """Get a command by name."""
+        return self._commands.get(name)
+
+    def show_menu(self) -> None:
+        """Display the slash command menu."""
+        render_slash_menu()
+
+    def parse_command(self, input_text: str) -> tuple[str, str]:
+        """Parse slash command input into (command, args)."""
+        parts = input_text.strip().split(maxsplit=1)
+        cmd = parts[0].lower() if parts else ""
+        args = parts[1] if len(parts) > 1 else ""
+        return cmd, args
+
+    def execute(self, input_text: str) -> bool:
+        """Execute a slash command. Returns True if command was handled."""
+        cmd, args = self.parse_command(input_text)
+
+        if cmd == "/":
+            self.show_menu()
+            return True
+
+        command = self.get_command(cmd)
+        if command:
+            command.handler(args)
+            return True
+
+        return False
+
+    @property
+    def commands(self) -> dict[str, SlashCommand]:
+        return self._commands

devobin/cli/terminal.py

@@ -0,0 +1,155 @@
+"""Terminal rendering for DevObin AI."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.columns import Columns
+from rich import box
+
+from devobin.config.settings import get_config
+
+console = Console()
+
+
+def render_banner() -> None:
+    """Render the main DevObin banner."""
+    banner = Text()
+    banner.append("  ██████╗ ███████╗██╗   ██╗███████╗██╗      ██████╗ ██╗    ██╗\n", style="bold cyan")
+    banner.append("  ██╔══██╗██╔════╝██║   ██║██╔════╝██║     ██╔═══██╗██║    ██║\n", style="bold cyan")
+    banner.append("  ██║  ██║█████╗  ██║   ██║█████╗  ██║     ██║   ██║██║ █╗ ██║\n", style="bold cyan")
+    banner.append("  ██║  ██║██╔══╝  ╚██╗ ██╔╝██╔══╝  ██║     ██║   ██║██║███╗██║\n", style="bold cyan")
+    banner.append("  ██████╔╝███████╗ ╚████╔╝ ██║     ███████╗╚██████╔╝╚███╔███╔╝\n", style="bold cyan")
+    banner.append("  ╚═════╝ ╚══════╝  ╚═══╝  ╚═╝     ╚══════╝ ╚═════╝  ╚══╝╚══╝\n", style="bold cyan")
+
+    config = get_config()
+    model = config.active_model or "Not connected"
+    project = config.get("active_project") or "default"
+
+    status = Text()
+    status.append(f"\n  Model: ", style="dim")
+    status.append(f"{model}\n", style="bold green")
+    status.append(f"  Project: ", style="dim")
+    status.append(f"{project}\n", style="bold yellow")
+    status.append(f"\n  Developer: mobin hasanghasemi", style="dim white")
+    status.append(f"\n  GitHub: ", style="dim white")
+    status.append(f"https://github.com/mobinhasanghasemi", style="bold dim cyan")
+
+    content = Text()
+    content.append_text(banner)
+    content.append_text(status)
+
+    console.print(Panel(
+        content,
+        border_style="cyan",
+        padding=(0, 1),
+        box=box.DOUBLE,
+    ))
+
+
+def render_slash_menu() -> None:
+    """Render the beautiful slash command menu."""
+    table = Table(
+        show_header=False,
+        show_edge=False,
+        box=None,
+        padding=(0, 2),
+    )
+    table.add_column("Command", style="bold cyan", width=12)
+    table.add_column("Description", style="white")
+
+    commands = [
+        ("/connect", "Connect AI provider"),
+        ("/model", "Change active model"),
+        ("/models", "List models"),
+        ("/project", "Manage projects"),
+        ("/memory", "View memory"),
+        ("/export", "Generate prompt file"),
+        ("/settings", "Settings"),
+        ("/run", "Run shell command"),
+        ("/read", "Read file contents"),
+        ("/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"),
+    ]
+
+    for cmd, desc in commands:
+        table.add_row(cmd, desc)
+
+    console.print(Panel(
+        table,
+        title="[bold cyan]DevObin Commands[/]",
+        border_style="cyan",
+        box=box.ROUNDED,
+        padding=(1, 2),
+    ))
+
+
+def render_action_menu(actions: list[tuple[str, str]]) -> None:
+    """Render an action menu (like after generating context)."""
+    table = Table(
+        show_header=False,
+        show_edge=False,
+        box=None,
+        padding=(0, 1),
+    )
+    table.add_column("Choice", style="bold yellow", width=4)
+    table.add_column("Action", style="white")
+
+    for i, (action, desc) in enumerate(actions, 1):
+        table.add_row(f"[{i}]", f"{action} — {desc}")
+
+    console.print(Panel(
+        table,
+        title="[bold yellow]Actions[/]",
+        border_style="yellow",
+        box=box.ROUNDED,
+        padding=(0, 1),
+    ))
+
+
+def render_status_bar() -> None:
+    """Render the status bar with model and project info."""
+    config = get_config()
+    model = config.active_model or "No model"
+    project = config.get("active_project") or "No project"
+
+    status = Text()
+    status.append("  ╭────────────────────────────────────────────╮\n", style="dim")
+    status.append(f"  │  Model: ", style="dim")
+    status.append(f"{model:<30}", style="bold green")
+    status.append("│\n", style="dim")
+    status.append(f"  │  Project: ", style="dim")
+    status.append(f"{project:<28}", style="bold yellow")
+    status.append("│\n", style="dim")
+    status.append("  ╰────────────────────────────────────────────╯\n", style="dim")
+
+    console.print(status)
+
+
+def render_divider() -> None:
+    """Render a visual divider."""
+    console.print("  " + "─" * 44, style="dim")
+
+
+def render_input_prefix() -> Text:
+    """Create the input prefix."""
+    prefix = Text()
+    prefix.append("  You ", style="bold cyan")
+    prefix.append("› ", style="bold white")
+    return prefix
+
+
+def render_ai_prefix() -> Text:
+    """Create the AI response prefix."""
+    prefix = Text()
+    prefix.append("  DevObin ", style="bold green")
+    prefix.append("› ", style="bold white")
+    return prefix