forgeoptimizer 0.1.0__py3-none-any.whl

forgecli/providers/http_base.py

@@ -0,0 +1,207 @@
+"""Async HTTP base class shared by real providers.
+
+A minimal :class:`HTTPChatProvider` that:
+
+* lazily resolves an API key from configuration;
+* exposes a typed :class:`httpx.AsyncClient` with sane timeouts;
+* logs request/response lifecycle through the standard :mod:`logging`.
+
+Subclasses implement :meth:`_format_request` and :meth:`_parse_response`
+to translate between the provider's wire format and ForgeCLI's
+provider-agnostic dataclasses.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable
+from typing import Any
+
+import httpx
+
+from forgecli.core.errors import ProviderError
+from forgecli.providers.base import (
+    ChatMessage,
+    ChatRequest,
+    ChatResponse,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    ModelInfo,
+    Provider,
+    Role,
+)
+
+
+class HTTPChatProvider(Provider[Any]):
+    """Base class for providers that talk JSON over HTTP."""
+
+    name = "abstract-http"
+
+    def __init__(
+        self,
+        config: Any,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 60.0,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        super().__init__(config)
+        self._api_key = api_key or self._resolve_api_key()
+        self._base_url = (
+            base_url or getattr(config, "base_url", None) or self._default_base_url()
+        ).rstrip("/")
+        self._timeout = timeout
+        self._client = client or httpx.AsyncClient(timeout=timeout)
+
+    # ------------------------------------------------------------------
+    # Subclass extension points
+    # ------------------------------------------------------------------
+
+    def _default_base_url(self) -> str:
+        raise NotImplementedError
+
+    def _resolve_api_key(self) -> str | None:
+        env_var = getattr(self.config, "api_key_env", None)
+        if env_var:
+            env_val = os.environ.get(env_var)
+            if env_val:
+                return env_val
+        from forgecli.core.credentials import get_api_key
+
+        # Check secure storage using provider name
+        val = get_api_key(self.name)
+        if val:
+            return val
+        if self.name == "google":
+            val = get_api_key("google") or get_api_key("gemini")
+            if val:
+                return val
+        return None
+
+    def _format_request(self, request: ChatRequest) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def _parse_response(self, payload: dict[str, Any]) -> ChatResponse:
+        raise NotImplementedError
+
+    def _embeddings_url(self) -> str:  # pragma: no cover - optional
+        raise NotImplementedError
+
+    def _format_embeddings(self, request: EmbeddingRequest) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def _parse_embeddings(self, payload: dict[str, Any]) -> EmbeddingResponse:
+        raise NotImplementedError
+
+    def _default_embedding_model(self) -> str:  # pragma: no cover - optional
+        raise NotImplementedError
+
+    def _auth_headers(self) -> dict[str, str]:
+        if not self._api_key:
+            return {}
+        return {"Authorization": f"Bearer {self._api_key}"}
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def aclose(self) -> None:
+        if self._client is not None:
+            await self._client.aclose()
+
+    def validate(self) -> None:
+        if not self._api_key:
+            env_var = getattr(self.config, "api_key_env", "API_KEY")
+            raise ProviderError(
+                f"{self.name}: missing API key. Set the {env_var} environment variable."
+            )
+
+    # ------------------------------------------------------------------
+    # Provider surface
+    # ------------------------------------------------------------------
+
+    async def chat(self, request: ChatRequest) -> ChatResponse:
+        if not self._api_key:
+            self.validate()
+        body = self._format_request(request)
+        response = await self._client.post(
+            self._chat_url_for(request), json=body, headers=self._auth_headers()
+        )
+        if response.status_code >= 400:
+            raise ProviderError(
+                f"{self.name} chat failed ({response.status_code}): {response.text[:500]}"
+            )
+        return self._parse_response(response.json())
+
+    async def embed(self, request: EmbeddingRequest) -> EmbeddingResponse:
+        if not self._api_key:
+            self.validate()
+        body = self._format_embeddings(request)
+        response = await self._client.post(
+            self._embeddings_url(), json=body, headers=self._auth_headers()
+        )
+        if response.status_code >= 400:
+            raise ProviderError(
+                f"{self.name} embed failed ({response.status_code}): {response.text[:500]}"
+            )
+        return self._parse_embeddings(response.json())
+
+    async def list_models(self) -> list[ModelInfo]:
+        try:
+            # Skip for mock provider
+            if self.name == "mock":
+                return self._known_models()
+            response = await self._client.get(
+                f"{self._base_url}/models", headers=self._auth_headers(), timeout=5.0
+            )
+            if response.status_code == 200:
+                data = response.json()
+                models_list = data.get("data", [])
+                if models_list:
+                    return [
+                        ModelInfo(
+                            id=str(m["id"]),
+                            name=str(m.get("id")),
+                            context_window=128_000,
+                            supports_tools=True,
+                            supports_vision=True,
+                        )
+                        for m in models_list
+                        if isinstance(m, dict) and m.get("id") is not None
+                    ]
+        except Exception:
+            pass
+        return self._known_models()
+
+    def _known_models(self) -> list[ModelInfo]:
+        return []
+
+    def _chat_url(self) -> str:
+        """Default chat URL; providers may override :meth:`_chat_url_for`."""
+        raise NotImplementedError
+
+    def _chat_url_for(self, request: ChatRequest) -> str:
+        """Return the chat URL for ``request``; default is the static URL."""
+        return self._chat_url()
+
+
+# ---------------------------------------------------------------------------
+# Wire-format helpers
+# ---------------------------------------------------------------------------
+
+
+def messages_to_openai(messages: Iterable[ChatMessage]) -> list[dict[str, Any]]:
+    """Translate :class:`ChatMessage` objects into the OpenAI schema."""
+    out: list[dict[str, Any]] = []
+    for message in messages:
+        entry: dict[str, Any] = {"role": message.role.value, "content": message.content}
+        if message.name:
+            entry["name"] = message.name
+        if message.role is Role.TOOL and message.tool_call_id:
+            entry["tool_call_id"] = message.tool_call_id
+        out.append(entry)
+    return out
+
+
+__all__ = ["HTTPChatProvider", "messages_to_openai"]

forgecli/providers/mock.py

@@ -0,0 +1,111 @@
+"""A deterministic provider used in tests and offline development."""
+
+from __future__ import annotations
+
+import hashlib
+from typing import ClassVar
+
+from forgecli.providers.base import (
+    ChatMessage,
+    ChatRequest,
+    ChatResponse,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    ModelInfo,
+    Provider,
+    Role,
+    StreamChunk,
+)
+from forgecli.providers.conversation import (
+    greeting_reply,
+    is_greeting,
+    offline_build_notice,
+)
+
+
+class MockProviderConfig:
+    """Configuration for :class:`MockProvider`."""
+
+    def __init__(self, default_model: str = "mock-model", max_tokens: int = 1024) -> None:
+        self.default_model = default_model
+        self.max_tokens = max_tokens
+
+
+class MockProvider(Provider[MockProviderConfig]):
+    """Offline provider for tests and explicit ``--mock`` mode."""
+
+    name: ClassVar[str] = "mock"
+    _MODELS: ClassVar[list[ModelInfo]] = [
+        ModelInfo(id="mock-model", name="Mock Model", context_window=8192),
+    ]
+
+    def __init__(self, config: MockProviderConfig | None = None) -> None:
+        super().__init__(config or MockProviderConfig())
+
+    async def chat(self, request: ChatRequest) -> ChatResponse:
+        last_user = next(
+            (m for m in reversed(request.messages) if m.role is Role.USER),
+            None,
+        )
+        text = last_user.content if last_user else ""
+
+        has_diff_request = any(
+            m.role is Role.SYSTEM and "unified diff" in m.content.lower() for m in request.messages
+        )
+
+        has_commit_request = (
+            any("commit" in m.content.lower() for m in request.messages) or "commit" in text.lower()
+        )
+
+        if has_commit_request:
+            content = (
+                "feat(auth): add secure provider authentication\n\n"
+                "- add OS keychain credential storage\n"
+                "- support provider selection\n"
+                "- improve onboarding flow\n"
+                "- add regression tests"
+            )
+        elif has_diff_request:
+            content = offline_build_notice()
+        elif is_greeting(text):
+            content = greeting_reply(text)
+        else:
+            content = (
+                "I'm running in offline mode without a configured AI provider. "
+                "Ask a question about your codebase after configuring an API key, "
+                "or pass `--mock` explicitly to stay offline."
+            )
+
+        return ChatResponse(
+            model=request.model or self.config.default_model,
+            message=ChatMessage(role=Role.ASSISTANT, content=content),
+            finish_reason="stop",
+            prompt_tokens=len(text),
+            completion_tokens=len(content),
+            total_tokens=len(text) + len(content),
+        )
+
+    async def stream(self, request: ChatRequest):
+        response = await self.chat(request)
+        if response.message.content:
+            yield StreamChunk(delta=response.message.content, raw=response.raw)
+        yield StreamChunk(delta="", finish_reason="stop")
+
+    async def embed(self, request: EmbeddingRequest) -> EmbeddingResponse:
+        vectors: list[list[float]] = []
+        for text in request.inputs:
+            digest = hashlib.sha256(text.encode("utf-8")).digest()
+            vec = [b / 255.0 for b in digest[:16]]
+            vectors.append(vec)
+        return EmbeddingResponse(
+            model=request.model or self.config.default_model,
+            vectors=vectors,
+            prompt_tokens=sum(len(t) for t in request.inputs),
+            total_tokens=sum(len(t) for t in request.inputs),
+        )
+
+    async def list_models(self) -> list[ModelInfo]:
+        return list(self._MODELS)
+
+
+__all__ = ["MockProvider", "MockProviderConfig"]

forgecli/providers/openai.py

@@ -0,0 +1,206 @@
+"""OpenAI Chat Completions provider.
+
+Targets the public ``https://api.openai.com/v1`` endpoint, with sane
+defaults for the most common models (gpt-4o, gpt-4o-mini, o1, …). The
+provider is configured via the standard ``OPENAI_API_KEY`` environment
+variable; the base URL can be overridden in the ForgeCLI config to
+point at OpenAI-compatible servers (vLLM, LM Studio, llama.cpp).
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from forgecli.providers.base import (
+    ChatMessage,
+    ChatRequest,
+    ChatResponse,
+    EmbeddingRequest,
+    EmbeddingResponse,
+    ModelInfo,
+    Role,
+    StreamChunk,
+)
+from forgecli.providers.http_base import HTTPChatProvider, messages_to_openai
+
+
+@dataclass
+class OpenAIConfig:
+    """Configuration for the OpenAI provider."""
+
+    api_key_env: str = "OPENAI_API_KEY"
+    base_url: str = "https://api.openai.com/v1"
+    default_model: str = "gpt-4o-mini"
+    max_tokens: int = 4096
+    temperature: float = 0.2
+    embeddings_model: str = "text-embedding-3-small"
+
+
+class OpenAIProvider(HTTPChatProvider):
+    """OpenAI Chat Completions + Embeddings."""
+
+    name = "openai"
+
+    def __init__(
+        self,
+        config: OpenAIConfig | None = None,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        super().__init__(
+            config or OpenAIConfig(),
+            api_key=api_key,
+            base_url=base_url,
+            client=client,
+        )
+
+    def _default_base_url(self) -> str:
+        return "https://api.openai.com/v1"
+
+    def _chat_url(self) -> str:
+        return f"{self._base_url}/chat/completions"
+
+    def _embeddings_url(self) -> str:
+        return f"{self._base_url}/embeddings"
+
+    def _default_embedding_model(self) -> str:
+        return self.config.embeddings_model
+
+    def _format_request(self, request: ChatRequest) -> dict[str, Any]:
+        body: dict[str, Any] = {
+            "model": request.model or self.config.default_model,
+            "messages": messages_to_openai(request.messages),
+        }
+        model_lower = (request.model or self.config.default_model).lower()
+        is_reasoning_or_gpt5 = (
+            model_lower.startswith("o1") or model_lower.startswith("o3") or "gpt-5" in model_lower
+        )
+        is_pure_reasoning = (
+            model_lower.startswith("o1") or model_lower.startswith("o3") or "gpt-5" in model_lower
+        )
+
+        if not is_pure_reasoning:
+            if request.temperature is not None:
+                body["temperature"] = request.temperature
+            else:
+                body["temperature"] = self.config.temperature
+
+        max_tokens_val = (
+            request.max_tokens if request.max_tokens is not None else self.config.max_tokens
+        )
+        if is_reasoning_or_gpt5:
+            body["max_completion_tokens"] = max_tokens_val
+        else:
+            body["max_tokens"] = max_tokens_val
+
+        if request.top_p is not None:
+            body["top_p"] = request.top_p
+        if request.stop:
+            body["stop"] = list(request.stop)
+        if request.tools:
+            body["tools"] = list(request.tools)
+        return body
+
+    def _parse_response(self, payload: dict[str, Any]) -> ChatResponse:
+        choices = payload.get("choices") or []
+        first = choices[0] if choices else {}
+        message = first.get("message") or {}
+        usage = payload.get("usage") or {}
+        return ChatResponse(
+            model=str(payload.get("model", self.config.default_model)),
+            message=ChatMessage(
+                role=Role(message.get("role", "assistant")),
+                content=str(message.get("content", "")),
+            ),
+            finish_reason=first.get("finish_reason"),
+            prompt_tokens=int(usage.get("prompt_tokens", 0) or 0),
+            completion_tokens=int(usage.get("completion_tokens", 0) or 0),
+            total_tokens=int(usage.get("total_tokens", 0) or 0),
+            raw=payload,
+        )
+
+    async def stream(self, request: ChatRequest) -> AsyncIterator[StreamChunk]:
+        from forgecli.core.errors import ProviderError
+
+        if not self._api_key:
+            self.validate()
+        body = self._format_request(request)
+        body["stream"] = True
+
+        req = self._client.build_request(
+            "POST", self._chat_url_for(request), json=body, headers=self._auth_headers()
+        )
+        response = await self._client.send(req, stream=True)
+        if response.status_code >= 400:
+            await response.aread()
+            raise ProviderError(
+                f"{self.name} stream failed ({response.status_code}): {response.text[:500]}"
+            )
+
+        import json
+
+        try:
+            async for line in response.aiter_lines():
+                line = line.strip()
+                if not line:
+                    continue
+                if line.startswith("data: "):
+                    data_str = line[6:]
+                    if data_str == "[DONE]":
+                        break
+                    try:
+                        payload = json.loads(data_str)
+                        choices = payload.get("choices", [])
+                        if choices:
+                            delta = choices[0].get("delta", {})
+                            content = delta.get("content", "")
+                            finish_reason = choices[0].get("finish_reason")
+                            if content or finish_reason:
+                                yield StreamChunk(
+                                    delta=content, finish_reason=finish_reason, raw=payload
+                                )
+                    except Exception:
+                        pass
+        finally:
+            await response.aclose()
+
+    def _format_embeddings(self, request: EmbeddingRequest) -> dict[str, Any]:
+        return {
+            "model": request.model or self.config.embeddings_model,
+            "input": list(request.inputs),
+        }
+
+    def _parse_embeddings(self, payload: dict[str, Any]) -> EmbeddingResponse:
+        data = payload.get("data") or []
+        vectors = [list(item.get("embedding", [])) for item in data]
+        usage = payload.get("usage") or {}
+        return EmbeddingResponse(
+            model=str(payload.get("model", self.config.embeddings_model)),
+            vectors=vectors,
+            prompt_tokens=int(usage.get("prompt_tokens", 0) or 0),
+            total_tokens=int(usage.get("total_tokens", 0) or 0),
+        )
+
+    def _known_models(self) -> list[ModelInfo]:
+        from forgecli.core.models import MODEL_CATALOG
+
+        return [
+            ModelInfo(
+                id=m.id,
+                name=m.display_name,
+                context_window=128_000,
+                supports_tools=not m.id.startswith("o1"),
+                supports_vision=True,
+            )
+            for m in MODEL_CATALOG
+            if m.provider == "openai"
+        ]
+
+
+__all__ = ["OpenAIConfig", "OpenAIProvider"]