devobin 1.0.0__py3-none-any.whl

devobin/cli/ui.py

@@ -0,0 +1,129 @@
+"""Rich UI components 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.markdown import Markdown
+from rich.theme import Theme
+from rich.tree import Tree
+from rich import box
+
+DEVOBIN_THEME = Theme({
+    "info": "cyan",
+    "success": "green",
+    "warning": "yellow",
+    "error": "bold red",
+    "accent": "bold magenta",
+    "dim": "dim white",
+})
+
+console = Console(theme=DEVOBIN_THEME)
+
+
+def print_status(message: str, style: str = "info") -> None:
+    """Print a status message."""
+    console.print(f"  {message}", style=style)
+
+
+def print_success(message: str) -> None:
+    console.print(f"  ✓ {message}", style="success")
+
+
+def print_error(message: str) -> None:
+    console.print(f"  ✗ {message}", style="error")
+
+
+def print_warning(message: str) -> None:
+    console.print(f"  ! {message}", style="warning")
+
+
+def print_detected(techs: list[str], label: str = "Detected") -> None:
+    """Print detected technologies in a tree."""
+    if not techs:
+        return
+    tree = Tree(f"[bold cyan]{label}[/]")
+    for tech in techs:
+        tree.add(f"[green]✓[/] {tech}")
+    console.print(tree)
+
+
+def print_research_status(tech: str) -> None:
+    console.print(f"  [dim]Researching {tech}...[/]", end="\r")
+
+
+def print_provider_table(providers: dict) -> Table:
+    """Print configured providers as a table."""
+    table = Table(title="Configured Providers", border_style="cyan", box=box.ROUNDED)
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Name", style="bold")
+    table.add_column("Provider", style="cyan")
+    table.add_column("Model", style="green")
+    table.add_column("Base URL", style="dim")
+
+    for i, (name, cfg) in enumerate(providers.items(), 1):
+        table.add_row(
+            str(i),
+            name,
+            cfg.get("type", name),
+            cfg.get("model", "-"),
+            cfg.get("base_url", "-"),
+        )
+
+    console.print(table)
+    return table
+
+
+def print_model_table(models: list[str], provider: str) -> Table:
+    """Print available models as a table."""
+    table = Table(title=f"Available Models ({provider})", border_style="green", box=box.ROUNDED)
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Model", style="bold")
+
+    for i, model in enumerate(models, 1):
+        table.add_row(str(i), model)
+
+    console.print(table)
+    return table
+
+
+def print_help() -> None:
+    """Print the help screen as a beautiful panel."""
+    table = Table(show_header=False, show_edge=False, box=None, padding=(0, 2))
+    table.add_column("Command", style="bold cyan", width=15)
+    table.add_column("Description", style="white")
+
+    commands = [
+        ("/help", "Show this help message"),
+        ("/connect", "Connect or configure an AI provider"),
+        ("/models", "List available models from current provider"),
+        ("/model <name>", "Switch to a different model"),
+        ("/history", "Show previous chat sessions"),
+        ("/memory", "View saved memories"),
+        ("/project create <name>", "Create a new project"),
+        ("/project switch <name>", "Switch to a project"),
+        ("/project list", "List all projects"),
+        ("/export", "Generate project_prompt.md"),
+        ("/settings", "View or modify settings"),
+        ("/clear", "Clear current conversation"),
+        ("/quit", "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_markdown(text: str) -> None:
+    """Render markdown text with Rich."""
+    md = Markdown(text)
+    console.print(md)

devobin/config/__init__.py

@@ -0,0 +1 @@
+"""DevObin config package."""

devobin/config/settings.py

@@ -0,0 +1,124 @@
+"""Configuration management for DevObin AI."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from platformdirs import user_config_dir, user_data_dir
+
+APP_NAME = "devobin"
+CONFIG_DIR = Path(user_config_dir(APP_NAME))
+DATA_DIR = Path(user_data_dir(APP_NAME))
+
+
+def local_data_dir() -> Path:
+    """Return the .devobin directory inside the current working directory.
+
+    Chat history, memory, and project-specific data live here so the user
+    can find everything where they launched the CLI.
+    """
+    d = Path.cwd() / ".devobin"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def ensure_dirs() -> None:
+    """Create all required directories."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    (DATA_DIR / "projects").mkdir(parents=True, exist_ok=True)
+    (DATA_DIR / "prompts").mkdir(parents=True, exist_ok=True)
+
+
+class ConfigManager:
+    """Manages application configuration and provider settings."""
+
+    def __init__(self) -> None:
+        ensure_dirs()
+        self._settings_path = CONFIG_DIR / "settings.json"
+        self._providers_path = CONFIG_DIR / "providers.json"
+        self._settings: dict[str, Any] = self._load(self._settings_path)
+        self._providers: dict[str, Any] = self._load(self._providers_path)
+
+    def _load(self, path: Path) -> dict[str, Any]:
+        if path.exists():
+            return json.loads(path.read_text(encoding="utf-8"))
+        return {}
+
+    def _save(self, path: Path, data: dict[str, Any]) -> None:
+        path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    # ── General Settings ──────────────────────────────────────────
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._settings.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._settings[key] = value
+        self._save(self._settings_path, self._settings)
+
+    @property
+    def active_provider(self) -> str | None:
+        return self._settings.get("active_provider")
+
+    @active_provider.setter
+    def active_provider(self, name: str) -> None:
+        self._settings["active_provider"] = name
+        self._save(self._settings_path, self._settings)
+
+    @property
+    def active_model(self) -> str | None:
+        return self._settings.get("active_model")
+
+    @active_model.setter
+    def active_model(self, model: str) -> None:
+        self._settings["active_model"] = model
+        self._save(self._settings_path, self._settings)
+
+    # ── Provider Management ───────────────────────────────────────
+
+    def list_providers(self) -> dict[str, Any]:
+        return self._providers
+
+    def get_provider(self, name: str) -> dict[str, Any] | None:
+        return self._providers.get(name)
+
+    def add_provider(self, name: str, config: dict[str, Any]) -> None:
+        self._providers[name] = config
+        self._save(self._providers_path, self._providers)
+
+    def remove_provider(self, name: str) -> bool:
+        if name in self._providers:
+            del self._providers[name]
+            self._save(self._providers_path, self._providers)
+            return True
+        return False
+
+    # ── Project Paths ─────────────────────────────────────────────
+
+    def projects_dir(self) -> Path:
+        d = DATA_DIR / "projects"
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    def project_dir(self, name: str) -> Path:
+        d = self.projects_dir() / name
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    def prompts_dir(self) -> Path:
+        d = DATA_DIR / "prompts"
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+
+_config: ConfigManager | None = None
+
+
+def get_config() -> ConfigManager:
+    global _config
+    if _config is None:
+        _config = ConfigManager()
+    return _config

devobin/core/__init__.py

@@ -0,0 +1 @@
+"""DevObin core package."""

devobin/core/analyzer.py

@@ -0,0 +1,166 @@
+"""Project analyzer - detects technologies and requirements from user input."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TechSignal:
+    """A detected technology with confidence and category."""
+
+    name: str
+    category: str  # framework, database, frontend, language, tool, cloud
+    confidence: float = 1.0
+    keywords: list[str] = field(default_factory=list)
+
+
+# ── Keyword-based detection patterns ──────────────────────────────
+
+TECH_PATTERNS: list[TechSignal] = [
+    # Backend Frameworks
+    TechSignal("Django", "framework", keywords=["django", "djangorestframework", "drf"]),
+    TechSignal("FastAPI", "framework", keywords=["fastapi", "fast api"]),
+    TechSignal("Flask", "framework", keywords=["flask"]),
+    TechSignal("Express.js", "framework", keywords=["express", "expressjs", "express.js"]),
+    TechSignal("NestJS", "framework", keywords=["nestjs", "nest js"]),
+    TechSignal("Laravel", "framework", keywords=["laravel"]),
+    TechSignal("Ruby on Rails", "framework", keywords=["rails", "ruby on rails"]),
+    TechSignal("Spring Boot", "framework", keywords=["spring boot", "springboot"]),
+    TechSignal("ASP.NET", "framework", keywords=["asp.net", "dotnet", ".net core"]),
+    TechSignal("Gin", "framework", keywords=["gin", "gin-gonic"]),
+    TechSignal("Echo", "framework", keywords=["echo framework"]),
+    TechSignal("Actix", "framework", keywords=["actix", "actix-web"]),
+    TechSignal("Axum", "framework", keywords=["axum"]),
+    # Frontend
+    TechSignal("React", "frontend", keywords=["react", "reactjs", "react.js", "nextjs", "next.js"]),
+    TechSignal("Vue.js", "frontend", keywords=["vue", "vuejs", "vue.js", "nuxt", "nuxtjs"]),
+    TechSignal("Angular", "frontend", keywords=["angular", "angularjs"]),
+    TechSignal("Svelte", "frontend", keywords=["svelte", "sveltekit"]),
+    TechSignal("HTMX", "frontend", keywords=["htmx"]),
+    TechSignal("Tailwind CSS", "frontend", keywords=["tailwind", "tailwindcss"]),
+    TechSignal("Bootstrap", "frontend", keywords=["bootstrap"]),
+    TechSignal("shadcn/ui", "frontend", keywords=["shadcn", "shadcnui"]),
+    # Languages
+    TechSignal("Python", "language", keywords=["python", "py"]),
+    TechSignal("JavaScript", "language", keywords=["javascript", "js"]),
+    TechSignal("TypeScript", "language", keywords=["typescript", "ts"]),
+    TechSignal("Go", "language", keywords=["golang"]),
+    TechSignal("Rust", "language", keywords=["rust"]),
+    TechSignal("Java", "language", keywords=["java", " spring"]),
+    TechSignal("C#", "language", keywords=["c#", "csharp", "c sharp"]),
+    TechSignal("PHP", "language", keywords=["php"]),
+    TechSignal("Ruby", "language", keywords=["ruby"]),
+    # Databases
+    TechSignal("PostgreSQL", "database", keywords=["postgresql", "postgres", "psql"]),
+    TechSignal("MySQL", "database", keywords=["mysql", "mariadb"]),
+    TechSignal("SQLite", "database", keywords=["sqlite"]),
+    TechSignal("MongoDB", "database", keywords=["mongodb", "mongo"]),
+    TechSignal("Redis", "database", keywords=["redis"]),
+    TechSignal("Elasticsearch", "database", keywords=["elasticsearch", "elastic"]),
+    TechSignal("DynamoDB", "database", keywords=["dynamodb", "dynamo"]),
+    TechSignal("Supabase", "database", keywords=["supabase"]),
+    TechSignal("PlanetScale", "database", keywords=["planetscale"]),
+    # Tools & Services
+    TechSignal("Docker", "tool", keywords=["docker", "container", "containers"]),
+    TechSignal("Kubernetes", "tool", keywords=["kubernetes", "k8s"]),
+    TechSignal("Celery", "tool", keywords=["celery"]),
+    TechSignal("RabbitMQ", "tool", keywords=["rabbitmq", "rabbit"]),
+    TechSignal("Kafka", "tool", keywords=["kafka"]),
+    TechSignal("Nginx", "tool", keywords=["nginx"]),
+    TechSignal("Stripe", "tool", keywords=["stripe", "payment"]),
+    TechSignal("AWS", "cloud", keywords=["aws", "amazon web services"]),
+    TechSignal("GCP", "cloud", keywords=["gcp", "google cloud"]),
+    TechSignal("Azure", "cloud", keywords=["azure", "microsoft azure"]),
+    TechSignal("Vercel", "cloud", keywords=["vercel"]),
+    TechSignal("Cloudflare", "cloud", keywords=["cloudflare"]),
+    # Patterns
+    TechSignal("REST API", "pattern", keywords=["rest api", "restful", "rest"]),
+    TechSignal("GraphQL", "pattern", keywords=["graphql"]),
+    TechSignal("WebSocket", "pattern", keywords=["websocket", "real-time", "realtime"]),
+    TechSignal("Microservices", "pattern", keywords=["microservice", "microservices"]),
+    TechSignal("Serverless", "pattern", keywords=["serverless", "lambda"]),
+    TechSignal("Authentication", "pattern", keywords=["auth", "authentication", "login", "jwt", "oauth"]),
+    TechSignal("E-commerce", "domain", keywords=["ecommerce", "e-commerce", "marketplace", "shop", "store"]),
+    TechSignal("SaaS", "domain", keywords=["saas", "software as a service"]),
+    TechSignal("Blog", "domain", keywords=["blog", "blogging", "cms"]),
+    TechSignal("Chat", "domain", keywords=["chat", "messaging", "instant message"]),
+    TechSignal("Social Network", "domain", keywords=["social", "social network", "social media"]),
+]
+
+
+@dataclass
+class AnalysisResult:
+    """Result of project analysis."""
+
+    description: str
+    detected_techs: list[TechSignal] = field(default_factory=list)
+    project_type: str = ""
+    requirements: list[str] = field(default_factory=list)
+
+    @property
+    def frameworks(self) -> list[TechSignal]:
+        return [t for t in self.detected_techs if t.category == "framework"]
+
+    @property
+    def databases(self) -> list[TechSignal]:
+        return [t for t in self.detected_techs if t.category == "database"]
+
+    @property
+    def frontends(self) -> list[TechSignal]:
+        return [t for t in self.detected_techs if t.category == "frontend"]
+
+    @property
+    def patterns(self) -> list[TechSignal]:
+        return [t for t in self.detected_techs if t.category == "pattern"]
+
+    @property
+    def all_tech_names(self) -> list[str]:
+        return [t.name for t in self.detected_techs]
+
+
+def analyze_input(text: str) -> AnalysisResult:
+    """Analyze user input and detect technologies mentioned."""
+    text_lower = text.lower()
+    detected: list[TechSignal] = []
+
+    for signal in TECH_PATTERNS:
+        for kw in signal.keywords:
+            if kw in text_lower:
+                detected.append(TechSignal(
+                    name=signal.name,
+                    category=signal.category,
+                    confidence=signal.confidence,
+                ))
+                break
+
+    # Infer project type
+    project_type = "general"
+    if any(t.category == "domain" for t in detected):
+        domain_techs = [t for t in detected if t.category == "domain"]
+        project_type = domain_techs[0].name.lower()
+    elif any(t.category == "pattern" for t in detected):
+        project_type = detected[0].name.lower()
+
+    # Infer requirements
+    requirements = []
+    if any(t.name == "Authentication" for t in detected):
+        requirements.append("user authentication and authorization")
+    if any(t.category == "database" for t in detected):
+        requirements.append("database design and persistence")
+    if any(t.category == "frontend" for t in detected):
+        requirements.append("frontend user interface")
+    if any(t.name == "Docker" for t in detected):
+        requirements.append("containerized deployment")
+    if any(t.name in ("Stripe",) for t in detected):
+        requirements.append("payment processing")
+    if any(t.name in ("WebSocket", "Chat") for t in detected):
+        requirements.append("real-time communication")
+
+    return AnalysisResult(
+        description=text,
+        detected_techs=detected,
+        project_type=project_type,
+        requirements=requirements,
+    )

