closecode 0.1.0__py3-none-any.whl

closecode/auth.py

@@ -0,0 +1,22 @@
+"""Close Code authentication — API key management."""
+
+from closecode.config import CloseCodeConfig, CLOSECODE_DIR
+
+
+def mask_key(key: str) -> str:
+    """Mask an API key for display (show first 4 + last 4)."""
+    if len(key) <= 10:
+        return "*" * len(key)
+    return key[:4] + "*" * (len(key) - 8) + key[-4:]
+
+
+def store_api_key(config: CloseCodeConfig, key: str):
+    """Store the API key in config."""
+    config.api_key = key
+    config.save()
+
+
+def clear_credentials(config: CloseCodeConfig):
+    """Remove stored credentials (logout)."""
+    config.api_key = ""
+    config.save()

closecode/config.py

@@ -0,0 +1,97 @@
+"""Close Code configuration management.
+
+Stores config at ~/.closecode/config.json.
+Supports environment variable overrides.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+# ── Paths ───────────────────────────────────────────────────────────────
+
+CLOSECODE_DIR = Path.home() / ".closecode"
+CONFIG_FILE = CLOSECODE_DIR / "config.json"
+SESSIONS_DIR = CLOSECODE_DIR / "sessions"
+LOGS_DIR = CLOSECODE_DIR / "logs"
+
+# Pre-rename location; migrated once on first run.
+_LEGACY_DIR = Path.home() / ".ovo"
+
+
+def _migrate_legacy_dir() -> None:
+    """Move ~/.ovo to ~/.closecode once, so upgrades keep their sessions."""
+    if CLOSECODE_DIR.exists() or not _LEGACY_DIR.is_dir():
+        return
+    try:
+        _LEGACY_DIR.rename(CLOSECODE_DIR)
+    except OSError:
+        pass
+
+
+class CloseCodeConfig(BaseModel):
+    """Application configuration."""
+
+    # LLMesh connection
+    api_url: str = Field(default="http://localhost:8087")
+    api_key: str = Field(default="")
+
+    # Defaults
+    default_mode: str = Field(default="build")
+    default_model: str = Field(default="")
+
+    # Current state (persisted across restarts)
+    current_mode: str = Field(default="build")
+    current_model: str = Field(default="")
+    current_provider: str = Field(default="")
+
+    # Behaviour
+    stream: bool = Field(default=True)
+    auto_fallback: bool = Field(default=True)
+    auto_compact: bool = Field(default=True)
+    show_usage: bool = Field(default=True)
+
+    # Context budget
+    system_budget: int = Field(default=10_000)
+    output_budget: int = Field(default=10_000)
+
+    # Tool approval
+    tool_approval_policy: str = Field(default="ask")  # ask | allow_safe | allow_all
+
+    model_config = {"protected_namespaces": ()}
+
+    @classmethod
+    def load(cls) -> "CloseCodeConfig":
+        """Load config from disk, with env var overrides."""
+        _migrate_legacy_dir()
+        config = cls()
+
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    data = json.load(f)
+                config = cls(**data)
+            except (json.JSONDecodeError, Exception):
+                pass
+
+        # Environment variable overrides
+        if url := os.environ.get("CLOSECODE_API_URL") or os.environ.get("LLMESH_API_URL"):
+            config.api_url = url
+        if key := os.environ.get("CLOSECODE_API_KEY") or os.environ.get("LLMESH_API_KEY"):
+            config.api_key = key
+
+        return config
+
+    def save(self):
+        """Persist config to disk."""
+        CLOSECODE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(self.model_dump(), f, indent=2)
+
+    def is_configured(self) -> bool:
+        """Whether Close Code has a stored API key."""
+        return bool(self.api_key)

closecode/llmesh/__init__.py

@@ -0,0 +1,91 @@
+"""Pydantic domain models for Close Code."""
+
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing import List
+
+
+class ModelStatus(Enum):
+    """Status of a model on the server."""
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    UNAVAILABLE = "unavailable"
+    RATE_LIMITED = "rate_limited"
+
+    @property
+    def icon(self) -> str:
+        return {
+            ModelStatus.ACTIVE: "●",
+            ModelStatus.INACTIVE: "○",
+            ModelStatus.UNAVAILABLE: "✗",
+            ModelStatus.RATE_LIMITED: "⚠",
+        }[self]
+
+    @property
+    def label(self) -> str:
+        return {
+            ModelStatus.ACTIVE: "Active",
+            ModelStatus.INACTIVE: "Inactive",
+            ModelStatus.UNAVAILABLE: "Unavailable",
+            ModelStatus.RATE_LIMITED: "Rate Limited",
+        }[self]
+
+    @property
+    def selectable(self) -> bool:
+        """Whether this model can be selected by the user."""
+        return self == ModelStatus.ACTIVE
+
+
+class ModelInfo(BaseModel):
+    """Information about an available LLM model."""
+    name: str = Field(description="Frontend display name")
+    backend_name: str = Field(default="")
+    provider: str = Field(default="")
+    server_url: str = Field(default="")
+    modes: List[str] = Field(default_factory=list)
+    capabilities: List[str] = Field(default_factory=list)
+    context_window: int = Field(default=0)
+    tool_support: bool = Field(default=False)
+    vision_support: bool = Field(default=False)
+    reasoning_support: bool = Field(default=False)
+    streaming_support: bool = Field(default=True)
+    status: bool = Field(default=True)
+    priority: int = Field(default=0)
+    weight: float = Field(default=1.0)
+
+    model_config = {"protected_namespaces": ()}
+
+    @property
+    def model_status(self) -> ModelStatus:
+        """Derive ModelStatus from the boolean status field."""
+        return ModelStatus.ACTIVE if self.status else ModelStatus.INACTIVE
+
+    @property
+    def display_name(self) -> str:
+        """Short display name — strip provider prefix for readability."""
+        name = self.name
+        # e.g. "openai/gpt-oss-20b:free" → "gpt-oss-20b (free)"
+        if "/" in name:
+            name = name.split("/", 1)[1]
+        if ":free" in name:
+            name = name.replace(":free", " (free)")
+        return name
+
+
+class ProviderInfo(BaseModel):
+    """Provider status."""
+    name: str
+    server_url: str = ""
+    healthy: bool = True
+    models: List[str] = Field(default_factory=list)
+
+
+class UsageInfo(BaseModel):
+    """Token usage for a request."""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    total_tokens: int = 0
+    model: str = ""
+    latency_ms: float = 0
+
+    model_config = {"protected_namespaces": ()}

closecode/llmesh/client.py

@@ -0,0 +1,221 @@
+"""LLMesh API client for Close Code.
+
+Talks only to the LLMesh gateway. Never contacts upstream providers directly.
+All provider authentication is handled server-side.
+"""
+
+import json
+import time
+from typing import Optional, Dict, List, Any, AsyncIterator
+
+import httpx
+
+from closecode.llmesh import ModelInfo, ProviderInfo, UsageInfo
+from closecode.llmesh.streaming import parse_sse_stream, StreamError
+
+
+class APIError(Exception):
+    """Raised when the LLMesh API returns an error."""
+    def __init__(self, message: str, status_code: int = 0):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class LLMeshClient:
+    """Async HTTP client for the LLMesh API."""
+
+    def __init__(self, base_url: str = "http://localhost:8087", api_key: str = ""):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self._client: Optional[httpx.AsyncClient] = None
+
+    def _get_headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    async def _ensure_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                timeout=httpx.Timeout(connect=10.0, read=300.0, write=10.0, pool=10.0),
+                headers=self._get_headers(),
+            )
+        return self._client
+
+    async def close(self):
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+
+    # ── Health ──────────────────────────────────────────────────────
+
+    async def verify_connection(self) -> bool:
+        """Verify the LLMesh gateway is reachable and the API key is valid."""
+        client = await self._ensure_client()
+        try:
+            resp = await client.get(f"{self.base_url}/v1/models", timeout=5.0)
+            return resp.status_code == 200
+        except httpx.HTTPError:
+            return False
+
+    async def health_check(self) -> bool:
+        """Quick health check."""
+        return await self.verify_connection()
+
+    # ── Models ──────────────────────────────────────────────────────
+
+    async def list_models(self) -> List[ModelInfo]:
+        """Fetch models from LLMesh.
+
+        Prefers /api/cli/models, which returns every configured model with its
+        real admin-set status and full metadata — including models the admin has
+        disabled, so they can be shown as unavailable rather than vanishing.
+
+        Falls back to the OpenAI-compatible /v1/models, which by design lists
+        only active models, for gateways that predate the CLI endpoint.
+        """
+        client = await self._ensure_client()
+
+        # Preferred: rich metadata, includes disabled models.
+        try:
+            resp = await client.get(f"{self.base_url}/api/cli/models")
+            if resp.status_code == 200:
+                data = resp.json()
+                models = [
+                    ModelInfo(
+                        name=m.get("name", ""),
+                        backend_name=m.get("backend_name", "") or m.get("name", ""),
+                        provider=m.get("provider", ""),
+                        server_url=m.get("server_url", ""),
+                        modes=m.get("modes") or [],
+                        capabilities=m.get("capabilities") or [],
+                        context_window=m.get("context_window") or 0,
+                        tool_support=bool(m.get("tool_support", False)),
+                        vision_support=bool(m.get("vision_support", False)),
+                        reasoning_support=bool(m.get("reasoning_support", False)),
+                        streaming_support=bool(m.get("streaming_support", True)),
+                        status=bool(m.get("status", True)),
+                        priority=m.get("priority") or 0,
+                        weight=m.get("weight") or 1.0,
+                    )
+                    for m in data.get("models", [])
+                    if m.get("name")
+                ]
+                if models:
+                    return models
+        except (httpx.HTTPError, json.JSONDecodeError, ValueError):
+            pass
+
+        # Fallback: OpenAI-compatible endpoint (active models only).
+        try:
+            resp = await client.get(f"{self.base_url}/v1/models")
+            if resp.status_code == 200:
+                data = resp.json()
+                models = []
+                for m in data.get("data", []):
+                    model_id = m.get("id", "")
+                    provider = m.get("owned_by", "")
+                    models.append(ModelInfo(
+                        name=model_id,
+                        backend_name=model_id,
+                        provider=provider,
+                        status=True,  # This endpoint only returns active models
+                    ))
+                return models
+        except (httpx.HTTPError, json.JSONDecodeError):
+            pass
+
+        return []
+
+    async def list_providers(self) -> List[ProviderInfo]:
+        """Fetch provider info."""
+        client = await self._ensure_client()
+        try:
+            resp = await client.get(f"{self.base_url}/api/cli/providers")
+            if resp.status_code == 200:
+                data = resp.json()
+                return [ProviderInfo(**p) for p in data.get("providers", [])]
+        except (httpx.HTTPError, json.JSONDecodeError):
+            pass
+        return []
+
+    # ── Chat ────────────────────────────────────────────────────────
+
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, str]],
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+    ) -> AsyncIterator[str]:
+        """Send a streaming chat completion request. Yields content tokens."""
+        client = await self._ensure_client()
+        payload: Dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+            "stream_options": {"include_usage": True},
+            "temperature": temperature,
+        }
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        async with client.stream(
+            "POST",
+            f"{self.base_url}/v1/chat/completions",
+            json=payload,
+            timeout=httpx.Timeout(connect=10.0, read=300.0, write=10.0, pool=10.0),
+        ) as response:
+            if response.status_code != 200:
+                body = await response.aread()
+                raise APIError(
+                    f"Server returned {response.status_code}: {body.decode()}",
+                    response.status_code,
+                )
+            async for token in parse_sse_stream(response):
+                yield token
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Send a non-streaming chat completion. Returns full response."""
+        client = await self._ensure_client()
+        payload: Dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "stream": False,
+            "temperature": temperature,
+        }
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        start = time.time()
+        resp = await client.post(f"{self.base_url}/v1/chat/completions", json=payload)
+
+        if resp.status_code != 200:
+            raise APIError(f"Server returned {resp.status_code}: {resp.text}", resp.status_code)
+
+        data = resp.json()
+        latency_ms = (time.time() - start) * 1000
+        usage = data.get("usage", {})
+
+        content = ""
+        choices = data.get("choices", [])
+        if choices:
+            content = choices[0].get("message", {}).get("content", "")
+
+        return {
+            "content": content,
+            "usage": UsageInfo(
+                input_tokens=usage.get("prompt_tokens", 0),
+                output_tokens=usage.get("completion_tokens", 0),
+                total_tokens=usage.get("total_tokens", 0),
+                model=model,
+                latency_ms=latency_ms,
+            ),
+        }

