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

kodit/infrastructure/enricher/enricher_factory.py

@@ -0,0 +1,53 @@
+"""Enricher factory for creating generic enricher domain services."""
+
+from kodit.config import AppContext, Endpoint
+from kodit.domain.enrichments.enricher import Enricher
+from kodit.infrastructure.enricher.litellm_enricher import LiteLLMEnricher
+from kodit.infrastructure.enricher.local_enricher import LocalEnricher
+from kodit.infrastructure.enricher.null_enricher import NullEnricher
+from kodit.log import log_event
+
+
+def _get_endpoint_configuration(app_context: AppContext) -> Endpoint | None:
+    """Get the endpoint configuration for the enricher service.
+
+    Args:
+        app_context: The application context.
+
+    Returns:
+        The endpoint configuration or None.
+
+    """
+    return app_context.enrichment_endpoint or None
+
+
+def enricher_domain_service_factory(
+    app_context: AppContext,
+    *,
+    use_null_enricher: bool = False,
+) -> Enricher:
+    """Create an enricher domain service.
+
+    Args:
+        app_context: The application context.
+        use_null_enricher: Whether to use the null enricher instead.
+
+    Returns:
+        An enricher domain service instance.
+
+    """
+    enricher: Enricher
+
+    if use_null_enricher:
+        log_event("kodit.enricher", {"provider": "null"})
+        enricher = NullEnricher()
+    else:
+        endpoint = _get_endpoint_configuration(app_context)
+        if endpoint:
+            log_event("kodit.enricher", {"provider": "litellm"})
+            enricher = LiteLLMEnricher(endpoint=endpoint)
+        else:
+            log_event("kodit.enricher", {"provider": "local"})
+            enricher = LocalEnricher()
+
+    return enricher

kodit/infrastructure/{enrichment/litellm_enrichment_provider.py → enricher/litellm_enricher.py}

@@ -1,4 +1,4 @@
-"""LiteLLM enrichment provider implementation."""
+"""LiteLLM enricher implementation."""
 
 import asyncio
 from collections.abc import AsyncGenerator
@@ -10,27 +10,22 @@ 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
+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
 
-ENRICHMENT_SYSTEM_PROMPT = """
-You are a professional software developer. You will be given a snippet of code.
-Please provide a concise explanation of the code.
-"""
-
-# Default tuned conservatively for broad provider compatibility
 DEFAULT_NUM_PARALLEL_TASKS = 20
 
 
-class LiteLLMEnrichmentProvider(EnrichmentProvider):
-    """LiteLLM enrichment provider that supports 100+ providers."""
+class LiteLLMEnricher(Enricher):
+    """LiteLLM enricher that supports 100+ providers."""
 
     def __init__(
         self,
         endpoint: Endpoint,
     ) -> None:
-        """Initialize the LiteLLM enrichment provider.
+        """Initialize the LiteLLM enricher.
 
         Args:
             endpoint: The endpoint configuration containing all settings.
@@ -44,23 +39,20 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
         self.num_parallel_tasks = (
             endpoint.num_parallel_tasks or DEFAULT_NUM_PARALLEL_TASKS
         )
-        self.timeout = endpoint.timeout or 30.0
+        self.timeout = endpoint.timeout
         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
+                base_url="http://localhost",
                 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]]) -> Any:
@@ -79,20 +71,17 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
             "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 completion function
             response = await acompletion(**kwargs)
+            self.log.debug("enrichment request", request=kwargs, response=response)
             return (
                 response.model_dump() if hasattr(response, "model_dump") else response
             )
@@ -108,30 +97,31 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
         """Enrich a list of requests using LiteLLM.
 
         Args:
-            requests: List of enrichment requests.
+            requests: List of generic enrichment requests.
 
         Yields:
-            Enrichment responses as they are processed.
+            Generic enrichment responses as they are processed.
 
         """
         if not requests:
             self.log.warning("No requests for enrichment")
             return
 
