kodit 0.3.17__py3-none-any.whl → 0.4.1__py3-none-any.whl

kodit/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.17'
-__version_tuple__ = version_tuple = (0, 3, 17)
+__version__ = version = '0.4.1'
+__version_tuple__ = version_tuple = (0, 4, 1)
+
+__commit_id__ = commit_id = None

kodit/app.py

@@ -12,7 +12,11 @@ from kodit.application.services.auto_indexing_service import AutoIndexingService
 from kodit.application.services.indexing_worker_service import IndexingWorkerService
 from kodit.application.services.sync_scheduler import SyncSchedulerService
 from kodit.config import AppContext
-from kodit.infrastructure.api.v1.routers import indexes_router, search_router
+from kodit.infrastructure.api.v1.routers import (
+    indexes_router,
+    queue_router,
+    search_router,
+)
 from kodit.infrastructure.api.v1.schemas.context import AppLifespanState
 from kodit.mcp import mcp
 from kodit.middleware import ASGICancelledErrorMiddleware, logging_middleware
@@ -113,6 +117,7 @@ async def healthz() -> Response:
 
 # Include API routers
 app.include_router(indexes_router)
+app.include_router(queue_router)
 app.include_router(search_router)
 
 

kodit/application/services/queue_service.py

@@ -50,3 +50,8 @@ class QueueService:
         """List all tasks in the queue."""
         repo = SqlAlchemyTaskRepository(self.session)
         return await repo.list(task_type)
+
+    async def get_task(self, task_id: str) -> Task | None:
+        """Get a specific task by ID."""
+        repo = SqlAlchemyTaskRepository(self.session)
+        return await repo.get(task_id)

kodit/config.py

@@ -38,15 +38,17 @@ DEFAULT_LOG_FORMAT = LogFormat.PRETTY
 DEFAULT_DISABLE_TELEMETRY = False
 T = TypeVar("T")
 
-EndpointType = Literal["openai"]
+EndpointType = Literal["openai", "litellm"]
 
 
 class Endpoint(BaseModel):
     """Endpoint provides configuration for an AI service."""
 
-    type: EndpointType | None = None
     base_url: str | None = None
-    model: str | None = None
+    model: str | None = Field(
+        default=None,
+        description="Model to use for the endpoint in litellm format (e.g. 'openai/text-embedding-3-small')",  # noqa: E501
+    )
     api_key: str | None = None
     num_parallel_tasks: int | None = None
     socket_path: str | None = Field(
@@ -57,6 +59,10 @@ class Endpoint(BaseModel):
         default=None,
         description="Request timeout in seconds (default: 30.0)",
     )
+    extra_params: dict[str, Any] | None = Field(
+        default=None,
+        description="Extra provider-specific non-secret parameters for LiteLLM",
+    )
 
 
 class Search(BaseModel):
@@ -114,15 +120,11 @@ class PeriodicSyncConfig(BaseModel):
 class RemoteConfig(BaseModel):
     """Configuration for remote server connection."""
 
-    server_url: str | None = Field(
-        default=None, description="Remote Kodit server URL"
-    )
+    server_url: str | None = Field(default=None, description="Remote Kodit server URL")
     api_key: str | None = Field(default=None, description="API key for authentication")
     timeout: float = Field(default=30.0, description="Request timeout in seconds")
     max_retries: int = Field(default=3, description="Maximum retry attempts")
-    verify_ssl: bool = Field(
-        default=True, description="Verify SSL certificates"
-    )
+    verify_ssl: bool = Field(default=True, description="Verify SSL certificates")
 
 
 class CustomAutoIndexingEnvSource(EnvSettingsSource):
@@ -198,13 +200,6 @@ class AppContext(BaseSettings):
     log_level: str = Field(default=DEFAULT_LOG_LEVEL)
     log_format: LogFormat = Field(default=DEFAULT_LOG_FORMAT)
     disable_telemetry: bool = Field(default=DEFAULT_DISABLE_TELEMETRY)