closecode/llmesh/streaming.py

@@ -0,0 +1,47 @@
+"""SSE stream parser for OpenAI-compatible streaming responses."""
+
+import json
+from typing import AsyncIterator
+
+import httpx
+
+
+async def parse_sse_stream(response: httpx.Response) -> AsyncIterator[str]:
+    """Parse an SSE stream and yield content tokens.
+
+    Handles the standard OpenAI streaming format:
+        data: {"choices": [{"delta": {"content": "token"}}]}
+        data: [DONE]
+    """
+    async for line in response.aiter_lines():
+        if not line.startswith("data: "):
+            continue
+
+        payload = line[6:].strip()
+
+        if payload == "[DONE]":
+            break
+
+        try:
+            chunk = json.loads(payload)
+        except json.JSONDecodeError:
+            continue
+
+        # Check for error responses
+        if "error" in chunk:
+            error_msg = chunk["error"].get("message", "Unknown error")
+            raise StreamError(error_msg)
+
+        choices = chunk.get("choices", [])
+        if not choices:
+            continue
+
+        delta = choices[0].get("delta", {})
+        content = delta.get("content", "")
+        if content:
+            yield content
+
+
+class StreamError(Exception):
+    """Raised when the SSE stream contains an error."""
+    pass

closecode/sessions.py