-        # 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:
+        async def process_request(
+            request: EnrichmentRequest,
+        ) -> EnrichmentResponse:
             async with sem:
                 if not request.text:
                     return EnrichmentResponse(
-                        snippet_id=request.snippet_id,
+                        id=request.id,
                         text="",
                     )
                 messages = [
                     {
                         "role": "system",
-                        "content": ENRICHMENT_SYSTEM_PROMPT,
+                        "content": request.system_prompt,
                     },
                     {"role": "user", "content": request.text},
                 ]
@@ -141,22 +131,19 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
                     .get("message", {})
                     .get("content", "")
                 )
-                # Remove thinking tags from the response
                 cleaned_content = clean_thinking_tags(content or "")
                 return EnrichmentResponse(
-                    snippet_id=request.snippet_id,
+                    id=request.id,
                     text=cleaned_content,
                 )
 
-        # Create tasks for all requests
         tasks = [process_request(request) for request in requests]
 
-        # Process all requests and yield results as they complete
         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."""
+        """Close the enricher and cleanup HTTPX client if using Unix sockets."""
         if (
             self.socket_path
             and hasattr(litellm, "aclient_session")

kodit/infrastructure/{enrichment/local_enrichment_provider.py → enricher/local_enricher.py}

@@ -1,4 +1,4 @@
-"""Local enrichment provider implementation."""
+"""Local enricher implementation."""
 
 import asyncio
 import os
@@ -8,28 +8,24 @@ from typing import Any
 import structlog
 import tiktoken
 
-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
+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
 
-ENRICHMENT_SYSTEM_PROMPT = """
-You are a professional software developer. You will be given a snippet of code.
-Please provide a concise explanation of the code.
-"""
+DEFAULT_ENRICHER_MODEL = "Qwen/Qwen3-0.6B"
+DEFAULT_CONTEXT_WINDOW_SIZE = 2048
 
-DEFAULT_ENRICHMENT_MODEL = "Qwen/Qwen3-0.6B"
-DEFAULT_CONTEXT_WINDOW_SIZE = 2048  # Small so it works even on low-powered devices
 
-
-class LocalEnrichmentProvider(EnrichmentProvider):
-    """Local enrichment provider implementation."""
+class LocalEnricher(Enricher):
+    """Local enricher implementation using local models."""
 
     def __init__(
         self,
-        model_name: str = DEFAULT_ENRICHMENT_MODEL,
+        model_name: str = DEFAULT_ENRICHER_MODEL,
         context_window: int = DEFAULT_CONTEXT_WINDOW_SIZE,
     ) -> None:
-        """Initialize the local enrichment provider.
+        """Initialize the local enricher.
 
         Args:
             model_name: The model name to use for enrichment.
@@ -49,13 +45,13 @@ class LocalEnrichmentProvider(EnrichmentProvider):
         """Enrich a list of requests using local model.
 
         Args:
-            requests: List of enrichment requests.
+            requests: List of generic enrichment requests.
 
         Yields:
-            Enrichment responses as they are processed.
+            Generic enrichment responses as they are processed.
 
         """
-        # Remove empty snippets
+        # Remove empty requests
         requests = [req for req in requests if req.text]
 
         if not requests:
@@ -73,7 +69,7 @@ class LocalEnrichmentProvider(EnrichmentProvider):
                     self.model_name, padding_side="left"
                 )
             if self.model is None:
-                os.environ["TOKENIZERS_PARALLELISM"] = "false"  # Avoid warnings
+                os.environ["TOKENIZERS_PARALLELISM"] = "false"
                 self.model = AutoModelForCausalLM.from_pretrained(
                     self.model_name,
                     torch_dtype="auto",
@@ -83,13 +79,13 @@ class LocalEnrichmentProvider(EnrichmentProvider):
 
         await asyncio.to_thread(_init_model)
 
-        # Prepare prompts
+        # Prepare prompts with custom system prompts
         prompts = [
             {
-                "id": req.snippet_id,
+                "id": req.id,
                 "text": self.tokenizer.apply_chat_template(  # type: ignore[attr-defined]
                     [
-                        {"role": "system", "content": ENRICHMENT_SYSTEM_PROMPT},
+                        {"role": "system", "content": req.system_prompt},
                         {"role": "user", "content": req.text},
                     ],
                     tokenize=False,
@@ -121,9 +117,8 @@ class LocalEnrichmentProvider(EnrichmentProvider):
                 )
 
             content = await asyncio.to_thread(process_prompt, prompt)
-            # Remove thinking tags from the response
             cleaned_content = clean_thinking_tags(content)
             yield EnrichmentResponse(
-                snippet_id=prompt["id"],
+                id=prompt["id"],
                 text=cleaned_content,
             )

kodit/infrastructure/enricher/null_enricher.py

@@ -0,0 +1,36 @@
+"""Null enricher implementation."""
+
+from collections.abc import AsyncGenerator
+
+import structlog
+
+from kodit.domain.enrichments.enricher import Enricher
+from kodit.domain.enrichments.request import EnrichmentRequest
+from kodit.domain.enrichments.response import EnrichmentResponse
+
+
+class NullEnricher(Enricher):
+    """Null enricher that returns empty responses."""
+
+    def __init__(self) -> None:
+        """Initialize the null enricher."""
+        self.log = structlog.get_logger(__name__)
+
+    async def enrich(
+        self, requests: list[EnrichmentRequest]
+    ) -> AsyncGenerator[EnrichmentResponse, None]:
+        """Return empty responses for all requests.
+
+        Args:
+            requests: List of generic enrichment requests.
+
+        Yields:
+            Empty generic enrichment responses.
+
+        """
+        self.log.info("NullEnricher: returning empty responses", count=len(requests))
+        for request in requests:
+            yield EnrichmentResponse(
+                id=request.id,
+                text="",
+            )

kodit/infrastructure/mappers/enrichment_mapper.py

@@ -0,0 +1,83 @@
+"""Enrichment mapper."""
+
+from kodit.domain.enrichments.architecture.architecture import (
+    ENRICHMENT_TYPE_ARCHITECTURE,
+)
+from kodit.domain.enrichments.architecture.physical.physical import (
+    ENRICHMENT_SUBTYPE_PHYSICAL,
+    PhysicalArchitectureEnrichment,
+)
+from kodit.domain.enrichments.development.development import ENRICHMENT_TYPE_DEVELOPMENT
+from kodit.domain.enrichments.development.snippet.snippet import (
+    ENRICHMENT_SUBTYPE_SNIPPET_SUMMARY,
+    SnippetEnrichment,
+)
+from kodit.domain.enrichments.enrichment import EnrichmentV2
+from kodit.domain.enrichments.usage.api_docs import (
+    ENRICHMENT_SUBTYPE_API_DOCS,
+    APIDocEnrichment,
+)
+from kodit.domain.enrichments.usage.usage import ENRICHMENT_TYPE_USAGE
+from kodit.infrastructure.sqlalchemy import entities as db_entities
+
+
+class EnrichmentMapper:
+    """Maps between domain enrichment entities and database entities."""
+
+    @staticmethod
+    def to_database(domain_enrichment: EnrichmentV2) -> db_entities.EnrichmentV2:
+        """Convert domain enrichment to database entity."""
+        return db_entities.EnrichmentV2(
+            id=domain_enrichment.id,
+            type=domain_enrichment.type,
+            subtype=domain_enrichment.subtype,
+            content=domain_enrichment.content,
+            created_at=domain_enrichment.created_at,
+            updated_at=domain_enrichment.updated_at,
+        )
+
+    @staticmethod
+    def to_domain(
+        db_enrichment: db_entities.EnrichmentV2,
+        entity_type: str,  # noqa: ARG004
+        entity_id: str,
+    ) -> EnrichmentV2:
+        """Convert database enrichment to domain entity."""
+        # Use the stored type and subtype to determine the correct domain class
+        if (
+            db_enrichment.type == ENRICHMENT_TYPE_DEVELOPMENT
+            and db_enrichment.subtype == ENRICHMENT_SUBTYPE_SNIPPET_SUMMARY
+        ):
+            return SnippetEnrichment(
+                id=db_enrichment.id,
+                entity_id=entity_id,
+                content=db_enrichment.content,
+                created_at=db_enrichment.created_at,
+                updated_at=db_enrichment.updated_at,
+            )
+        if (
+            db_enrichment.type == ENRICHMENT_TYPE_USAGE
+            and db_enrichment.subtype == ENRICHMENT_SUBTYPE_API_DOCS
+        ):
+            return APIDocEnrichment(
+                id=db_enrichment.id,
+                entity_id=entity_id,
+                content=db_enrichment.content,
+                created_at=db_enrichment.created_at,
+                updated_at=db_enrichment.updated_at,
+            )
+        if (
+            db_enrichment.type == ENRICHMENT_TYPE_ARCHITECTURE
+            and db_enrichment.subtype == ENRICHMENT_SUBTYPE_PHYSICAL
+        ):
+            return PhysicalArchitectureEnrichment(
+                id=db_enrichment.id,
+                entity_id=entity_id,
+                content=db_enrichment.content,
+                created_at=db_enrichment.created_at,
+                updated_at=db_enrichment.updated_at,
+            )
+
+        raise ValueError(
+            f"Unknown enrichment type: {db_enrichment.type}/{db_enrichment.subtype}"
+        )

kodit/infrastructure/mappers/snippet_mapper.py

@@ -1,6 +1,8 @@
 """Mapping between domain Git entities and SQLAlchemy entities."""
 
 import kodit.domain.entities.git as domain_git_entities
+from kodit.domain.enrichments.development.snippet.snippet import SnippetEnrichment
+from kodit.domain.enrichments.enrichment import EnrichmentV2
 from kodit.domain.value_objects import Enrichment, EnrichmentType
 from kodit.infrastructure.sqlalchemy import entities as db_entities
 
@@ -12,19 +14,17 @@ class SnippetMapper:
         self,
         db_snippet: db_entities.SnippetV2,
         db_files: list[db_entities.GitCommitFile],
-        db_enrichments: list[db_entities.Enrichment],
+        db_enrichments: list[EnrichmentV2],
     ) -> domain_git_entities.SnippetV2:
         """Convert SQLAlchemy SnippetV2 to domain SnippetV2."""
-        # Convert enrichments
-        enrichments = []
-        for db_enrichment in db_enrichments:
-            # Map from SQLAlchemy enum to domain enum
-            enrichment_type = EnrichmentType(db_enrichment.type.value)
-            enrichment = Enrichment(
-                type=enrichment_type,
-                content=db_enrichment.content,
+        # Convert enrichments from SnippetEnrichment to Enrichment value objects
+        enrichments: list[Enrichment] = [
+            Enrichment(
+                type=EnrichmentType.SUMMARIZATION,
+                content=enrichment.content,
             )
-            enrichments.append(enrichment)
+            for enrichment in db_enrichments
+        ]
 
         derives_from = [
             domain_git_entities.GitFile(
@@ -59,20 +59,18 @@ class SnippetMapper:
         )
 
     def from_domain_enrichments(
-        self, snippet_sha: str, enrichments: list[Enrichment]
-    ) -> list[db_entities.Enrichment]:
-        """Convert domain enrichments to SQLAlchemy enrichments."""
-        db_enrichments = []
-        for enrichment in enrichments:
-            # Map from domain enum to SQLAlchemy enum
-            db_enrichment_type = db_entities.EnrichmentType(enrichment.type.value)
-            db_enrichment = db_entities.Enrichment(
-                snippet_sha=snippet_sha,
-                type=db_enrichment_type,
+        self,
+        snippet_sha: str,
+        enrichments: list[Enrichment],
+    ) -> list[SnippetEnrichment]:
+        """Convert domain enrichments to SnippetEnrichment entities."""
+        return [
+            SnippetEnrichment(
+                entity_id=snippet_sha,
                 content=enrichment.content,
             )
-            db_enrichments.append(db_enrichment)
-        return db_enrichments
+            for enrichment in enrichments
+        ]
 
     def to_domain_commit_index(
         self,

kodit/infrastructure/physical_architecture/__init__.py

@@ -0,0 +1 @@
+"""Physical architecture discovery infrastructure."""

kodit/infrastructure/physical_architecture/detectors/__init__.py

@@ -0,0 +1 @@
+"""Component detectors for physical architecture discovery."""