kodit 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

kodit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.1'
-__version_tuple__ = version_tuple = (0, 5, 1)
+__version__ = version = '0.5.3'
+__version_tuple__ = version_tuple = (0, 5, 3)
 
 __commit_id__ = commit_id = None

kodit/application/factories/server_factory.py

@@ -1,7 +1,6 @@
 """Create a big object that contains all the application services."""
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -12,6 +11,9 @@ from kodit.application.services.code_search_application_service import (
 from kodit.application.services.commit_indexing_application_service import (
     CommitIndexingApplicationService,
 )
+from kodit.application.services.enrichment_query_service import (
+    EnrichmentQueryService,
+)
 from kodit.application.services.queue_service import QueueService
 from kodit.application.services.reporting import ProgressTracker
 from kodit.application.services.sync_scheduler import SyncSchedulerService
@@ -39,6 +41,7 @@ from kodit.domain.services.git_repository_service import (
 from kodit.domain.services.physical_architecture_service import (
     PhysicalArchitectureService,
 )
+from kodit.domain.tracking.resolution_service import TrackableResolutionService
 from kodit.infrastructure.bm25.local_bm25_repository import LocalBM25Repository
 from kodit.infrastructure.bm25.vectorchord_bm25_repository import (
     VectorChordBM25Repository,
@@ -82,9 +85,6 @@ from kodit.infrastructure.sqlalchemy.task_status_repository import (
 )
 from kodit.infrastructure.sqlalchemy.unit_of_work import SqlAlchemyUnitOfWork
 
-if TYPE_CHECKING:
-    from kodit.domain.services.enrichment_service import EnrichmentDomainService
-
 
 class ServerFactory:
     """Factory for creating server application services."""
@@ -105,7 +105,6 @@ class ServerFactory:
         self._commit_indexing_application_service: (
             CommitIndexingApplicationService | None
         ) = None
-        self._enrichment_service: EnrichmentDomainService | None = None
         self._enricher_service: Enricher | None = None
         self._task_status_repository: TaskStatusRepository | None = None
         self._operation: ProgressTracker | None = None
@@ -127,6 +126,8 @@ class ServerFactory:
         self._architecture_service: PhysicalArchitectureService | None = None
         self._enrichment_v2_repository: EnrichmentV2Repository | None = None
         self._architecture_formatter: PhysicalArchitectureFormatter | None = None
+        self._trackable_resolution_service: TrackableResolutionService | None = None
+        self._enrichment_query_service: EnrichmentQueryService | None = None
 
     def architecture_formatter(self) -> PhysicalArchitectureFormatter:
         """Create a PhysicalArchitectureFormatter instance."""
@@ -351,3 +352,22 @@ class ServerFactory:
                 session_factory=self.session_factory
             )
         return self._git_tag_repository
+
+    def trackable_resolution_service(self) -> TrackableResolutionService:
+        """Create a TrackableResolutionService instance."""
+        if not self._trackable_resolution_service:
+            self._trackable_resolution_service = TrackableResolutionService(
+                commit_repo=self.git_commit_repository(),
+                branch_repo=self.git_branch_repository(),
+                tag_repo=self.git_tag_repository(),
+            )
+        return self._trackable_resolution_service
+
+    def enrichment_query_service(self) -> EnrichmentQueryService:
+        """Create a EnrichmentQueryService instance."""
+        if not self._enrichment_query_service:
+            self._enrichment_query_service = EnrichmentQueryService(
+                trackable_resolution=self.trackable_resolution_service(),
+                enrichment_repo=self.enrichment_v2_repository(),
+            )
+        return self._enrichment_query_service

kodit/application/services/enrichment_query_service.py

@@ -0,0 +1,95 @@
+"""Application service for querying enrichments."""
+
+import structlog
+
+from kodit.domain.enrichments.enrichment import EnrichmentV2
+from kodit.domain.tracking.resolution_service import TrackableResolutionService
+from kodit.domain.tracking.trackable import Trackable
+from kodit.infrastructure.sqlalchemy.enrichment_v2_repository import (
+    EnrichmentV2Repository,
+)
+
+
+class EnrichmentQueryService:
+    """Finds the latest commit with enrichments for a trackable.
+
+    Orchestrates domain services and repositories to fulfill the use case.
+    """
+
+    def __init__(
+        self,
+        trackable_resolution: TrackableResolutionService,
+        enrichment_repo: EnrichmentV2Repository,
+    ) -> None:
+        """Initialize the enrichment query service."""
+        self.trackable_resolution = trackable_resolution
+        self.enrichment_repo = enrichment_repo
+        self.log = structlog.get_logger(__name__)
+
+    async def find_latest_enriched_commit(
+        self,
+        trackable: Trackable,
+        enrichment_type: str | None = None,
+        max_commits_to_check: int = 100,
+    ) -> str | None:
+        """Find the most recent commit with enrichments.
+
+        Args:
+            trackable: What to track (branch, tag, or commit)
+            enrichment_type: Optional filter for specific enrichment type
+            max_commits_to_check: How far back in history to search
+
+        Returns:
+            Commit SHA of the most recent commit with enrichments, or None
+
+        """
+        # Get candidate commits from the trackable
+        candidate_commits = await self.trackable_resolution.resolve_to_commits(
+            trackable, max_commits_to_check
+        )
+
+        if not candidate_commits:
+            return None
+
+        # Check which commits have enrichments
+        enrichments = await self.enrichment_repo.enrichments_for_entity_type(
+            entity_type="git_commit",
+            entity_ids=candidate_commits,
+        )
+
+        # Filter by type if specified
+        if enrichment_type:
+            enrichments = [e for e in enrichments if e.type == enrichment_type]
+
+        # Find the first commit (newest) that has enrichments
+        for commit_sha in candidate_commits:
+            if any(e.entity_id == commit_sha for e in enrichments):
+                return commit_sha
+
+        return None
+
+    async def get_enrichments_for_commit(
+        self,
+        commit_sha: str,
+        enrichment_type: str | None = None,
+    ) -> list[EnrichmentV2]:
+        """Get all enrichments for a specific commit.
+
+        Args:
+            commit_sha: The commit SHA to get enrichments for
+            enrichment_type: Optional filter for specific enrichment type
+
+        Returns:
+            List of enrichments for the commit
+
+        """
+        enrichments = await self.enrichment_repo.enrichments_for_entity_type(
+            entity_type="git_commit",
+            entity_ids=[commit_sha],
+        )
+
+        # Filter by type if specified
+        if enrichment_type:
+            enrichments = [e for e in enrichments if e.type == enrichment_type]
+
+        return enrichments

kodit/config.py

@@ -70,6 +70,18 @@ class Endpoint(BaseModel):
         default=60,
         description="Request timeout in seconds",
     )
+    max_retries: int = Field(
+        default=5,
+        description="Maximum number of retries for the endpoint",
+    )
+    initial_delay: float = Field(
+        default=2.0,
+        description="Initial delay in seconds for the endpoint",
+    )
+    backoff_factor: float = Field(
+        default=2.0,
+        description="Backoff factor for the endpoint",
+    )
     extra_params: dict[str, Any] | None = Field(
         default=None,
         description="Extra provider-specific non-secret parameters for LiteLLM",

kodit/domain/tracking/__init__.py

@@ -0,0 +1 @@
+"""Tracking domain module."""

kodit/domain/tracking/resolution_service.py

@@ -0,0 +1,81 @@
+"""Domain service for resolving trackables to commits."""
+
+import structlog
+
+from kodit.domain.protocols import (
+    GitBranchRepository,
+    GitCommitRepository,
+    GitTagRepository,
+)
+from kodit.domain.tracking.trackable import Trackable, TrackableReferenceType
+
+
+class TrackableResolutionService:
+    """Resolves trackables to ordered lists of commits.
+
+    This is a domain service because it orchestrates multiple aggregates
+    (branches, tags, commits) without belonging to any single entity.
+    """
+
+    def __init__(
+        self,
+        commit_repo: GitCommitRepository,
+        branch_repo: GitBranchRepository,
+        tag_repo: GitTagRepository,
+    ) -> None:
+        """Initialize the trackable resolution service."""
+        self.commit_repo = commit_repo
+        self.branch_repo = branch_repo
+        self.tag_repo = tag_repo
+        self.log = structlog.get_logger(__name__)
+
+    async def resolve_to_commits(
+        self, trackable: Trackable, limit: int = 100
+    ) -> list[str]:
+        """Resolve a trackable to an ordered list of commit SHAs.
+
+        Returns commits from newest to oldest based on git history.
+        """
+        if trackable.type == TrackableReferenceType.BRANCH:
+            return await self._resolve_branch(trackable, limit)
+        if trackable.type == TrackableReferenceType.TAG:
+            return await self._resolve_tag(trackable, limit)
+        # COMMIT_SHA
+        return [trackable.identifier]
+
+    async def _resolve_branch(
+        self, trackable: Trackable, limit: int
+    ) -> list[str]:
+        """Get commits from branch HEAD backwards through history."""
+        branch = await self.branch_repo.get_by_name(
+            trackable.identifier, trackable.repo_id
+        )
+        # Walk commit history from head_commit backwards
+        return await self._walk_commit_history(
+            branch.head_commit.commit_sha, limit
+        )
+
+    async def _resolve_tag(self, trackable: Trackable, limit: int) -> list[str]:
+        """Get commits from tag target backwards through history."""
+        tag = await self.tag_repo.get_by_name(
+            trackable.identifier, trackable.repo_id
+        )
+        return await self._walk_commit_history(
+            tag.target_commit.commit_sha, limit
+        )
+
+    async def _walk_commit_history(
+        self, start_sha: str, limit: int
+    ) -> list[str]:
+        """Walk commit history backwards from start_sha."""
+        result = []
+        current_sha: str | None = start_sha
+
+        for _ in range(limit):
+            if not current_sha:
+                break
+            result.append(current_sha)
+            commit = await self.commit_repo.get_by_sha(current_sha)
+            current_sha = commit.parent_commit_sha or None
+
+        return result

kodit/domain/tracking/trackable.py

@@ -0,0 +1,21 @@
+"""Trackable value objects."""
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class TrackableReferenceType(StrEnum):
+    """Types of git references that can be tracked."""
+
+    BRANCH = "branch"
+    TAG = "tag"
+    COMMIT_SHA = "commit_sha"
+
+
+@dataclass(frozen=True)
+class Trackable:
+    """Represents a trackable reference point in a git repository."""
+
+    type: TrackableReferenceType
+    identifier: str  # e.g., "main", "v1.0.0", "abc123..."
+    repo_id: int

kodit/infrastructure/api/v1/dependencies.py

@@ -13,6 +13,9 @@ from kodit.application.services.code_search_application_service import (
 from kodit.application.services.commit_indexing_application_service import (
     CommitIndexingApplicationService,
 )
+from kodit.application.services.enrichment_query_service import (
+    EnrichmentQueryService,
+)
 from kodit.application.services.queue_service import QueueService
 from kodit.config import AppContext
 from kodit.domain.protocols import (
@@ -155,3 +158,15 @@ async def get_code_search_app_service(
 CodeSearchAppServiceDep = Annotated[
     CodeSearchApplicationService, Depends(get_code_search_app_service)
 ]
+
+
+async def get_enrichment_query_service(
+    server_factory: ServerFactoryDep,
+) -> EnrichmentQueryService:
+    """Get enrichment query service dependency."""
+    return server_factory.enrichment_query_service()
+
+
+EnrichmentQueryServiceDep = Annotated[
+    EnrichmentQueryService, Depends(get_enrichment_query_service)
+]

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

@@ -2,15 +2,22 @@
 
 from fastapi import APIRouter, Depends, HTTPException
 
+from kodit.domain.tracking.trackable import Trackable, TrackableReferenceType
 from kodit.infrastructure.api.middleware.auth import api_key_auth
 from kodit.infrastructure.api.v1.dependencies import (
     CommitIndexingAppServiceDep,
+    EnrichmentQueryServiceDep,
     GitBranchRepositoryDep,
     GitCommitRepositoryDep,
     GitRepositoryDep,
     GitTagRepositoryDep,
     TaskStatusQueryServiceDep,
 )
+from kodit.infrastructure.api.v1.schemas.enrichment import (
+    EnrichmentAttributes,
+    EnrichmentData,
+    EnrichmentListResponse,
+)
 from kodit.infrastructure.api.v1.schemas.repository import (
     RepositoryBranchData,
     RepositoryCommitData,
@@ -259,6 +266,98 @@ async def get_repository_tag(
     )
 
 
+@router.get(
+    "/{repo_id}/enrichments",
+    summary="List latest repository enrichments",
+    responses={404: {"description": "Repository not found"}},
+)
+async def list_repository_enrichments(  # noqa: PLR0913
+    repo_id: str,
+    git_repository: GitRepositoryDep,
+    enrichment_query_service: EnrichmentQueryServiceDep,
+    ref_type: str = "branch",
+    ref_name: str | None = None,
+    enrichment_type: str | None = None,
+    limit: int = 10,
+) -> EnrichmentListResponse:
+    """List the most recent enrichments for a repository.
+
+    Query parameters:
+    - ref_type: Type of reference (branch, tag, or commit_sha). Defaults to "branch".
+    - ref_name: Name of the reference. For branches, defaults to the tracking branch.
+    - enrichment_type: Optional filter for specific enrichment type.
+    - limit: Maximum number of enrichments to return. Defaults to 10.
+    """
+    # Get repository
+    repo = await git_repository.get_by_id(int(repo_id))
+    if not repo:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    # Determine the reference to track
+    if ref_name is None:
+        if ref_type == "branch":
+            # Default to tracking branch
+            if not repo.tracking_branch:
+                raise HTTPException(
+                    status_code=400, detail="No tracking branch configured"
+                )
+            ref_name = repo.tracking_branch.name
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail="ref_name is required for tag and commit_sha references",
+            )
+
+    # Parse ref_type
+    try:
+        trackable_type = TrackableReferenceType(ref_type)
+    except ValueError:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid ref_type: {ref_type}. Must be branch, tag, or commit_sha",
+        ) from None
+
+    # Create trackable
+    trackable = Trackable(
+        type=trackable_type, identifier=ref_name, repo_id=int(repo_id)
+    )
+
+    # Find the latest enriched commit
+    enriched_commit = await enrichment_query_service.find_latest_enriched_commit(
+        trackable=trackable,
+        enrichment_type=enrichment_type,
+        max_commits_to_check=limit * 10,  # Check more commits to find enriched ones
+    )
+
+    # If no enriched commit found, return empty list
+    if not enriched_commit:
+        return EnrichmentListResponse(data=[])
+
+    # Get enrichments for the commit
+    enrichments = await enrichment_query_service.get_enrichments_for_commit(
+        commit_sha=enriched_commit,
+        enrichment_type=enrichment_type,
+    )
+
+    # Map enrichments to API response format
+    enrichment_data = [
+        EnrichmentData(
+            type="enrichment",
+            id=str(enrichment.id) if enrichment.id else "0",
+            attributes=EnrichmentAttributes(
+                type=enrichment.type,
+                subtype=enrichment.subtype,
+                content=enrichment.content,
+                created_at=enrichment.created_at,
+                updated_at=enrichment.updated_at,
+            ),
+        )
+        for enrichment in enrichments
+    ]
+
+    return EnrichmentListResponse(data=enrichment_data)
+
+
 @router.delete(
     "/{repo_id}",
     status_code=204,

kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py

@@ -1,14 +1,9 @@
 """LiteLLM embedding provider implementation."""
 
-import asyncio
 from collections.abc import AsyncGenerator
-from typing import Any
 
-import httpx
-import litellm
 import structlog
 import tiktoken
-from litellm import aembedding
 
 from kodit.config import Endpoint
 from kodit.domain.services.embedding_service import EmbeddingProvider
@@ -16,6 +11,10 @@ from kodit.domain.value_objects import EmbeddingRequest, EmbeddingResponse
 from kodit.infrastructure.embedding.embedding_providers.batching import (
     split_sub_batches,
 )
+from kodit.infrastructure.providers.async_batch_processor import (
+    process_items_concurrently,
+)
+from kodit.infrastructure.providers.litellm_provider import LiteLLMProvider
 
 
 class LiteLLMEmbeddingProvider(EmbeddingProvider):
@@ -34,22 +33,7 @@ class LiteLLMEmbeddingProvider(EmbeddingProvider):
         self.endpoint = endpoint
         self.log = structlog.get_logger(__name__)
         self._encoding: tiktoken.Encoding | None = None
-
-        # 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.endpoint.socket_path:
-            # Create HTTPX client with Unix socket transport
-            transport = httpx.AsyncHTTPTransport(uds=self.endpoint.socket_path)
-            unix_client = httpx.AsyncClient(
-                transport=transport,
-                base_url="http://localhost",  # Base URL for Unix socket
-                timeout=self.endpoint.timeout,
-            )
-            # Set as LiteLLM's async client session
-            litellm.aclient_session = unix_client
+        self.provider: LiteLLMProvider = LiteLLMProvider(self.endpoint)
 
     def _split_sub_batches(
         self, encoding: tiktoken.Encoding, data: list[EmbeddingRequest]
@@ -62,45 +46,6 @@ class LiteLLMEmbeddingProvider(EmbeddingProvider):
             batch_size=self.endpoint.num_parallel_tasks,
         )
 
-    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.endpoint.model,
-            "input": texts,
-            "timeout": self.endpoint.timeout,
-        }
-
-        # Add API key if provided
-        if self.endpoint.api_key:
-            kwargs["api_key"] = self.endpoint.api_key
-
-        # Add base_url if provided
-        if self.endpoint.base_url:
-            kwargs["api_base"] = self.endpoint.base_url
-
-        # Add extra parameters
-        kwargs.update(self.endpoint.extra_params or {})
-
-        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.endpoint.model
-            )
-            raise
-
     async def embed(
         self, data: list[EmbeddingRequest]
     ) -> AsyncGenerator[list[EmbeddingResponse], None]:
@@ -113,39 +58,45 @@ class LiteLLMEmbeddingProvider(EmbeddingProvider):
         encoding = self._get_encoding()
         batched_data = self._split_sub_batches(encoding, data)
 
-        # Process batches concurrently with semaphore
-        sem = asyncio.Semaphore(self.endpoint.num_parallel_tasks or 10)
-
         async def _process_batch(
             batch: list[EmbeddingRequest],
         ) -> list[EmbeddingResponse]:
-            async with sem:
-                response = await self._call_embeddings_api(
-                    [item.text for item in batch]
+            texts = [item.text for item in batch]
+            response = await self.provider.embedding(texts)
+            embeddings_data = response.get("data", [])
+
+            # Handle mismatch between batch size and response size
+            if len(embeddings_data) != len(batch):
+                preview_response = embeddings_data[:3] if embeddings_data else None
+                self.log.error(
+                    "Embedding response size mismatch",
+                    batch_size=len(batch),
+                    response_size=len(embeddings_data),
+                    texts_preview=[t[:50] for t in texts[:3]],
+                    response_preview=preview_response,
+                )
+                raise ValueError(
+                    f"Expected {len(batch)} embeddings, got {len(embeddings_data)}"
                 )
-                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)
-                ]
+            return [
+                EmbeddingResponse(
+                    snippet_id=item.snippet_id,
+                    embedding=emb_data.get("embedding", []),
+                )
+                for item, emb_data in zip(batch, embeddings_data, strict=True)
+            ]
 
-        tasks = [_process_batch(batch) for batch in batched_data]
-        for task in asyncio.as_completed(tasks):
-            yield await task
+        async for result in process_items_concurrently(
+            batched_data,
+            _process_batch,
+            self.endpoint.num_parallel_tasks,
+        ):
+            yield result
 
     async def close(self) -> None:
-        """Close the provider and cleanup HTTPX client if using Unix sockets."""
-        if (
-            self.endpoint.socket_path
-            and hasattr(litellm, "aclient_session")
-            and litellm.aclient_session
-        ):
-            await litellm.aclient_session.aclose()
-            litellm.aclient_session = None
+        """Close the provider."""
+        await self.provider.close()
 
     def _get_encoding(self) -> tiktoken.Encoding:
         """Return (and cache) the tiktoken encoding for the chosen model."""

kodit/infrastructure/enricher/litellm_enricher.py

@@ -1,21 +1,18 @@
 """LiteLLM enricher 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.enrichments.enricher import Enricher
 from kodit.domain.enrichments.request import EnrichmentRequest
 from kodit.domain.enrichments.response import EnrichmentResponse
 from kodit.infrastructure.enricher.utils import clean_thinking_tags
-
-DEFAULT_NUM_PARALLEL_TASKS = 20
+from kodit.infrastructure.providers.async_batch_processor import (
+    process_items_concurrently,
+)
+from kodit.infrastructure.providers.litellm_provider import LiteLLMProvider
 
 
 class LiteLLMEnricher(Enricher):
@@ -32,64 +29,8 @@ class LiteLLMEnricher(Enricher):
 
         """
         self.log = structlog.get_logger(__name__)
-        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
-        self.extra_params = endpoint.extra_params or {}
-
-        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:
-            transport = httpx.AsyncHTTPTransport(uds=self.socket_path)
-            unix_client = httpx.AsyncClient(
-                transport=transport,
-                base_url="http://localhost",
-                timeout=self.timeout,
-            )
-            litellm.aclient_session = unix_client
-
-    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.
-
-        Returns:
-            The API response as a dictionary.
-
-        """
-        kwargs = {
-            "model": self.model_name,
-            "messages": messages,
-            "timeout": self.timeout,
-        }
-
-        if self.api_key:
-            kwargs["api_key"] = self.api_key
-
-        if self.base_url:
-            kwargs["api_base"] = self.base_url
-
-        kwargs.update(self.extra_params)
-
-        try:
-            response = await acompletion(**kwargs)
-            self.log.debug("enrichment request", request=kwargs, response=response)
-            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
+        self.provider: LiteLLMProvider = LiteLLMProvider(endpoint)
+        self.endpoint = endpoint
 
     async def enrich(
         self, requests: list[EnrichmentRequest]
@@ -107,47 +48,36 @@ class LiteLLMEnricher(Enricher):
             self.log.warning("No requests for enrichment")
             return
 
-        sem = asyncio.Semaphore(self.num_parallel_tasks)
-
         async def process_request(
             request: EnrichmentRequest,
         ) -> EnrichmentResponse:
-            async with sem:
-                if not request.text:
-                    return EnrichmentResponse(
-                        id=request.id,
-                        text="",
-                    )
-                messages = [
-                    {
-                        "role": "system",
-                        "content": request.system_prompt,
-                    },
-                    {"role": "user", "content": request.text},
-                ]
-                response = await self._call_chat_completion(messages)
-                content = (
-                    response.get("choices", [{}])[0]
-                    .get("message", {})
-                    .get("content", "")
-                )
-                cleaned_content = clean_thinking_tags(content or "")
+            if not request.text:
                 return EnrichmentResponse(
                     id=request.id,
-                    text=cleaned_content,
+                    text="",
                 )
+            messages = [
+                {
+                    "role": "system",
+                    "content": request.system_prompt,
+                },
+                {"role": "user", "content": request.text},
+            ]
+            response = await self.provider.chat_completion(messages)
+            content = (
+                response.get("choices", [{}])[0].get("message", {}).get("content", "")
+            )
+            cleaned_content = clean_thinking_tags(content or "")
+            return EnrichmentResponse(
+                id=request.id,
+                text=cleaned_content,
+            )
 
-        tasks = [process_request(request) for request in requests]
-
-        for task in asyncio.as_completed(tasks):
-            yield await task
+        async for result in process_items_concurrently(
+            requests, process_request, self.endpoint.num_parallel_tasks
+        ):
+            yield result
 
     async def close(self) -> None:
         """Close the enricher 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
+        await self.provider.close()

kodit/infrastructure/providers/__init__.py

@@ -0,0 +1 @@
+"""Provider utilities for LiteLLM and async batch processing."""

kodit/infrastructure/providers/async_batch_processor.py

@@ -0,0 +1,51 @@
+"""Generic async batch processor with semaphore-controlled concurrency."""
+
+import asyncio
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from typing import TypeVar
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+async def process_items_concurrently(
+    items: list[T],
+    process_fn: Callable[[T], Awaitable[R]],
+    max_parallel_tasks: int,
+) -> AsyncGenerator[R, None]:
+    """Process items concurrently with semaphore-controlled concurrency.
+
+    Args:
+        items: List of items to process.
+        process_fn: Async function to process each item.
+        max_parallel_tasks: Maximum number of concurrent tasks.
+
+    Yields:
+        Results as they are completed (not necessarily in order).
+
+    """
+    if not items:
+        return
+
+    sem = asyncio.Semaphore(max_parallel_tasks)
+
+    async def _process_with_semaphore(item: T) -> R:
+        async with sem:
+            return await process_fn(item)
+
+    tasks: list[asyncio.Task[R]] = [
+        asyncio.create_task(_process_with_semaphore(item)) for item in items
+    ]
+
+    try:
+        for task in asyncio.as_completed(tasks):
+            yield await task
+    finally:
+        # Cancel any remaining tasks when generator exits
+        # (due to exception, Ctrl+C, or early consumer termination)
+        for task in tasks:
+            if not task.done():
+                task.cancel()
+
+        # Wait for all tasks to finish cancelling
+        await asyncio.gather(*tasks, return_exceptions=True)

kodit/infrastructure/providers/litellm_provider.py

@@ -0,0 +1,132 @@
+"""LiteLLM provider implementation."""
+
+import asyncio
+import functools
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+import litellm
+import structlog
+from litellm import acompletion, aembedding
+
+from kodit.config import Endpoint
+
+ProviderMaxRetriesError = Exception("LiteLLM API error: Max retries exceeded")
+
+RETRYABLE_ERRORS = (
+    litellm.exceptions.Timeout,
+    litellm.exceptions.RateLimitError,
+    litellm.exceptions.InternalServerError,
+    litellm.exceptions.ServiceUnavailableError,
+    litellm.exceptions.APIConnectionError,
+    litellm.exceptions.MidStreamFallbackError,
+)
+
+
+def litellm_retry(
+    func: Callable[..., Coroutine[Any, Any, Any]],
+) -> Callable[..., Coroutine[Any, Any, Any]]:
+    """Retry decorator for LiteLLM API calls with exponential backoff.
+
+    Extracts retry configuration from the endpoint attribute of the first
+    argument (self) if it's a LiteLLMProvider instance.
+    """
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # Extract endpoint configuration from self if available
+        endpoint = None
+        if args and hasattr(args[0], "endpoint"):
+            endpoint = args[0].endpoint
+
+        # Use endpoint configuration or fall back to defaults
+        max_retries = endpoint.max_retries if endpoint else 5
+        initial_delay = endpoint.initial_delay if endpoint else 2.0
+        backoff_factor = endpoint.backoff_factor if endpoint else 2.0
+
+        retries = max_retries
+        delay = initial_delay
+        log: structlog.stdlib.BoundLogger = structlog.get_logger(__name__)
+
+        while True:
+            try:
+                return await func(*args, **kwargs)
+            except (asyncio.CancelledError, KeyboardInterrupt):
+                raise
+            except Exception as e:
+                if isinstance(e, RETRYABLE_ERRORS) and retries > 0:
+                    log.warning(
+                        "LiteLLM API error: Retrying",
+                        error=e,
+                        retries=retries,
+                        backoff=delay,
+                    )
+                    try:
+                        await asyncio.sleep(delay)
+                    except (asyncio.CancelledError, KeyboardInterrupt):
+                        # Cancellation during sleep should stop retries immediately
+                        log.info("Retry cancelled during backoff")
+                        raise
+                    retries -= 1
+                    delay *= backoff_factor
+                    continue
+
+                exception_info = {
+                    attr: getattr(e, attr)
+                    for attr in dir(e)
+                    if not attr.startswith("_")
+                }
+                log.exception(
+                    "LiteLLM API error, check provider logs for details",
+                    error=e,
+                    exception_info=exception_info,
+                    retries=retries,
+                    backoff=delay,
+                )
+                raise
+
+    return wrapper
+
+
+class LiteLLMProvider:
+    """LiteLLM provider that supports 100+ providers."""
+
+    def __init__(self, endpoint: Endpoint) -> None:
+        """Initialize the LiteLLM provider."""
+        self.endpoint = endpoint
+
+    def _populate_base_kwargs(self) -> dict[str, Any]:
+        """Populate base kwargs common to all API calls."""
+        kwargs = {
+            "model": self.endpoint.model,
+            "timeout": self.endpoint.timeout,
+        }
+
+        if self.endpoint.api_key:
+            kwargs["api_key"] = self.endpoint.api_key
+
+        if self.endpoint.base_url:
+            kwargs["api_base"] = self.endpoint.base_url
+
+        kwargs.update(self.endpoint.extra_params or {})
+
+        return kwargs
+
+    @litellm_retry
+    async def chat_completion(self, messages: list[dict[str, str]]) -> Any:
+        """Call the chat completion API using LiteLLM."""
+        kwargs = self._populate_base_kwargs()
+        kwargs["messages"] = messages
+        response = await acompletion(max_retries=0, **kwargs)
+        return response.model_dump()
+
+    @litellm_retry
+    async def embedding(self, texts: list[str]) -> Any:
+        """Call the embedding API using LiteLLM."""
+        kwargs = self._populate_base_kwargs()
+        kwargs["input"] = texts
+        response = await aembedding(max_retries=0, **kwargs)
+        return response.model_dump()
+
+    async def close(self) -> None:
+        """Close the provider - litellm handles its own connection cleanup."""

kodit/log.py

@@ -1,6 +1,7 @@
 """Logging configuration for kodit."""
 
 import logging
+import os
 import platform
 import re
 import shutil
@@ -11,6 +12,9 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
+# Set litellm logging level BEFORE import to prevent broken logging objects
+os.environ["LITELLM_LOG"] = "ERROR"
+
 import litellm
 import rudderstack.analytics as rudder_analytics  # type: ignore[import-untyped]
 import structlog
@@ -108,9 +112,14 @@ def configure_logging(app_context: AppContext) -> None:
         else:
             logging.getLogger(_log).disabled = True
 
-    # More litellm logging cruft
+    # Disable litellm's internal debug logging
     litellm.suppress_debug_info = True
 
+    # Monkey-patch litellm's Logging class to add missing debug method
+    # This prevents AttributeError when litellm tries to call logging_obj.debug()
+    if not hasattr(litellm.Logging, "debug"):
+        litellm.Logging.debug = lambda _self, *_args, **_kwargs: None  # type: ignore[attr-defined]
+
     # Configure SQLAlchemy loggers to use our structlog setup
     for _log in ["sqlalchemy.engine", "alembic"]:
         engine_logger = logging.getLogger(_log)

{kodit-0.5.1.dist-info → kodit-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.5.1
+Version: 0.5.3
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/

{kodit-0.5.1.dist-info → kodit-0.5.3.dist-info}/RECORD

@@ -1,22 +1,23 @@
 kodit/.gitignore,sha256=ztkjgRwL9Uud1OEi36hGQeDGk3OLK1NfDEO8YqGYy8o,11
 kodit/__init__.py,sha256=aEKHYninUq1yh6jaNfvJBYg-6fenpN132nJt1UU6Jxs,59
-kodit/_version.py,sha256=cYMOhuaBHd0MIZmumuccsEQ-AxM8LIJy9dsBAWgOpqE,704
+kodit/_version.py,sha256=EWl7XaGZUG57Di8WiRltpKAkwy1CShJuJ-i6_rAPr-w,704
 kodit/app.py,sha256=niIfZiuuDp7mLzrBwQhx_FU7RvKfUALNV5y0o43miss,5802
 kodit/cli.py,sha256=QSTXIUDxZo3anIONY-grZi9_VSehWoS8QoVJZyOmWPQ,3086
 kodit/cli_utils.py,sha256=umkvt4kWNapk6db6RGz6bmn7oxgDpsW2Vo09MZ37OGg,2430
-kodit/config.py,sha256=s3xm0ve_Sw5LllAA-PKzka3OF-ucQ4F0O8XqZcJ7-Yc,7667
+kodit/config.py,sha256=x_67lawaejOenJvl8yMxzXgdIkeWx8Yyc2ISO37GCvc,8031
 kodit/database.py,sha256=Pjxx0k431_lCqAJwE3FpLfs74qz1l5JFUQX1TD-wgSs,3264
-kodit/log.py,sha256=ZpM0eMo_DVGQqrHxg0VV6dMrN2AAmu_3C0I3G7p2nMw,8828
+kodit/log.py,sha256=vaucGfLv1qTsLmx-1cMLxKkUthey_P9NKzRogFzkOi0,9265
 kodit/mcp.py,sha256=PwMogCaYwEJ289y_8-LkLQrL00q2vesYRVxix6-4nuE,7166
 kodit/middleware.py,sha256=TiwebNpaEmiP7QRuZrfZcCL51IUefQyNLSPuzVyk8UM,2813
 kodit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kodit/application/__init__.py,sha256=mH50wTpgP9dhbKztFsL8Dda9Hi18TSnMVxXtpp4aGOA,35
 kodit/application/factories/__init__.py,sha256=bU5CvEnaBePZ7JbkCOp1MGTNP752bnU2uEqmfy5FdRk,37
 kodit/application/factories/reporting_factory.py,sha256=3IpRiAw_olM69db-jbDAtjyGtd6Nh5o8jUJX3-rXCA8,1421
-kodit/application/factories/server_factory.py,sha256=NrOFLbkKsLpymNBYbuvoWdRznV5YRh_BsoLQjx3_i_o,15185
+kodit/application/factories/server_factory.py,sha256=RJ-u0IpKSahq__ZzxP3yPyJ5sVWgGJhyxNbI9uIu-ZY,16251
 kodit/application/services/__init__.py,sha256=p5UQNw-H5sxQvs5Etfte93B3cJ1kKW6DNxK34uFvU1E,38
 kodit/application/services/code_search_application_service.py,sha256=sqMgyAw7e2d2FWroaonaL8G1Hwigb-Yku71dut3wOpQ,4963
 kodit/application/services/commit_indexing_application_service.py,sha256=S5Gep4aXB9_1CWxs9xcIMnGmsrfrwJqvfDAHIPhoS1k,29860
+kodit/application/services/enrichment_query_service.py,sha256=4wtBPwLbmgFCDgYam1D6x6EgSDGEJeQgAt_opzQz5rs,3102
 kodit/application/services/indexing_worker_service.py,sha256=8J8CaUdPd5nF6MyvJbJQpXeGkP2oClmFjZel1xBXELU,4065
 kodit/application/services/queue_service.py,sha256=nXplzN-nehPEeEvygzjJwWg4oQmu3SPodsZzY1Z3MtE,2509
 kodit/application/services/reporting.py,sha256=cwe-S-UpSOE6xSAEhoD1hi4hSWk1bW3YRLJ7463fIvM,3518
@@ -50,11 +51,13 @@ kodit/domain/factories/git_repo_factory.py,sha256=4yaa-waMbzapNtldHG1oxBVMuI6JB-
 kodit/domain/services/__init__.py,sha256=Q1GhCK_PqKHYwYE4tkwDz5BIyXkJngLBBOHhzvX8nzo,42
 kodit/domain/services/bm25_service.py,sha256=-E5k0td2Ucs25qygWkJlY0fl7ZckOUe5xZnKYff3hF8,3631
 kodit/domain/services/embedding_service.py,sha256=al-vBd7H9KuCqZTWtC7q8CEDVXaIQhDhvMFV9IxWasU,4663
-kodit/domain/services/enrichment_service.py,sha256=ziFaYqTYE5R2LTgirYDCniQxVuB1d3ZeONEalyaS_o0,858
 kodit/domain/services/git_repository_service.py,sha256=b-zAAFVxU22KKp2ACyKUgOpFKK7uar4PV5mqoN0Vgzk,15534
 kodit/domain/services/git_service.py,sha256=nVQCfXQ8kW-MAAoAd8bgSQmCdgPMVftUh5qd4du_bes,11352
 kodit/domain/services/physical_architecture_service.py,sha256=0YgoAvbUxT_VwgIh_prftSYnil_XIqNPSoP0g37eIt4,7209
 kodit/domain/services/task_status_query_service.py,sha256=rI93pTMHeycigQryCWkimXSDzRqx_nJOr07UzPAacPE,736
+kodit/domain/tracking/__init__.py,sha256=5FvxhDxB2Fpr8Dw8BLtjfPE1YUWn2rr3u7njQlqcosk,30
+kodit/domain/tracking/resolution_service.py,sha256=w9OMgNv0ZS1DiduY-XFTA_pWK9vXgoEvEGLBl1vqRHE,2765
+kodit/domain/tracking/trackable.py,sha256=-9UT-c5iDkg5LxLl-BEyysvrKgHoYfofuGUacjPhVk4,479
 kodit/infrastructure/__init__.py,sha256=HzEYIjoXnkz_i_MHO2e0sIVYweUcRnl2RpyBiTbMObU,28
 kodit/infrastructure/api/__init__.py,sha256=U0TSMPpHrlj1zbAtleuZjU3nXGwudyMe-veNBgvODwM,34
 kodit/infrastructure/api/client/__init__.py,sha256=8MjEc6cHCqiI-LtIyng3uKD7a2wUaR-QUdIAePYyIRg,292
@@ -65,11 +68,11 @@ kodit/infrastructure/api/client/search_client.py,sha256=f4mM5ZJpAuR7w-i9yASbh4SY
 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=xWtkR3UP7daksCXW_Eyvcqsh091OREqfBPnlFs027_o,22
-kodit/infrastructure/api/v1/dependencies.py,sha256=S0U1oY0CH8rQpF685d1eT2TE6KgbCWsav1E4HIss5KQ,4457
+kodit/infrastructure/api/v1/dependencies.py,sha256=VZhSBgPF1lTc7UnayXl5RsHkA6EvHkGl8NLHPUedjU0,4875
 kodit/infrastructure/api/v1/routers/__init__.py,sha256=pz_7kFwHcxztbTiFI-57Q2tCAllI7u0fgTP4rpQeUoQ,22
 kodit/infrastructure/api/v1/routers/commits.py,sha256=osjmm2Po-MOshD7zBv01C12UcYukkaKATtjEa3hSAJU,11624
 kodit/infrastructure/api/v1/routers/queue.py,sha256=srZmOCZqvcCBlDcPYt1ZWhwVhvVWARWJ3Qp4Tn5eK4Y,2148
-kodit/infrastructure/api/v1/routers/repositories.py,sha256=pxdCCMQWAsezkwyj-rNG-eQbtlW8wMaXZwfzHmae3sI,9328
+kodit/infrastructure/api/v1/routers/repositories.py,sha256=fDc73mt9tc1oqa35LGXr8WpG3zIS6QNuQu9qu15l0I0,12758
 kodit/infrastructure/api/v1/routers/search.py,sha256=eMlofqcy9xWCsE9ugfBZHtcPo1hb-A06_Xfv4XR3FfY,3187
 kodit/infrastructure/api/v1/schemas/__init__.py,sha256=capaxPe7y28pWj6Pu5hfTOxLnVL9pwW-hJu7ZdN2klw,41
 kodit/infrastructure/api/v1/schemas/commit.py,sha256=UVGkwZNjwUMiitUbFws1_mlZN7IALq99P99HJCg5h2c,1794
@@ -94,11 +97,11 @@ kodit/infrastructure/embedding/vectorchord_vector_search_repository.py,sha256=nI
 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=9Q5he_MI8xXENODwCvYCbhVawTjTv1bArGQrmxoWLas,5297
+kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py,sha256=RuZ5OvD2CJPzAq7CDRI0GdjyLHoHLEmInzdhlFDMp0U,3795
 kodit/infrastructure/embedding/embedding_providers/local_embedding_provider.py,sha256=9aLV1Zg4KMhYWlGRwgAUtswW4aIabNqbsipWhAn64RI,4133
 kodit/infrastructure/enricher/__init__.py,sha256=5KCwKHnQ3i_-1s5Q8kquUY_Y0BktJMGVrsDJLtTlDNc,55
 kodit/infrastructure/enricher/enricher_factory.py,sha256=R2UlmCrMW55nvPHHf5Aj0soEBr7T_XU1dgDWwqs49Cg,1593
-kodit/infrastructure/enricher/litellm_enricher.py,sha256=q3V6frb29yzmodzqQ6TDovbSmittiwHtoPNYy5x4dLQ,4866
+kodit/infrastructure/enricher/litellm_enricher.py,sha256=ZWqQQxtuWAr7SpdfxNtLq6GUmTpXGWADoOAEuhFX8ls,2666
 kodit/infrastructure/enricher/local_enricher.py,sha256=AUzmpjlPK7LGaX5DO8thmvfdwNPLLHCB4W5wyudqk3k,4317
 kodit/infrastructure/enricher/null_enricher.py,sha256=Vu3agCTXROzYl2MzM8gVgH2rMw_FHIkgH-S1vijKw_0,1048
 kodit/infrastructure/enricher/utils.py,sha256=FE9UCuxxzSdoHrmAC8Si2b5D6Nf6kVqgM1yjUVyCvW0,930
@@ -119,6 +122,9 @@ kodit/infrastructure/physical_architecture/detectors/__init__.py,sha256=z8JzHOy8
 kodit/infrastructure/physical_architecture/detectors/docker_compose_detector.py,sha256=NQWN24eV_wl3tDMsCnL2FbcBsGz2y-4pEfASBejeAKg,13245
 kodit/infrastructure/physical_architecture/formatters/__init__.py,sha256=2OCvhVKGUTHusxlsqRbLk8cNtzZ9HrGqnKYcozuLOE0,81
 kodit/infrastructure/physical_architecture/formatters/narrative_formatter.py,sha256=43bERS_iGhL94pkUV2Bn5vjeaHPxjHatuDh7dHreh_M,5713
+kodit/infrastructure/providers/__init__.py,sha256=XjB6DIQIXRrwRhSY32EF3QhZGTWNWsBZA5pwUc--ZZc,65
+kodit/infrastructure/providers/async_batch_processor.py,sha256=0GkfBfOdQWoZ9JL-_ZCqtlpL2R19nUUn-fhK9y0O0s0,1466
+kodit/infrastructure/providers/litellm_provider.py,sha256=Ybxws56fUKhN-Cku43vdmhlIINmwM7v9LckWnfowjCc,4504
 kodit/infrastructure/reporting/__init__.py,sha256=4Qu38YbDOaeDqLdT_CbK8tOZHTKGrHRXncVKlGRzOeQ,32
 kodit/infrastructure/reporting/db_progress.py,sha256=VVaCKjC_UFwdRptXbBroG9qhXCxI4bZmElf1PMsBzWA,819
 kodit/infrastructure/reporting/log_progress.py,sha256=yhzkjYulEn_sfpKwHKi--HdQHLb4h4uEolhFYqvdHS8,1261
@@ -161,8 +167,8 @@ kodit/utils/dump_config.py,sha256=dd5uPgqh6ATk02Zt59t2JFKR9X17YWjHudV0nE8VktE,11
 kodit/utils/dump_openapi.py,sha256=EasYOnnpeabwb_sTKQUBrrOLHjPcOFQ7Zx0YKpx9fmM,1239
 kodit/utils/generate_api_paths.py,sha256=TMtx9v55podDfUmiWaHgJHLtEWLV2sLL-5ejGFMPzAo,3569
 kodit/utils/path_utils.py,sha256=UB_81rx7Y1G1jalVv2PX8miwaprBbcqEdtoQ3hPT3kU,2451
-kodit-0.5.1.dist-info/METADATA,sha256=HyFZ0U2-rvusI_5CIa3Z1BOaER_--WZEyy_g3i1BHg8,7703
-kodit-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kodit-0.5.1.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
-kodit-0.5.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kodit-0.5.1.dist-info/RECORD,,
+kodit-0.5.3.dist-info/METADATA,sha256=340z0xqhe7h6HOYh85xfIIryGRIBuNLzHI50L2-EdFI,7703
+kodit-0.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kodit-0.5.3.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
+kodit-0.5.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kodit-0.5.3.dist-info/RECORD,,

kodit/domain/services/enrichment_service.py

@@ -1,27 +0,0 @@
-"""Domain service for enrichment operations."""
-
-from collections.abc import AsyncGenerator
-
-from kodit.domain.enrichments.enricher import Enricher
-from kodit.domain.enrichments.request import EnrichmentRequest
-from kodit.domain.enrichments.response import EnrichmentResponse
-
-
-class EnrichmentDomainService:
-    """Domain service for enrichment operations."""
-
-    def __init__(self, enricher: Enricher) -> None:
-        """Initialize the enrichment domain service."""
-        self.enricher = enricher
-
-    async def enrich_documents(
-        self, requests: list[EnrichmentRequest]
-    ) -> AsyncGenerator[EnrichmentResponse, None]:
-        """Enrich documents using the enricher.
-
-        Yields:
-            Enrichment responses as they are processed.
-
-        """
-        async for response in self.enricher.enrich(requests):
-            yield response