@@ -0,0 +1,176 @@
+"""Close Code Session Manager — local-only session persistence.
+
+Sessions are stored as JSON files in ~/.closecode/sessions/.
+Nothing is sent to the server. Only conversation content and model name are persisted.
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional
+from dataclasses import dataclass, field, asdict
+
+from closecode.config import SESSIONS_DIR
+
+
+@dataclass
+class SessionMessage:
+    """A single message in a session."""
+    role: str
+    content: str
+    timestamp: str = ""
+    model: str = ""
+
+    def __post_init__(self):
+        if not self.timestamp:
+            self.timestamp = datetime.now(timezone.utc).isoformat()
+
+
+@dataclass
+class Session:
+    """A saved conversation session."""
+    id: str = ""
+    title: str = "New session"
+    model: str = ""
+    created_at: str = ""
+    updated_at: str = ""
+    messages: List[SessionMessage] = field(default_factory=list)
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = uuid.uuid4().hex[:12]
+        now = datetime.now(timezone.utc).isoformat()
+        if not self.created_at:
+            self.created_at = now
+        if not self.updated_at:
+            self.updated_at = now
+
+    @property
+    def message_count(self) -> int:
+        return len(self.messages)
+
+    @property
+    def preview(self) -> str:
+        """First user message as a preview, truncated."""
+        for msg in self.messages:
+            if msg.role == "user":
+                text = msg.content.strip().replace("\n", " ")
+                return text[:60] + ("…" if len(text) > 60 else "")
+        return "Empty session"
+
+    @property
+    def age_label(self) -> str:
+        """Human-readable age like '2 hours ago'."""
+        try:
+            updated = datetime.fromisoformat(self.updated_at)
+            now = datetime.now(timezone.utc)
+            delta = now - updated
+            seconds = delta.total_seconds()
+
+            if seconds < 60:
+                return "just now"
+            elif seconds < 3600:
+                mins = int(seconds // 60)
+                return f"{mins}m ago"
+            elif seconds < 86400:
+                hours = int(seconds // 3600)
+                return f"{hours}h ago"
+            elif seconds < 604800:
+                days = int(seconds // 86400)
+                return f"{days}d ago"
+            else:
+                return updated.strftime("%b %d")
+        except Exception:
+            return ""
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "model": self.model,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "messages": [asdict(m) for m in self.messages],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Session:
+        msgs = [SessionMessage(**m) for m in data.get("messages", [])]
+        return cls(
+            id=data.get("id", ""),
+            title=data.get("title", "New session"),
+            model=data.get("model", ""),
+            created_at=data.get("created_at", ""),
+            updated_at=data.get("updated_at", ""),
+            messages=msgs,
+        )
+
+
+class SessionManager:
+    """Manages local session files in ~/.closecode/sessions/."""
+
+    def __init__(self, sessions_dir: Optional[Path] = None):
+        self.sessions_dir = sessions_dir or SESSIONS_DIR
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, session_id: str) -> Path:
+        return self.sessions_dir / f"{session_id}.json"
+
+    def create(self, model: str = "", title: str = "") -> Session:
+        """Create a new session."""
+        return Session(model=model, title=title or "New session")
+
+    def save(self, session: Session) -> None:
+        """Save a session to disk."""
+        session.updated_at = datetime.now(timezone.utc).isoformat()
+        path = self._path(session.id)
+        with open(path, "w") as f:
+            json.dump(session.to_dict(), f, indent=2)
+
+    def load(self, session_id: str) -> Optional[Session]:
+        """Load a session from disk."""
+        path = self._path(session_id)
+        if not path.exists():
+            return None
+        try:
+            with open(path) as f:
+                data = json.load(f)
+            return Session.from_dict(data)
+        except (json.JSONDecodeError, Exception):
+            return None
+
+    def list_sessions(self, limit: int = 20) -> List[Session]:
+        """List all sessions, sorted by most recently updated."""
+        sessions = []
+        for path in self.sessions_dir.glob("*.json"):
+            try:
+                with open(path) as f:
+                    data = json.load(f)
+                sessions.append(Session.from_dict(data))
+            except (json.JSONDecodeError, Exception):
+                continue
+
+        sessions.sort(key=lambda s: s.updated_at, reverse=True)
+        return sessions[:limit]
+
+    def delete(self, session_id: str) -> bool:
+        """Delete a session file."""
+        path = self._path(session_id)
+        if path.exists():
+            path.unlink()
+            return True
+        return False
+
+    @staticmethod
+    def auto_title(messages: List[SessionMessage]) -> str:
+        """Generate a title from the first user message."""
+        for msg in messages:
+            if msg.role == "user":
+                text = msg.content.strip().replace("\n", " ")
+                if len(text) > 50:
+                    return text[:47] + "…"
+                return text
+        return "New session"

closecode/ui/__init__.py

@@ -0,0 +1 @@
+"""Close Code UI package."""

closecode/ui/screens/__init__.py

@@ -0,0 +1 @@
+"""Close Code UI screens package."""