-    default_endpoint: Endpoint | None = Field(
-        default=None,
-        description=(
-            "Default endpoint to use for all AI interactions "
-            "(can be overridden by task-specific configuration)."
-        ),
-    )
     embedding_endpoint: Endpoint | None = Field(
         default=None,
         description="Endpoint to use for embedding.",

kodit/infrastructure/api/v1/__init__.py

@@ -1,5 +1,5 @@
 """API v1 modules."""
 
-from .routers import indexes_router, search_router
+from .routers import indexes_router, queue_router, search_router
 
-__all__ = ["indexes_router", "search_router"]
+__all__ = ["indexes_router", "queue_router", "search_router"]

kodit/infrastructure/api/v1/routers/__init__.py

@@ -1,6 +1,7 @@
 """API v1 routers."""
 
 from .indexes import router as indexes_router
+from .queue import router as queue_router
 from .search import router as search_router
 
-__all__ = ["indexes_router", "search_router"]
+__all__ = ["indexes_router", "queue_router", "search_router"]

kodit/infrastructure/api/v1/routers/queue.py

@@ -0,0 +1,76 @@
+"""Queue management router for the REST API."""
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from kodit.domain.value_objects import TaskType
+from kodit.infrastructure.api.middleware.auth import api_key_auth
+from kodit.infrastructure.api.v1.dependencies import QueueServiceDep
+from kodit.infrastructure.api.v1.schemas.queue import (
+    TaskAttributes,
+    TaskData,
+    TaskListResponse,
+    TaskResponse,
+)
+
+router = APIRouter(
+    prefix="/api/v1/queue",
+    tags=["queue"],
+    dependencies=[Depends(api_key_auth)],
+    responses={
+        401: {"description": "Unauthorized"},
+        422: {"description": "Invalid request"},
+    },
+)
+
+
+@router.get("")
+async def list_queue_tasks(
+    queue_service: QueueServiceDep,
+    task_type: TaskType | None = None,
+) -> TaskListResponse:
+    """List all tasks in the queue.
+
+    Optionally filter by task type.
+    """
+    tasks = await queue_service.list_tasks(task_type)
+    return TaskListResponse(
+        data=[
+            TaskData(
+                type="task",
+                id=task.id,
+                attributes=TaskAttributes(
+                    type=str(task.type),
+                    priority=task.priority,
+                    payload=task.payload,
+                    created_at=task.created_at,
+                    updated_at=task.updated_at,
+                ),
+            )
+            for task in tasks
+        ]
+    )
+
+
+@router.get("/{task_id}", responses={404: {"description": "Task not found"}})
+async def get_queue_task(
+    task_id: str,
+    queue_service: QueueServiceDep,
+) -> TaskResponse:
+    """Get details of a specific task in the queue."""
+    task = await queue_service.get_task(task_id)
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+
+    return TaskResponse(
+        data=TaskData(
+            type="task",
+            id=task.id,
+            attributes=TaskAttributes(
+                type=str(task.type),
+                priority=task.priority,
+                payload=task.payload,
+                created_at=task.created_at,
+                updated_at=task.updated_at,
+            ),
+        )
+    )

kodit/infrastructure/api/v1/schemas/queue.py

@@ -0,0 +1,35 @@
+"""JSON:API schemas for queue operations."""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class TaskAttributes(BaseModel):
+    """Task attributes for JSON:API responses."""
+
+    type: str
+    priority: int
+    payload: dict
+    created_at: datetime | None
+    updated_at: datetime | None
+
+
+class TaskData(BaseModel):
+    """Task data for JSON:API responses."""
+
+    type: str = "task"
+    id: str
+    attributes: TaskAttributes
+
+
+class TaskResponse(BaseModel):
+    """JSON:API response for single task."""
+
+    data: TaskData
+
+
+class TaskListResponse(BaseModel):
+    """JSON:API response for task list."""
+
+    data: list[TaskData]

kodit/infrastructure/embedding/embedding_factory.py

@@ -1,5 +1,6 @@
 """Factory for creating embedding services with DDD architecture."""
 
+import structlog
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.config import AppContext, Endpoint
@@ -8,14 +9,13 @@ from kodit.domain.services.embedding_service import (
     EmbeddingProvider,
     VectorSearchRepository,
 )
+from kodit.infrastructure.embedding.embedding_providers.litellm_embedding_provider import (  # noqa: E501
+    LiteLLMEmbeddingProvider,
+)
 from kodit.infrastructure.embedding.embedding_providers.local_embedding_provider import (  # noqa: E501
     CODE,
     LocalEmbeddingProvider,
 )
-from kodit.infrastructure.embedding.embedding_providers.openai_embedding_provider import (  # noqa: E501
-    OPENAI_NUM_PARALLEL_TASKS,
-    OpenAIEmbeddingProvider,
-)
 from kodit.infrastructure.embedding.local_vector_search_repository import (
     LocalVectorSearchRepository,
 )
@@ -32,30 +32,24 @@ from kodit.log import log_event
 
 def _get_endpoint_configuration(app_context: AppContext) -> Endpoint | None:
     """Get the endpoint configuration for the embedding service."""
-    return app_context.embedding_endpoint or app_context.default_endpoint or None
+    return app_context.embedding_endpoint or None
 
 
 def embedding_domain_service_factory(
     task_name: TaskName, app_context: AppContext, session: AsyncSession
 ) -> EmbeddingDomainService:
     """Create an embedding domain service."""
+    structlog.get_logger(__name__)
     # Create embedding repository
     embedding_repository = SqlAlchemyEmbeddingRepository(session=session)
 
     # Create embedding provider
     embedding_provider: EmbeddingProvider | None = None
     endpoint = _get_endpoint_configuration(app_context)
-    if endpoint and endpoint.type == "openai":
-        log_event("kodit.embedding", {"provider": "openai"})
-        # Use new httpx-based provider with socket support
-        embedding_provider = OpenAIEmbeddingProvider(
-            api_key=endpoint.api_key,
-            base_url=endpoint.base_url or "https://api.openai.com/v1",
-            model_name=endpoint.model or "text-embedding-3-small",
-            num_parallel_tasks=endpoint.num_parallel_tasks or OPENAI_NUM_PARALLEL_TASKS,
-            socket_path=endpoint.socket_path,
-            timeout=endpoint.timeout or 30.0,
-        )
+
+    if endpoint:
+        log_event("kodit.embedding", {"provider": "litellm"})
+        embedding_provider = LiteLLMEmbeddingProvider(endpoint=endpoint)
     else:
         log_event("kodit.embedding", {"provider": "local"})
         embedding_provider = LocalEmbeddingProvider(CODE)

kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py

@@ -0,0 +1,163 @@
+"""LiteLLM embedding provider implementation."""
+
+import asyncio
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import httpx
+import litellm
+import structlog
+from litellm import aembedding
+
+from kodit.config import Endpoint
+from kodit.domain.services.embedding_service import EmbeddingProvider
+from kodit.domain.value_objects import EmbeddingRequest, EmbeddingResponse
+
+# Constants
+MAX_TOKENS = 8192  # Conservative token limit for the embedding model
+BATCH_SIZE = 10  # Maximum number of items per API call
+DEFAULT_NUM_PARALLEL_TASKS = 10  # Semaphore limit for concurrent requests
+
+
+class LiteLLMEmbeddingProvider(EmbeddingProvider):
+    """LiteLLM embedding provider that supports 100+ providers."""
+
+    def __init__(
+        self,
+        endpoint: Endpoint,
+    ) -> None:
+        """Initialize the LiteLLM embedding provider.
+
+        Args:
+            endpoint: The endpoint configuration containing all settings.
+
+        """
+        self.model_name = endpoint.model or "text-embedding-3-small"
+        self.api_key = endpoint.api_key
+        self.base_url = endpoint.base_url
+        self.socket_path = endpoint.socket_path
+        self.num_parallel_tasks = (
+            endpoint.num_parallel_tasks or DEFAULT_NUM_PARALLEL_TASKS
+        )
+        self.timeout = endpoint.timeout or 30.0
+        self.extra_params = endpoint.extra_params or {}
+        self.log = structlog.get_logger(__name__)
+
+        # Configure LiteLLM with custom HTTPX client for Unix socket support if needed
+        self._setup_litellm_client()
+
+    def _setup_litellm_client(self) -> None:
+        """Set up LiteLLM with custom HTTPX client for Unix socket support."""
+        if self.socket_path:
+            # Create HTTPX client with Unix socket transport
+            transport = httpx.AsyncHTTPTransport(uds=self.socket_path)
+            unix_client = httpx.AsyncClient(
+                transport=transport,
+                base_url="http://localhost",  # Base URL for Unix socket
+                timeout=self.timeout,
+            )
+            # Set as LiteLLM's async client session
+            litellm.aclient_session = unix_client
+
+    def _split_sub_batches(
+        self, data: list[EmbeddingRequest]
+    ) -> list[list[EmbeddingRequest]]:
+        """Split data into manageable batches.
+
+        For LiteLLM, we use a simpler batching approach since token counting
+        varies by provider. We use a conservative batch size approach.
+        """
+        batches = []
+        for i in range(0, len(data), BATCH_SIZE):
+            batch = data[i : i + BATCH_SIZE]
+            batches.append(batch)
+        return batches
+
+    async def _call_embeddings_api(self, texts: list[str]) -> Any:
+        """Call the embeddings API using LiteLLM.
+
+        Args:
+            texts: The texts to embed.
+
+        Returns:
+            The API response as a dictionary.
+
+        """
+        kwargs = {
+            "model": self.model_name,
+            "input": texts,
+            "timeout": self.timeout,
+        }
+
+        # Add API key if provided
+        if self.api_key:
+            kwargs["api_key"] = self.api_key
+
+        # Add base_url if provided
+        if self.base_url:
+            kwargs["api_base"] = self.base_url
+
+        # Add extra parameters
+        kwargs.update(self.extra_params)
+
+        try:
+            # Use litellm's async embedding function
+            response = await aembedding(**kwargs)
+            return (
+                response.model_dump() if hasattr(response, "model_dump") else response
+            )
+        except Exception as e:
+            self.log.exception(
+                "LiteLLM embedding API error", error=str(e), model=self.model_name
+            )
+            raise
+
+    async def embed(
+        self, data: list[EmbeddingRequest]
+    ) -> AsyncGenerator[list[EmbeddingResponse], None]:
+        """Embed a list of strings using LiteLLM."""
+        if not data:
+            yield []
+            return
+
+        # Split into batches
+        batched_data = self._split_sub_batches(data)
+
+        # Process batches concurrently with semaphore
+        sem = asyncio.Semaphore(self.num_parallel_tasks)
+
+        async def _process_batch(
+            batch: list[EmbeddingRequest],
+        ) -> list[EmbeddingResponse]:
+            async with sem:
+                try:
+                    response = await self._call_embeddings_api(
+                        [item.text for item in batch]
+                    )
+                    embeddings_data = response.get("data", [])
+
+                    return [
+                        EmbeddingResponse(
+                            snippet_id=item.snippet_id,
+                            embedding=emb_data.get("embedding", []),
+                        )
+                        for item, emb_data in zip(batch, embeddings_data, strict=True)
+                    ]
+                except Exception as e:
+                    self.log.exception("Error embedding batch", error=str(e))
+                    # Return no embeddings for this batch if there was an error
+                    return []
+
+        tasks = [_process_batch(batch) for batch in batched_data]
+        for task in asyncio.as_completed(tasks):
+            yield await task
+
+    async def close(self) -> None:
+        """Close the provider and cleanup HTTPX client if using Unix sockets."""
+        if (
+            self.socket_path
+            and hasattr(litellm, "aclient_session")
+            and litellm.aclient_session
+        ):
+            await litellm.aclient_session.aclose()
+            litellm.aclient_session = None

kodit/infrastructure/enrichment/enrichment_factory.py

@@ -5,13 +5,12 @@ from kodit.domain.services.enrichment_service import (
     EnrichmentDomainService,
     EnrichmentProvider,
 )
+from kodit.infrastructure.enrichment.litellm_enrichment_provider import (
+    LiteLLMEnrichmentProvider,
+)
 from kodit.infrastructure.enrichment.local_enrichment_provider import (
     LocalEnrichmentProvider,
 )
-from kodit.infrastructure.enrichment.openai_enrichment_provider import (
-    OPENAI_NUM_PARALLEL_TASKS,
-    OpenAIEnrichmentProvider,
-)
 from kodit.log import log_event
 
 
@@ -25,7 +24,7 @@ def _get_endpoint_configuration(app_context: AppContext) -> Endpoint | None:
         The endpoint configuration or None.
 
     """
-    return app_context.enrichment_endpoint or app_context.default_endpoint or None
+    return app_context.enrichment_endpoint or None
 
 
 def enrichment_domain_service_factory(
@@ -43,17 +42,9 @@ def enrichment_domain_service_factory(
     endpoint = _get_endpoint_configuration(app_context)
 
     enrichment_provider: EnrichmentProvider | None = None
-    if endpoint and endpoint.type == "openai":
-        log_event("kodit.enrichment", {"provider": "openai"})
-        # Use new httpx-based provider with socket support
-        enrichment_provider = OpenAIEnrichmentProvider(
-            api_key=endpoint.api_key,
-            base_url=endpoint.base_url or "https://api.openai.com/v1",
-            model_name=endpoint.model or "gpt-4o-mini",
-            num_parallel_tasks=endpoint.num_parallel_tasks or OPENAI_NUM_PARALLEL_TASKS,
-            socket_path=endpoint.socket_path,
-            timeout=endpoint.timeout or 30.0,
-        )
+    if endpoint:
+        log_event("kodit.enrichment", {"provider": "litellm"})
+        enrichment_provider = LiteLLMEnrichmentProvider(endpoint=endpoint)
     else:
         log_event("kodit.enrichment", {"provider": "local"})
         enrichment_provider = LocalEnrichmentProvider()

kodit/infrastructure/enrichment/{openai_enrichment_provider.py → litellm_enrichment_provider.py}

@@ -1,12 +1,15 @@
-"""OpenAI enrichment provider implementation using httpx."""
+"""LiteLLM enrichment provider implementation."""
 
 import asyncio
 from collections.abc import AsyncGenerator
 from typing import Any
 
 import httpx
+import litellm
 import structlog
+from litellm import acompletion
 
+from kodit.config import Endpoint
 from kodit.domain.services.enrichment_service import EnrichmentProvider
 from kodit.domain.value_objects import EnrichmentRequest, EnrichmentResponse
 from kodit.infrastructure.enrichment.utils import clean_thinking_tags
@@ -16,60 +19,52 @@ You are a professional software developer. You will be given a snippet of code.
 Please provide a concise explanation of the code.
 """
 
-# Default tuned to approximately fit within OpenAI's rate limit of 500 / RPM
-OPENAI_NUM_PARALLEL_TASKS = 40
+# Default tuned conservatively for broad provider compatibility
+DEFAULT_NUM_PARALLEL_TASKS = 20
 
 
+class LiteLLMEnrichmentProvider(EnrichmentProvider):
+    """LiteLLM enrichment provider that supports 100+ providers."""
 
-class OpenAIEnrichmentProvider(EnrichmentProvider):
-    """OpenAI enrichment provider implementation using httpx."""
-
-    def __init__(  # noqa: PLR0913
+    def __init__(
         self,
-        api_key: str | None = None,
-        base_url: str = "https://api.openai.com",
-        model_name: str = "gpt-4o-mini",
-        num_parallel_tasks: int = OPENAI_NUM_PARALLEL_TASKS,
-        socket_path: str | None = None,
-        timeout: float = 30.0,
+        endpoint: Endpoint,
     ) -> None:
-        """Initialize the OpenAI enrichment provider.
+        """Initialize the LiteLLM enrichment provider.
 
         Args:
-            api_key: The OpenAI API key.
-            base_url: The base URL for the OpenAI API.
-            model_name: The model name to use for enrichment.
-            num_parallel_tasks: Maximum number of concurrent requests.
-            socket_path: Optional Unix socket path for local communication.
-            timeout: Request timeout in seconds.
+            endpoint: The endpoint configuration containing all settings.
 
         """
         self.log = structlog.get_logger(__name__)
-        self.model_name = model_name
-        self.num_parallel_tasks = num_parallel_tasks
-        self.api_key = api_key
-        self.base_url = base_url
-        self.socket_path = socket_path
-        self.timeout = timeout
-
-        # Create httpx client with optional Unix socket support
-        if socket_path:
-            transport = httpx.AsyncHTTPTransport(uds=socket_path)
-            self.http_client = httpx.AsyncClient(
+        self.model_name = endpoint.model or "gpt-4o-mini"
+        self.api_key = endpoint.api_key
+        self.base_url = endpoint.base_url
+        self.socket_path = endpoint.socket_path
+        self.num_parallel_tasks = (
+            endpoint.num_parallel_tasks or DEFAULT_NUM_PARALLEL_TASKS
+        )
+        self.timeout = endpoint.timeout or 30.0
+        self.extra_params = endpoint.extra_params or {}
+
+        # Configure LiteLLM with custom HTTPX client for Unix socket support if needed
+        self._setup_litellm_client()
+
+    def _setup_litellm_client(self) -> None:
+        """Set up LiteLLM with custom HTTPX client for Unix socket support."""
+        if self.socket_path:
+            # Create HTTPX client with Unix socket transport
+            transport = httpx.AsyncHTTPTransport(uds=self.socket_path)
+            unix_client = httpx.AsyncClient(
                 transport=transport,
                 base_url="http://localhost",  # Base URL for Unix socket
-                timeout=timeout,
-            )
-        else:
-            self.http_client = httpx.AsyncClient(
-                base_url=base_url,
-                timeout=timeout,
+                timeout=self.timeout,
             )
+            # Set as LiteLLM's async client session
+            litellm.aclient_session = unix_client
 
-    async def _call_chat_completion(
-        self, messages: list[dict[str, str]]
-    ) -> dict[str, Any]:
-        """Call the chat completion API using httpx.
+    async def _call_chat_completion(self, messages: list[dict[str, str]]) -> Any:
+        """Call the chat completion API using LiteLLM.
 
         Args:
             messages: The messages to send to the API.
@@ -78,29 +73,39 @@ class OpenAIEnrichmentProvider(EnrichmentProvider):
             The API response as a dictionary.
 
         """
-        headers = {
-            "Content-Type": "application/json",
-        }
-        if self.api_key:
-            headers["Authorization"] = f"Bearer {self.api_key}"
-
-        data = {
+        kwargs = {
             "model": self.model_name,
             "messages": messages,
+            "timeout": self.timeout,
         }
 
-        response = await self.http_client.post(
-            "/v1/chat/completions",
-            json=data,
-            headers=headers,
-        )
-        response.raise_for_status()
-        return response.json()
+        # Add API key if provided
+        if self.api_key:
+            kwargs["api_key"] = self.api_key
+
+        # Add base_url if provided
+        if self.base_url:
+            kwargs["api_base"] = self.base_url
+
+        # Add extra parameters
+        kwargs.update(self.extra_params)
+
+        try:
+            # Use litellm's async completion function
+            response = await acompletion(**kwargs)
+            return (
+                response.model_dump() if hasattr(response, "model_dump") else response
+            )
+        except Exception as e:
+            self.log.exception(
+                "LiteLLM completion API error", error=str(e), model=self.model_name
+            )
+            raise
 
     async def enrich(
         self, requests: list[EnrichmentRequest]
     ) -> AsyncGenerator[EnrichmentResponse, None]:
-        """Enrich a list of requests using OpenAI API.
+        """Enrich a list of requests using LiteLLM.
 
         Args:
             requests: List of enrichment requests.
@@ -113,7 +118,7 @@ class OpenAIEnrichmentProvider(EnrichmentProvider):
             self.log.warning("No requests for enrichment")
             return
 
-        # Process batches in parallel with a semaphore to limit concurrent requests
+        # Process requests in parallel with a semaphore to limit concurrent requests
         sem = asyncio.Semaphore(self.num_parallel_tasks)
 
         async def process_request(request: EnrichmentRequest) -> EnrichmentResponse:
@@ -158,6 +163,11 @@ class OpenAIEnrichmentProvider(EnrichmentProvider):
             yield await task
 
     async def close(self) -> None:
-        """Close the HTTP client."""
-        if hasattr(self, "http_client"):
-            await self.http_client.aclose()
+        """Close the provider and cleanup HTTPX client if using Unix sockets."""
+        if (
+            self.socket_path
+            and hasattr(litellm, "aclient_session")
+            and litellm.aclient_session
+        ):
+            await litellm.aclient_session.aclose()
+            litellm.aclient_session = None

kodit/infrastructure/git/git_utils.py

@@ -3,6 +3,7 @@
 import tempfile
 
 import git
+import structlog
 
 
 # FUTURE: move to clone dir
@@ -19,7 +20,12 @@ def is_valid_clone_target(target: str) -> bool:
     with tempfile.TemporaryDirectory() as temp_dir:
         try:
             git.Repo.clone_from(target, temp_dir)
-        except git.GitCommandError:
+        except git.GitCommandError as e:
+            structlog.get_logger(__name__).warning(
+                "Failed to clone git repository",
+                target=target,
+                error=e,
+            )
             return False
         else:
             return True

kodit/log.py

@@ -11,6 +11,7 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
+import litellm
 import rudderstack.analytics as rudder_analytics  # type: ignore[import-untyped]
 import structlog
 from structlog.types import EventDict
@@ -99,6 +100,7 @@ def configure_logging(app_context: AppContext) -> None:
         "bm25s",
         "sentence_transformers.SentenceTransformer",
         "httpx",
+        "LiteLLM",
     ]:
         if root_logger.getEffectiveLevel() == logging.DEBUG:
             logging.getLogger(_log).handlers.clear()
@@ -106,6 +108,9 @@ def configure_logging(app_context: AppContext) -> None:
         else:
             logging.getLogger(_log).disabled = True
 
+    # More litellm logging cruft
+    litellm.suppress_debug_info = True
+
     # Configure SQLAlchemy loggers to use our structlog setup
     for _log in ["sqlalchemy.engine", "alembic"]:
         engine_logger = logging.getLogger(_log)
@@ -138,6 +143,7 @@ def configure_logging(app_context: AppContext) -> None:
 
 def configure_telemetry(app_context: AppContext) -> None:
     """Configure telemetry for the application."""
+    litellm.telemetry = False  # Disable litellm telemetry by default
     if app_context.disable_telemetry:
         structlog.stdlib.get_logger(__name__).info("Telemetry has been disabled")
         rudder_analytics.send = False

{kodit-0.3.17.dist-info → kodit-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.17
+Version: 0.4.1
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/
@@ -35,7 +35,8 @@ Requires-Dist: gitpython>=3.1.44
 Requires-Dist: hf-xet>=1.1.2
 Requires-Dist: httpx-retries>=0.3.2
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: openai>=1.82.0
+Requires-Dist: litellm>=1.75.8
+Requires-Dist: openai==1.99.9
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: pystemmer>=3.0.0

{kodit-0.3.17.dist-info → kodit-0.4.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
 kodit/.gitignore,sha256=ztkjgRwL9Uud1OEi36hGQeDGk3OLK1NfDEO8YqGYy8o,11
 kodit/__init__.py,sha256=aEKHYninUq1yh6jaNfvJBYg-6fenpN132nJt1UU6Jxs,59
-kodit/_version.py,sha256=cGWA93r_16rR-tkjWO67nlhhjy0fPwiHpKtUFrImZgo,513
-kodit/app.py,sha256=r0w0JJsOacrQ5aAQ1yf-BK1CrYZPrvtUoH1LACd9FaA,4262
+kodit/_version.py,sha256=k7cu0JKra64gmMNU_UfA5sw2eNc_GRvf3QmesiYAy8g,704
+kodit/app.py,sha256=FKqHbJNoHpnBb5KLJaUINDm0a5cHpxlrQ5qNoWnHsBc,4326
 kodit/cli.py,sha256=VUZD4cPRgAnrKEWUl2PbS-nOA0FkDVqmJ2SR0g1yJsk,28202
 kodit/cli_utils.py,sha256=bW4rIm-elrsyM_pSGHh30zV0_oX7V-64pL3YSaBcOt0,2810
-kodit/config.py,sha256=YYo36lBi3auCssyCVrpw3Z3ZXSzXKTDo45nIsUjkzfs,10305
+kodit/config.py,sha256=EOyB3BfSDfGJeOts2vrOyX8lhGXbAHVUl69kzjqGHXE,10326
 kodit/database.py,sha256=kI9yBm4uunsgV4-QeVoCBL0wLzU4kYmYv5qZilGnbPE,1740
-kodit/log.py,sha256=XyuseZk90gUBj1B7np2UO2EW9eE_ApayIpPRvI19KCE,8651
+kodit/log.py,sha256=ZpM0eMo_DVGQqrHxg0VV6dMrN2AAmu_3C0I3G7p2nMw,8828
 kodit/mcp.py,sha256=aEcPc8dQiZaR0AswCZZNxcm_rhhUZNsEBimYti0ibSI,7221
 kodit/middleware.py,sha256=TiwebNpaEmiP7QRuZrfZcCL51IUefQyNLSPuzVyk8UM,2813
 kodit/reporting.py,sha256=icce1ZyiADsA_Qz-mSjgn2H4SSqKuGfLKnw-yrl9nsg,2722
@@ -17,7 +17,7 @@ kodit/application/services/__init__.py,sha256=p5UQNw-H5sxQvs5Etfte93B3cJ1kKW6DNx
 kodit/application/services/auto_indexing_service.py,sha256=O5BNR5HypgghzUFG4ykIWMl9mxHCUExnBmJuITIhECk,3457
 kodit/application/services/code_indexing_application_service.py,sha256=nrnd_Md-D0AfNKku7Aqt3YHDbXsBV9f44Z6XsjhiF3E,15877
 kodit/application/services/indexing_worker_service.py,sha256=Un4PytnWJU4uwROcxOMUFkt4cD7nmPezaBLsEHrMN6U,5185
-kodit/application/services/queue_service.py,sha256=GaixRoCUaDhLYfwZLVED8C3w_NPiy_QbuVp_jhwP4GI,1727
+kodit/application/services/queue_service.py,sha256=vf_TEl76B0F0RSvfCeGDuM-QFzW-VUuj3zQaRmDPEYI,1921
 kodit/application/services/sync_scheduler.py,sha256=aLpEczZdTM8ubfAEY0Ajdh3MLfDcB9s-0ILZJrtIuZs,3504
 kodit/domain/__init__.py,sha256=TCpg4Xx-oF4mKV91lo4iXqMEfBT1OoRSYnbG-zVWolA,66
 kodit/domain/entities.py,sha256=QsCzKXT7gF9jTPAjJo5lqjFGRsIklAFC2qRy_Gt3RbA,10377
@@ -41,14 +41,16 @@ kodit/infrastructure/api/client/index_client.py,sha256=OxsakDQBEulwmqZVzwOSSI0Lk
 kodit/infrastructure/api/client/search_client.py,sha256=f4mM5ZJpAuR7w-i9yASbh4SYMxOq7_f4hXgaQesGquI,2614
 kodit/infrastructure/api/middleware/__init__.py,sha256=6m7eE5k5buboJbuzyX5E9-Tf99yNwFaeJF0f_6HwLyM,30
 kodit/infrastructure/api/middleware/auth.py,sha256=QSnMcMLWvfumqN1iG4ePj2vEZb2Dlsgr-WHptkEkkhE,1064
-kodit/infrastructure/api/v1/__init__.py,sha256=XYv4_9Z6fo69oMvC2mEbtD6DaMqHth29KHUOelmQFwM,121
+kodit/infrastructure/api/v1/__init__.py,sha256=hQ03es21FSgzQlmdP5xWZzK80woIvuYGjiZLwFYuYwk,151
 kodit/infrastructure/api/v1/dependencies.py,sha256=jaM000IfSnvU8uzwnC1cBZsfsMC-19jWFjObHfqBYuM,2475
-kodit/infrastructure/api/v1/routers/__init__.py,sha256=L8hT_SkDzmCXIiWrFQWCkZXQ3UDy_ZMxPr8AIhjSWK0,160
+kodit/infrastructure/api/v1/routers/__init__.py,sha256=YYyeiuyphIPc-Q_2totF8zfR0BoseOH4ZYFdHP0ed_M,218
 kodit/infrastructure/api/v1/routers/indexes.py,sha256=_lUir1M0SW6kPHeGqjiPjtSa50rY4PN2es5TZEpSHYE,3442
+kodit/infrastructure/api/v1/routers/queue.py,sha256=EZbR-G0qDO9W5ajV_75GRk2pW1Qdgc0ggOwrGKlBE2A,2138
 kodit/infrastructure/api/v1/routers/search.py,sha256=da9YTR6VTzU85_6X3aaZemdTHGCEvcPNeKuMFBgmT_A,2452
 kodit/infrastructure/api/v1/schemas/__init__.py,sha256=_5BVqv4EUi_vvWlAQOE_VfRulUDAF21ZQ7z27y7YOdw,498
 kodit/infrastructure/api/v1/schemas/context.py,sha256=NlsIn9j1R3se7JkGZivS_CUN4gGP5NYaAtkRe3QH6dk,214
 kodit/infrastructure/api/v1/schemas/index.py,sha256=NtL09YtO50h-ddpAFxNf-dyxu_Xi5v3yOpKW0W4xsAM,1950
+kodit/infrastructure/api/v1/schemas/queue.py,sha256=oa4wumWOvGzi53Q3cjwIrQJRoentp5nsQSsaj-l-B4U,652
 kodit/infrastructure/api/v1/schemas/search.py,sha256=CWzg5SIMUJ_4yM-ZfgSLWCanMxov6AyGgQQcOMkRlGw,5618
 kodit/infrastructure/bm25/__init__.py,sha256=DmGbrEO34FOJy4e685BbyxLA7gPW1eqs2gAxsp6JOuM,34
 kodit/infrastructure/bm25/bm25_factory.py,sha256=I4eo7qRslnyXIRkBf-StZ5ga2Evrr5J5YFocTChFD3g,884
@@ -59,22 +61,22 @@ kodit/infrastructure/cloning/metadata.py,sha256=GD2UnCC1oR82RD0SVUqk9CJOqzXPxhOA
 kodit/infrastructure/cloning/git/__init__.py,sha256=20ePcp0qE6BuLsjsv4KYB1DzKhMIMsPXwEqIEZtjTJs,34
 kodit/infrastructure/cloning/git/working_copy.py,sha256=qYcrR5qP1rhWZiYGMT1p-1Alavi_YvQLXx4MgIV7eXs,2611
 kodit/infrastructure/embedding/__init__.py,sha256=F-8nLlWAerYJ0MOIA4tbXHLan8bW5rRR84vzxx6tRKI,39
-kodit/infrastructure/embedding/embedding_factory.py,sha256=8LC2jKf2vx-P-TCh8ZanxwF3hT5PSjWA3vuSR6ggcXk,3731
+kodit/infrastructure/embedding/embedding_factory.py,sha256=wngBD2g6NniHDq_-KcYhhwSvmcMYyI8yIzoXvGQvu1U,3287
 kodit/infrastructure/embedding/local_vector_search_repository.py,sha256=ExweyNEL5cP-g3eDhGqZSih7zhdOrop2WdFPPJL-tB4,3505
 kodit/infrastructure/embedding/vectorchord_vector_search_repository.py,sha256=PIoU0HsDlaoXDXnGjOR0LAkAcW4JiE3ymJy_SBhEopc,8030
 kodit/infrastructure/embedding/embedding_providers/__init__.py,sha256=qeZ-oAIAxMl5QqebGtO1lq-tHjl_ucAwOXePklcwwGk,34
 kodit/infrastructure/embedding/embedding_providers/batching.py,sha256=a8CL9PX2VLmbeg616fc_lQzfC4BWTVn32m4SEhXpHxc,3279
 kodit/infrastructure/embedding/embedding_providers/hash_embedding_provider.py,sha256=V6OdCuWyQQOvo3OJGRi-gBKDApIcrELydFg7T696P5s,2257
+kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py,sha256=5LCrPSQn3ZaLZ1XTKzJV_LzANH7FdaR4NL-gJupaiDE,5579
 kodit/infrastructure/embedding/embedding_providers/local_embedding_provider.py,sha256=9aLV1Zg4KMhYWlGRwgAUtswW4aIabNqbsipWhAn64RI,4133
-kodit/infrastructure/embedding/embedding_providers/openai_embedding_provider.py,sha256=CE86s8IicieUjIDWn2xzswteHXCzmw1Qz6Kp4GBIcus,6316
 kodit/infrastructure/enrichment/__init__.py,sha256=8acZKNzql8Fs0lceFu9U3KoUrOptRBtVIxr_Iw6lz3Y,40
-kodit/infrastructure/enrichment/enrichment_factory.py,sha256=jZWGgAvFjEuRUc1oW3iGhgipvX-EnVJZpw6ybzp9NGM,2016
+kodit/infrastructure/enrichment/enrichment_factory.py,sha256=NFGY6u9SJ_GOgiB_RtotbQmte0kGFQUymwzZCbbsx34,1530
+kodit/infrastructure/enrichment/litellm_enrichment_provider.py,sha256=AM4-4KApDndzWzQzzKAedy21iGMhkwylR5VCmV9K-uI,6040
 kodit/infrastructure/enrichment/local_enrichment_provider.py,sha256=aVU3_kbLJ0BihwGIwvJ00DBe0voHkiKdFSjPxxkVfVA,4150
 kodit/infrastructure/enrichment/null_enrichment_provider.py,sha256=DhZkJBnkvXg_XSAs-oKiFnKqYFPnmTl3ikdxrqeEfbc,713
-kodit/infrastructure/enrichment/openai_enrichment_provider.py,sha256=C0y0NEPu1GpFr22TGi1voxYGsYTV0ZITYuDzvRJ5vW4,5573
 kodit/infrastructure/enrichment/utils.py,sha256=FE9UCuxxzSdoHrmAC8Si2b5D6Nf6kVqgM1yjUVyCvW0,930
 kodit/infrastructure/git/__init__.py,sha256=0iMosFzudj4_xNIMe2SRbV6l5bWqkjnUsZoFsoZFuM8,33
-kodit/infrastructure/git/git_utils.py,sha256=KERwmhWDR4ooMQKS-nSPxjvdCzoWF9NS6nhdeXyzdtY,571
+kodit/infrastructure/git/git_utils.py,sha256=3Fg2ZX9pkp8Mk1mWuW30PSO_ZKXrPL7wTCS9TMTfIUM,765
 kodit/infrastructure/ignore/__init__.py,sha256=VzFv8XOzHmsu0MEGnWVSF6KsgqLBmvHlRqAkT1Xb1MY,36
 kodit/infrastructure/ignore/ignore_pattern_provider.py,sha256=zdxun3GodLfXxyssBK8QDUK58xb4fBJ0SKcHUyn3pzM,2131
 kodit/infrastructure/indexing/__init__.py,sha256=7UPRa2jwCAsa0Orsp6PqXSF8iIXJVzXHMFmrKkI9yH8,38
@@ -109,8 +111,8 @@ kodit/utils/__init__.py,sha256=DPEB1i8evnLF4Ns3huuAYg-0pKBFKUFuiDzOKG9r-sw,33
 kodit/utils/dump_openapi.py,sha256=29VdjHpNSaGAg7RjQw0meq1OLhljCx1ElgBlTC8xoF4,1247
 kodit/utils/generate_api_paths.py,sha256=TMtx9v55podDfUmiWaHgJHLtEWLV2sLL-5ejGFMPzAo,3569
 kodit/utils/path_utils.py,sha256=thK6YGGNvQThdBaCYCCeCvS1L8x-lwl3AoGht2jnjGw,1645
-kodit-0.3.17.dist-info/METADATA,sha256=xxyRRv2pL9aSP6MYMRPDsVNLR0gdFNg5CJ4UbbLwOAU,7672
-kodit-0.3.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kodit-0.3.17.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
-kodit-0.3.17.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kodit-0.3.17.dist-info/RECORD,,
+kodit-0.4.1.dist-info/METADATA,sha256=Mf4UuPg2D08hfp1STtsZ1DwOHA2a1J4ba5_-T7Pifr4,7702
+kodit-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kodit-0.4.1.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
+kodit-0.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kodit-0.4.1.dist-info/RECORD,,

kodit/infrastructure/embedding/embedding_providers/openai_embedding_provider.py

@@ -1,183 +0,0 @@
-"""OpenAI embedding provider implementation using httpx."""
-
-import asyncio
-from collections.abc import AsyncGenerator
-from typing import Any
-
-import httpx
-import structlog
-import tiktoken
-from tiktoken import Encoding
-
-from kodit.domain.services.embedding_service import EmbeddingProvider
-from kodit.domain.value_objects import EmbeddingRequest, EmbeddingResponse
-
-from .batching import split_sub_batches
-
-# Constants
-MAX_TOKENS = 8192  # Conservative token limit for the embedding model
-BATCH_SIZE = (
-    10  # Maximum number of items per API call (keeps existing test expectations)
-)
-OPENAI_NUM_PARALLEL_TASKS = 10  # Semaphore limit for concurrent OpenAI requests
-
-
-class OpenAIEmbeddingProvider(EmbeddingProvider):
-    """OpenAI embedding provider that uses OpenAI's embedding API via httpx."""
-
-    def __init__(  # noqa: PLR0913
-        self,
-        api_key: str | None = None,
-        base_url: str = "https://api.openai.com",
-        model_name: str = "text-embedding-3-small",
-        num_parallel_tasks: int = OPENAI_NUM_PARALLEL_TASKS,
-        socket_path: str | None = None,
-        timeout: float = 30.0,
-    ) -> None:
-        """Initialize the OpenAI embedding provider.
-
-        Args:
-            api_key: The OpenAI API key.
-            base_url: The base URL for the OpenAI API.
-            model_name: The model name to use for embeddings.
-            num_parallel_tasks: Maximum number of concurrent requests.
-            socket_path: Optional Unix socket path for local communication.
-            timeout: Request timeout in seconds.
-
-        """
-        self.model_name = model_name
-        self.num_parallel_tasks = num_parallel_tasks
-        self.log = structlog.get_logger(__name__)
-        self.api_key = api_key
-        self.base_url = base_url
-        self.socket_path = socket_path
-        self.timeout = timeout
-
-        # Lazily initialised token encoding
-        self._encoding: Encoding | None = None
-
-        # Create httpx client with optional Unix socket support
-        if socket_path:
-            transport = httpx.AsyncHTTPTransport(uds=socket_path)
-            self.http_client = httpx.AsyncClient(
-                transport=transport,
-                base_url="http://localhost",  # Base URL for Unix socket
-                timeout=timeout,
-            )
-        else:
-            self.http_client = httpx.AsyncClient(
-                base_url=base_url,
-                timeout=timeout,
-            )
-
-    # ---------------------------------------------------------------------
-    # Helper utilities
-    # ---------------------------------------------------------------------
-
-    def _get_encoding(self) -> "Encoding":
-        """Return (and cache) the tiktoken encoding for the chosen model."""
-        if self._encoding is None:
-            try:
-                self._encoding = tiktoken.encoding_for_model(self.model_name)
-            except KeyError:
-                # If the model is not supported by tiktoken, use a default encoding
-                self.log.info(
-                    "Model not supported by tiktoken, using default encoding",
-                    model_name=self.model_name,
-                    default_encoding="o200k_base",
-                )
-                self._encoding = tiktoken.get_encoding("o200k_base")
-
-        return self._encoding
-
-    def _split_sub_batches(
-        self, encoding: "Encoding", data: list[EmbeddingRequest]
-    ) -> list[list[EmbeddingRequest]]:
-        """Proxy to the shared batching utility (kept for backward-compat)."""
-        return split_sub_batches(
-            encoding,
-            data,
-            max_tokens=MAX_TOKENS,
-            batch_size=BATCH_SIZE,
-        )
-
-    async def _call_embeddings_api(
-        self, texts: list[str]
-    ) -> dict[str, Any]:
-        """Call the embeddings API using httpx.
-
-        Args:
-            texts: The texts to embed.
-
-        Returns:
-            The API response as a dictionary.
-
-        """
-        headers = {
-            "Content-Type": "application/json",
-        }
-        if self.api_key:
-            headers["Authorization"] = f"Bearer {self.api_key}"
-
-        data = {
-            "model": self.model_name,
-            "input": texts,
-        }
-
-        response = await self.http_client.post(
-            "/v1/embeddings",
-            json=data,
-            headers=headers,
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def embed(
-        self, data: list[EmbeddingRequest]
-    ) -> AsyncGenerator[list[EmbeddingResponse], None]:
-        """Embed a list of strings using OpenAI's API."""
-        if not data:
-            yield []
-
-        encoding = self._get_encoding()
-
-        # First, split by token limits (and max batch size)
-        batched_data = self._split_sub_batches(encoding, data)
-
-        # -----------------------------------------------------------------
-        # Process batches concurrently (but bounded by a semaphore)
-        # -----------------------------------------------------------------
-
-        sem = asyncio.Semaphore(self.num_parallel_tasks)
-
-        async def _process_batch(
-            batch: list[EmbeddingRequest],
-        ) -> list[EmbeddingResponse]:
-            async with sem:
-                try:
-                    response = await self._call_embeddings_api(
-                        [item.text for item in batch]
-                    )
-                    embeddings_data = response.get("data", [])
-
-                    return [
-                        EmbeddingResponse(
-                            snippet_id=item.snippet_id,
-                            embedding=emb_data.get("embedding", []),
-                        )
-                        for item, emb_data in zip(batch, embeddings_data, strict=True)
-                    ]
-                except Exception as e:
-                    self.log.exception("Error embedding batch", error=str(e))
-                    # Return no embeddings for this batch if there was an error
-                    return []
-
-        tasks = [_process_batch(batch) for batch in batched_data]
-        for task in asyncio.as_completed(tasks):
-            yield await task
-
-    async def close(self) -> None:
-        """Close the HTTP client."""
-        if hasattr(self, "http_client"):
-            await self.http_client.aclose()
-