devobin 1.0.0__py3-none-any.whl

devobin/providers/anthropic_provider.py

@@ -0,0 +1,72 @@
+"""Anthropic Claude provider."""
+
+from __future__ import annotations
+
+from typing import AsyncIterator
+
+from anthropic import AsyncAnthropic
+
+from devobin.providers import AIProvider
+
+
+class AnthropicProvider(AIProvider):
+    name = "anthropic"
+
+    def __init__(self, config: dict) -> None:
+        super().__init__(config)
+        self._client = AsyncAnthropic(api_key=self.api_key)
+
+    async def chat(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> str:
+        kwargs: dict = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if system:
+            kwargs["system"] = system
+
+        response = await self._client.messages.create(**kwargs)
+        return response.content[0].text if response.content else ""
+
+    async def chat_stream(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> AsyncIterator[str]:
+        kwargs: dict = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if system:
+            kwargs["system"] = system
+
+        async with self._client.messages.stream(**kwargs) as stream:
+            async for text in stream.text_stream:
+                yield text
+
+    async def validate_connection(self) -> bool:
+        try:
+            await self.chat([{"role": "user", "content": "hi"}], max_tokens=5)
+            return True
+        except Exception:
+            return self.api_key != ""
+
+    def available_models(self) -> list[str]:
+        return [
+            "claude-opus-4-20250514",
+            "claude-sonnet-4-20250514",
+            "claude-3-5-haiku-20241022",
+            "claude-3-5-sonnet-20241022",
+            "claude-3-opus-20240229",
+        ]

devobin/providers/google_provider.py

@@ -0,0 +1,90 @@
+"""Google Gemini provider."""
+
+from __future__ import annotations
+
+from typing import AsyncIterator
+
+from google import genai
+from google.genai import types
+
+from devobin.providers import AIProvider
+
+
+class GoogleProvider(AIProvider):
+    name = "google"
+
+    def __init__(self, config: dict) -> None:
+        super().__init__(config)
+        self._client = genai.Client(api_key=self.api_key)
+
+    async def chat(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> str:
+        contents = []
+        if system:
+            contents.append(types.Content(role="user", parts=[types.Part(text=system)]))
+            contents.append(types.Content(role="model", parts=[types.Part(text="Understood.")]))
+
+        for m in messages:
+            role = "user" if m["role"] == "user" else "model"
+            contents.append(types.Content(role=role, parts=[types.Part(text=m["content"])]))
+
+        response = await self._client.aio.models.generate_content(
+            model=self.model,
+            contents=contents,
+            config=types.GenerateContentConfig(
+                temperature=temperature,
+                max_output_tokens=max_tokens,
+            ),
+        )
+        return response.text or ""
+
+    async def chat_stream(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> AsyncIterator[str]:
+        contents = []
+        if system:
+            contents.append(types.Content(role="user", parts=[types.Part(text=system)]))
+            contents.append(types.Content(role="model", parts=[types.Part(text="Understood.")]))
+
+        for m in messages:
+            role = "user" if m["role"] == "user" else "model"
+            contents.append(types.Content(role=role, parts=[types.Part(text=m["content"])]))
+
+        async for chunk in self._client.aio.models.generate_content_stream(
+            model=self.model,
+            contents=contents,
+            config=types.GenerateContentConfig(
+                temperature=temperature,
+                max_output_tokens=max_tokens,
+            ),
+        ):
+            if chunk.text:
+                yield chunk.text
+
+    async def validate_connection(self) -> bool:
+        try:
+            await self._client.aio.models.generate_content(
+                model=self.model,
+                contents="hi",
+                config=types.GenerateContentConfig(max_output_tokens=5),
+            )
+            return True
+        except Exception:
+            return self.api_key != ""
+
+    def available_models(self) -> list[str]:
+        return [
+            "gemini-2.0-flash",
+            "gemini-1.5-pro",
+            "gemini-1.5-flash",
+            "gemini-1.0-pro",
+        ]

devobin/providers/ollama_provider.py

@@ -0,0 +1,81 @@
+"""Ollama local model provider."""
+
+from __future__ import annotations
+
+from typing import AsyncIterator
+
+import httpx
+
+from devobin.providers import AIProvider
+
+
+class OllamaProvider(AIProvider):
+    name = "ollama"
+
+    def __init__(self, config: dict) -> None:
+        super().__init__(config)
+        self.base_url = config.get("base_url", "http://localhost:11434")
+        self._client = httpx.AsyncClient(base_url=self.base_url, timeout=120.0)
+
+    async def chat(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> str:
+        payload: dict = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        if system:
+            payload["system"] = system
+
+        response = await self._client.post("/api/chat", json=payload)
+        response.raise_for_status()
+        data = response.json()
+        return data.get("message", {}).get("content", "")
+
+    async def chat_stream(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> AsyncIterator[str]:
+        payload: dict = {
+            "model": self.model,
+            "messages": messages,
+            "stream": True,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        if system:
+            payload["system"] = system
+
+        async with self._client.stream("POST", "/api/chat", json=payload) as response:
+            response.raise_for_status()
+            async for line in response.aiter_lines():
+                if line:
+                    import json
+                    data = json.loads(line)
+                    content = data.get("message", {}).get("content", "")
+                    if content:
+                        yield content
+
+    async def validate_connection(self) -> bool:
+        try:
+            resp = await self._client.get("/api/tags")
+            return resp.status_code == 200
+        except Exception:
+            return False
+
+    def available_models(self) -> list[str]:
+        try:
+            import json
+            resp = httpx.get(f"{self.base_url}/api/tags", timeout=5.0)
+            data = resp.json()
+            return [m["name"] for m in data.get("models", [])]
+        except Exception:
+            return ["llama3", "codellama", "mistral", "gemma"]

devobin/providers/openai_provider.py

@@ -0,0 +1,102 @@
+"""OpenAI and OpenAI-compatible API provider."""
+
+from __future__ import annotations
+
+from typing import AsyncIterator
+
+from openai import AsyncOpenAI
+
+from devobin.providers import AIProvider
+
+
+class OpenAIProvider(AIProvider):
+    name = "openai"
+
+    def __init__(self, config: dict) -> None:
+        super().__init__(config)
+        base = config.get("base_url") or "https://api.openai.com/v1"
+        self._client = AsyncOpenAI(api_key=self.api_key, base_url=base)
+
+    async def chat(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> str:
+        full_messages = []
+        if system:
+            full_messages.append({"role": "system", "content": system})
+        full_messages.extend(messages)
+
+        response = await self._client.chat.completions.create(
+            model=self.model,
+            messages=full_messages,  # type: ignore[arg-type]
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        if not response.choices:
+            return ""
+        return response.choices[0].message.content or ""
+
+    async def chat_stream(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> AsyncIterator[str]:
+        full_messages = []
+        if system:
+            full_messages.append({"role": "system", "content": system})
+        full_messages.extend(messages)
+
+        stream = await self._client.chat.completions.create(
+            model=self.model,
+            messages=full_messages,  # type: ignore[arg-type]
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=True,
+        )
+        async for chunk in stream:
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta
+            if delta and delta.content:
+                yield delta.content
+
+    async def validate_connection(self) -> bool:
+        try:
+            await self._client.models.list()
+            return True
+        except Exception:
+            return self.api_key != ""
+
+    def available_models(self) -> list[str]:
+        import httpx
+
+        base = self.config.get("base_url") or "https://api.openai.com/v1"
+
+        # For OpenAI official API, return known models
+        if "api.openai.com" in base:
+            return [
+                "gpt-4o",
+                "gpt-4o-mini",
+                "gpt-4-turbo",
+                "gpt-4",
+                "gpt-3.5-turbo",
+                "o1",
+                "o1-mini",
+                "o1-pro",
+            ]
+
+        # For compatible APIs, fetch models from the endpoint
+        try:
+            headers = {"Authorization": f"Bearer {self.api_key}"} if self.api_key else {}
+            resp = httpx.get(f"{base}/models", headers=headers, timeout=10.0)
+            resp.raise_for_status()
+            data = resp.json()
+            models = [m["id"] for m in data.get("data", [])]
+            return models if models else ["default"]
+        except Exception:
+            return ["default"]

devobin/storage/__init__.py

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

devobin/storage/database.py

@@ -0,0 +1,207 @@
+"""Local storage for projects, history, and memories."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from devobin.config.settings import get_config
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class ProjectStorage:
+    """Per-project persistent storage (memory, sessions, prompts).
+
+    Data lives in .devobin/ inside the current working directory so the user
+    can find everything where they launched the CLI.
+
+    Sessions: each chat conversation is a separate JSON file in sessions/.
+    """
+
+    def __init__(self, project_name: str) -> None:
+        from devobin.config.settings import local_data_dir
+        self.name = project_name
+        self._dir = local_data_dir() / "projects" / project_name
+        self._dir.mkdir(parents=True, exist_ok=True)
+        self._memory_path = self._dir / "memory.json"
+        self._meta_path = self._dir / "meta.json"
+        self._sessions_dir = self._dir / "sessions"
+        self._sessions_dir.mkdir(parents=True, exist_ok=True)
+        self._memory: list[dict[str, Any]] = self._load_list(self._memory_path)
+        self._meta: dict[str, Any] = self._load_dict(self._meta_path)
+        self._current_session_id: str | None = None
+        self._current_session: list[dict[str, Any]] = []
+
+    # ── I/O helpers ───────────────────────────────────────────────
+
+    def _load_list(self, path: Path) -> list[dict[str, Any]]:
+        if path.exists():
+            return json.loads(path.read_text(encoding="utf-8"))
+        return []
+
+    def _load_dict(self, path: Path) -> dict[str, Any]:
+        if path.exists():
+            return json.loads(path.read_text(encoding="utf-8"))
+        return {}
+
+    def _save_list(self, path: Path, data: list[dict[str, Any]]) -> None:
+        path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    def _save_dict(self, path: Path, data: dict[str, Any]) -> None:
+        path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    # ── Memory ────────────────────────────────────────────────────
+
+    def add_memory(self, content: str, category: str = "general") -> dict[str, Any]:
+        entry = {
+            "id": uuid.uuid4().hex[:8],
+            "content": content,
+            "category": category,
+            "created_at": _now_iso(),
+        }
+        self._memory.append(entry)
+        self._save_list(self._memory_path, self._memory)
+        return entry
+
+    def get_memories(self, category: str | None = None) -> list[dict[str, Any]]:
+        if category:
+            return [m for m in self._memory if m.get("category") == category]
+        return list(self._memory)
+
+    def search_memories(self, query: str) -> list[dict[str, Any]]:
+        q = query.lower()
+        return [m for m in self._memory if q in m.get("content", "").lower()]
+
+    def clear_memories(self) -> None:
+        self._memory.clear()
+        self._save_list(self._memory_path, self._memory)
+
+    # ── Sessions (each chat = separate file) ──────────────────────
+
+    def new_session(self) -> str:
+        """Create a new session and return its ID."""
+        sid = _now_iso().replace(":", "-").replace(".", "-")[:19]
+        self._current_session_id = sid
+        self._current_session = []
+        self._save_session()
+        return sid
+
+    def _session_path(self, sid: str) -> Path:
+        return self._sessions_dir / f"{sid}.json"
+
+    def _save_session(self) -> None:
+        if self._current_session_id:
+            path = self._session_path(self._current_session_id)
+            data = {
+                "id": self._current_session_id,
+                "messages": self._current_session,
+            }
+            path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    def add_message(self, role: str, content: str) -> dict[str, Any]:
+        entry = {
+            "id": uuid.uuid4().hex[:8],
+            "role": role,
+            "content": content,
+            "timestamp": _now_iso(),
+        }
+        if self._current_session_id is None:
+            self.new_session()
+        self._current_session.append(entry)
+        self._save_session()
+        return entry
+
+    def get_history(self, limit: int = 50) -> list[dict[str, Any]]:
+        return self._current_session[-limit:]
+
+    def clear_history(self) -> None:
+        self._current_session.clear()
+        self._save_session()
+
+    def get_context_messages(self, max_messages: int = 20) -> list[dict[str, str]]:
+        recent = self._current_session[-max_messages:]
+        return [{"role": m["role"], "content": m["content"]} for m in recent]
+
+    def list_sessions(self) -> list[dict[str, Any]]:
+        """List all sessions for this project."""
+        sessions = []
+        for f in sorted(self._sessions_dir.glob("*.json"), reverse=True):
+            try:
+                data = json.loads(f.read_text(encoding="utf-8"))
+                msgs = data.get("messages", [])
+                if msgs:
+                    first_user = next(
+                        (m["content"][:60] for m in msgs if m.get("role") == "user"),
+                        "(empty)"
+                    )
+                    sessions.append({
+                        "id": data.get("id", f.stem),
+                        "count": len(msgs),
+                        "preview": first_user,
+                        "messages": msgs,
+                    })
+            except Exception:
+                continue
+        return sessions
+
+    # ── Meta ──────────────────────────────────────────────────────
+
+    def set_meta(self, key: str, value: Any) -> None:
+        self._meta[key] = value
+        self._save_dict(self._meta_path, self._meta)
+
+    def get_meta(self, key: str, default: Any = None) -> Any:
+        return self._meta.get(key, default)
+
+    @property
+    def created_at(self) -> str:
+        return self._meta.get("created_at", _now_iso())
+
+
+class GlobalStorage:
+    """Global storage for user-level memory and preferences."""
+
+    def __init__(self) -> None:
+        self._dir = get_config().projects_dir().parent
+        self._memory_path = get_config()._settings_path.parent / "global_memory.json"
+        self._memory: list[dict[str, Any]] = self._load()
+
+    def _load(self) -> list[dict[str, Any]]:
+        if self._memory_path.exists():
+            return json.loads(self._memory_path.read_text(encoding="utf-8"))
+        return []
+
+    def _save(self) -> None:
+        self._memory_path.write_text(
+            json.dumps(self._memory, indent=2, ensure_ascii=False), encoding="utf-8"
+        )
+
+    def add_memory(self, content: str, category: str = "preference") -> dict[str, Any]:
+        entry = {
+            "id": uuid.uuid4().hex[:8],
+            "content": content,
+            "category": category,
+            "created_at": _now_iso(),
+        }
+        self._memory.append(entry)
+        self._save()
+        return entry
+
+    def get_memories(self, category: str | None = None) -> list[dict[str, Any]]:
+        if category:
+            return [m for m in self._memory if m.get("category") == category]
+        return list(self._memory)
+
+    def search_memories(self, query: str) -> list[dict[str, Any]]:
+        q = query.lower()
+        return [m for m in self._memory if q in m.get("content", "").lower()]
+
+    def clear_memories(self) -> None:
+        self._memory.clear()
+        self._save()

devobin/ui/__init__.py

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

devobin/ui/ask_modal.py

@@ -0,0 +1,96 @@
+"""Interactive question modal — lets the AI ask the user for clarification or permission."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, Input, Button
+from textual.containers import Vertical
+from textual.binding import Binding
+from textual import on
+from rich.markup import escape
+
+
+class AskModal(ModalScreen[str | None]):
+    """Modal that shows an AI question and returns the user's answer.
+
+    Used when the model needs clarification or permission to read a file.
+    """
+
+    CSS = """
+    AskModal {
+        align: center middle;
+    }
+    #ask-container {
+        width: 60;
+        max-height: 30;
+        background: $surface;
+        border: tall $primary;
+        padding: 2;
+    }
+    #ask-title {
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+    #ask-question {
+        height: auto;
+        max-height: 15;
+        overflow-y: auto;
+        margin-bottom: 1;
+        color: $text;
+    }
+    #ask-input {
+        width: 100%;
+        background: #161b22;
+        color: #e6edf3;
+        border: round #2b3440;
+        padding: 0 1;
+    }
+    #ask-input:focus { border: round #00d4aa; }
+    #ask-buttons {
+        height: auto;
+        margin-top: 1;
+    }
+    #ask-buttons Button {
+        margin: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+    ]
+
+    def __init__(self, question: str, title: str = "DevObin asks") -> None:
+        super().__init__()
+        self._question = question
+        self._title = title
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="ask-container"):
+            yield Static(self._title, id="ask-title")
+            yield Static(escape(self._question), id="ask-question")
+            yield Input(placeholder="Your answer…", id="ask-input")
+            with Vertical(id="ask-buttons"):
+                yield Button("Send", id="ask-send", variant="primary")
+                yield Button("Skip", id="ask-skip", variant="default")
+
+    def on_mount(self) -> None:
+        self.query_one("#ask-input", Input).focus()
+
+    @on(Input.Submitted, "#ask-input")
+    def on_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value.strip() or None)
+
+    @on(Button.Pressed, "#ask-send")
+    def on_send_pressed(self) -> None:
+        value = self.query_one("#ask-input", Input).value.strip()
+        self.dismiss(value or None)
+
+    @on(Button.Pressed, "#ask-skip")
+    def on_skip_pressed(self) -> None:
+        self.dismiss(None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)