devobin/core/executor.py

@@ -0,0 +1,244 @@
+"""Shell execution and file operations for DevObin AI."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ExecResult:
+    """Result of a shell command execution."""
+
+    command: str
+    stdout: str = ""
+    stderr: str = ""
+    return_code: int = 0
+    success: bool = True
+    timed_out: bool = False
+
+    @property
+    def output(self) -> str:
+        """Combined output for display."""
+        parts = []
+        if self.stdout.strip():
+            parts.append(self.stdout.strip())
+        if self.stderr.strip():
+            parts.append(f"[stderr]\n{self.stderr.strip()}")
+        if self.timed_out:
+            parts.append("[timed out after 30s]")
+        if not parts:
+            parts.append("(no output)")
+        return "\n".join(parts)
+
+
+@dataclass
+class FileResult:
+    """Result of a file operation."""
+
+    path: str
+    operation: str  # read, write, create, delete, list, exists
+    success: bool = True
+    content: str = ""
+    error: str = ""
+    files: list[str] = field(default_factory=list)
+    size: int = 0
+
+    @property
+    def output(self) -> str:
+        """Formatted output for display."""
+        if not self.success:
+            return f"[red]Error:[/] {self.error}"
+
+        if self.operation == "read":
+            lines = self.content.count("\n") + 1
+            return f"[dim]{self.path}[/] ({lines} lines, {self.size} bytes)\n\n{self.content}"
+
+        if self.operation in ("write", "create"):
+            return f"[green]✓[/] {self.operation.title()}: [bold]{self.path}[/] ({self.size} bytes)"
+
+        if self.operation == "delete":
+            return f"[green]✓[/] Deleted: [bold]{self.path}[/]"
+
+        if self.operation == "list":
+            if not self.files:
+                return f"[dim]No files in {self.path}[/]"
+            header = f"[bold]{self.path}[/] ({len(self.files)} items):"
+            items = "\n".join(f"  {'📁' if f.endswith('/') else '📄'} {f}" for f in self.files)
+            return f"{header}\n{items}"
+
+        if self.operation == "exists":
+            status = "[green]exists[/]" if self.success else "[red]not found[/]"
+            return f"{self.path}: {status}"
+
+        return ""
+
+
+class ShellExecutor:
+    """Execute shell commands safely."""
+
+    def __init__(self, cwd: str | Path | None = None) -> None:
+        self.cwd = str(cwd) if cwd else os.getcwd()
+        self.timeout = 30  # seconds
+
+    def run(self, command: str) -> ExecResult:
+        """Execute a shell command and return the result."""
+        if not command.strip():
+            return ExecResult(command=command, success=False, stderr="Empty command")
+
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+                cwd=self.cwd,
+                env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+            )
+            return ExecResult(
+                command=command,
+                stdout=result.stdout,
+                stderr=result.stderr,
+                return_code=result.returncode,
+                success=(result.returncode == 0),
+            )
+        except subprocess.TimeoutExpired:
+            return ExecResult(
+                command=command,
+                success=False,
+                timed_out=True,
+                stderr=f"Command timed out after {self.timeout}s",
+            )
+        except Exception as e:
+            return ExecResult(
+                command=command,
+                success=False,
+                stderr=str(e),
+            )
+
+
+class FileManager:
+    """Read, write, and manage files."""
+
+    def __init__(self, base_dir: str | Path | None = None) -> None:
+        self.base_dir = Path(base_dir) if base_dir else Path.cwd()
+
+    def _resolve(self, path: str) -> Path:
+        """Resolve path relative to base_dir, preventing escapes."""
+        p = Path(path)
+        if p.is_absolute():
+            return p.resolve()
+        return (self.base_dir / p).resolve()
+
+    def read(self, path: str, max_lines: int = 0) -> FileResult:
+        """Read a file's contents.
+
+        ``max_lines=0`` (default) reads the whole file — DevObin explores real
+        projects, so no artificial truncation. Pass a positive value only when a
+        short preview is explicitly wanted.
+        """
+        resolved = self._resolve(path)
+        if not resolved.exists():
+            return FileResult(path=str(resolved), operation="read", success=False,
+                              error=f"File not found: {resolved}")
+        if not resolved.is_file():
+            return FileResult(path=str(resolved), operation="read", success=False,
+                              error=f"Not a file: {resolved}")
+
+        try:
+            content = resolved.read_text(encoding="utf-8")
+            if max_lines and max_lines > 0:
+                lines = content.split("\n")
+                if len(lines) > max_lines:
+                    content = "\n".join(lines[:max_lines])
+                    content += f"\n\n... ({len(lines) - max_lines} more lines truncated)"
+            return FileResult(
+                path=str(resolved),
+                operation="read",
+                content=content,
+                size=resolved.stat().st_size,
+            )
+        except Exception as e:
+            return FileResult(path=str(resolved), operation="read", success=False, error=str(e))
+
+    def write(self, path: str, content: str, mkdir: bool = True) -> FileResult:
+        """Write content to a file, creating directories if needed."""
+        resolved = self._resolve(path)
+        try:
+            if mkdir:
+                resolved.parent.mkdir(parents=True, exist_ok=True)
+            resolved.write_text(content, encoding="utf-8")
+            return FileResult(
+                path=str(resolved),
+                operation="create" if not Path(path).exists() else "write",
+                size=len(content.encode("utf-8")),
+            )
+        except Exception as e:
+            return FileResult(path=str(resolved), operation="write", success=False, error=str(e))
+
+    def list_dir(self, path: str = ".") -> FileResult:
+        """List directory contents."""
+        resolved = self._resolve(path)
+        if not resolved.exists():
+            return FileResult(path=str(resolved), operation="list", success=False,
+                              error=f"Directory not found: {resolved}")
+        if not resolved.is_dir():
+            return FileResult(path=str(resolved), operation="list", success=False,
+                              error=f"Not a directory: {resolved}")
+
+        try:
+            entries = sorted(
+                (e.name + "/" if e.is_dir() else e.name)
+                for e in resolved.iterdir()
+                if not e.name.startswith(".")
+            )
+            return FileResult(path=str(resolved), operation="list", files=entries)
+        except Exception as e:
+            return FileResult(path=str(resolved), operation="list", success=False, error=str(e))
+
+    def exists(self, path: str) -> FileResult:
+        """Check if a file or directory exists."""
+        resolved = self._resolve(path)
+        return FileResult(
+            path=str(resolved),
+            operation="exists",
+            success=resolved.exists(),
+        )
+
+    def delete(self, path: str) -> FileResult:
+        """Delete a file."""
+        resolved = self._resolve(path)
+        if not resolved.exists():
+            return FileResult(path=str(resolved), operation="delete", success=False,
+                              error=f"Not found: {resolved}")
+        try:
+            if resolved.is_dir():
+                shutil.rmtree(resolved)
+            else:
+                resolved.unlink()
+            return FileResult(path=str(resolved), operation="delete")
+        except Exception as e:
+            return FileResult(path=str(resolved), operation="delete", success=False, error=str(e))
+
+
+# Singleton instances
+_shell: ShellExecutor | None = None
+_files: FileManager | None = None
+
+
+def get_executor(cwd: str | Path | None = None) -> ShellExecutor:
+    global _shell
+    if _shell is None or cwd is not None:
+        _shell = ShellExecutor(cwd)
+    return _shell
+
+
+def get_file_manager(base_dir: str | Path | None = None) -> FileManager:
+    global _files
+    if _files is None or base_dir is not None:
+        _files = FileManager(base_dir)
+    return _files