kodit 0.5.0__py3-none-any.whl → 0.5.1__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.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)
 
 __commit_id__ = commit_id = None

kodit/app.py

@@ -14,12 +14,8 @@ from kodit.application.factories.server_factory import ServerFactory
 from kodit.application.services.indexing_worker_service import IndexingWorkerService
 from kodit.application.services.sync_scheduler import SyncSchedulerService
 from kodit.config import AppContext
-from kodit.domain.value_objects import (
-    Document,
-    EnrichmentIndexRequest,
-    EnrichmentRequest,
-    IndexRequest,
-)
+from kodit.domain.enrichments.request import EnrichmentRequest
+from kodit.domain.value_objects import Document, IndexRequest
 from kodit.infrastructure.api.v1.routers.commits import router as commits_router
 from kodit.infrastructure.api.v1.routers.queue import router as queue_router
 from kodit.infrastructure.api.v1.routers.repositories import (
@@ -71,12 +67,14 @@ async def app_lifespan(_: FastAPI) -> AsyncIterator[AppLifespanState]:
         raise ValueError("Embedding service is not accessible") from e
     try:
         await anext(
-            _server_factory.enrichment_service().enrich_documents(
-                EnrichmentIndexRequest(
-                    requests=[
-                        EnrichmentRequest(snippet_id="1", text="def hello(): pass")
-                    ]
-                )
+            _server_factory.enricher().enrich(
+                [
+                    EnrichmentRequest(
+                        id="1",
+                        text="def hello(): pass",
+                        system_prompt="Explain this code",
+                    )
+                ]
             )
         )
     except Exception as e:

kodit/application/factories/server_factory.py

@@ -1,6 +1,7 @@
 """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
 
@@ -15,6 +16,10 @@ from kodit.application.services.queue_service import QueueService
 from kodit.application.services.reporting import ProgressTracker
 from kodit.application.services.sync_scheduler import SyncSchedulerService
 from kodit.config import AppContext
+from kodit.domain.enrichments.architecture.physical.formatter import (
+    PhysicalArchitectureFormatter,
+)
+from kodit.domain.enrichments.enricher import Enricher
 from kodit.domain.protocols import (
     FusionService,
     GitAdapter,
@@ -27,11 +32,13 @@ from kodit.domain.protocols import (
 )
 from kodit.domain.services.bm25_service import BM25DomainService, BM25Repository
 from kodit.domain.services.embedding_service import EmbeddingDomainService
-from kodit.domain.services.enrichment_service import EnrichmentDomainService
 from kodit.domain.services.git_repository_service import (
     GitRepositoryScanner,
     RepositoryCloner,
 )
+from kodit.domain.services.physical_architecture_service import (
+    PhysicalArchitectureService,
+)
 from kodit.infrastructure.bm25.local_bm25_repository import LocalBM25Repository
 from kodit.infrastructure.bm25.vectorchord_bm25_repository import (
     VectorChordBM25Repository,
@@ -40,17 +47,23 @@ from kodit.infrastructure.cloning.git.git_python_adaptor import GitPythonAdapter
 from kodit.infrastructure.embedding.embedding_factory import (
     embedding_domain_service_factory,
 )
-from kodit.infrastructure.enrichment.enrichment_factory import (
-    enrichment_domain_service_factory,
+from kodit.infrastructure.enricher.enricher_factory import (
+    enricher_domain_service_factory,
 )
 
 # InMemoryGitTagRepository removed - now handled by InMemoryGitRepoRepository
 from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
+from kodit.infrastructure.physical_architecture.formatters.narrative_formatter import (
+    NarrativeFormatter,
+)
 from kodit.infrastructure.slicing.slicer import Slicer
 from kodit.infrastructure.sqlalchemy.embedding_repository import (
     SqlAlchemyEmbeddingRepository,
     create_embedding_repository,
 )
+from kodit.infrastructure.sqlalchemy.enrichment_v2_repository import (
+    EnrichmentV2Repository,
+)
 from kodit.infrastructure.sqlalchemy.git_branch_repository import (
     create_git_branch_repository,
 )
@@ -69,6 +82,9 @@ 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."""
@@ -90,6 +106,7 @@ class ServerFactory:
             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
         self._queue_service: QueueService | None = None
@@ -107,6 +124,31 @@ class ServerFactory:
         self._git_commit_repository: GitCommitRepository | None = None
         self._git_branch_repository: GitBranchRepository | None = None
         self._git_tag_repository: GitTagRepository | None = None
+        self._architecture_service: PhysicalArchitectureService | None = None
+        self._enrichment_v2_repository: EnrichmentV2Repository | None = None
+        self._architecture_formatter: PhysicalArchitectureFormatter | None = None
+
+    def architecture_formatter(self) -> PhysicalArchitectureFormatter:
+        """Create a PhysicalArchitectureFormatter instance."""
+        if not self._architecture_formatter:
+            self._architecture_formatter = NarrativeFormatter()
+        return self._architecture_formatter
+
+    def architecture_service(self) -> PhysicalArchitectureService:
+        """Create a PhysicalArchitectureService instance."""
+        if not self._architecture_service:
+            self._architecture_service = PhysicalArchitectureService(
+                formatter=self.architecture_formatter()
+            )
+        return self._architecture_service
+
+    def enrichment_v2_repository(self) -> EnrichmentV2Repository:
+        """Create a EnrichmentV2Repository instance."""
+        if not self._enrichment_v2_repository:
+            self._enrichment_v2_repository = EnrichmentV2Repository(
+                session_factory=self.session_factory
+            )
+        return self._enrichment_v2_repository
 
     def queue_service(self) -> QueueService:
         """Create a QueueService instance."""
@@ -190,8 +232,10 @@ class ServerFactory:
                     bm25_service=self.bm25_service(),
                     code_search_service=self.code_search_service(),
                     text_search_service=self.text_search_service(),
-                    enrichment_service=self.enrichment_service(),
                     embedding_repository=self.embedding_repository(),
+                    architecture_service=self.architecture_service(),
+                    enrichment_v2_repository=self.enrichment_v2_repository(),
+                    enricher_service=self.enricher(),
                 )
             )
 
@@ -242,13 +286,11 @@ class ServerFactory:
             )
         return self._snippet_v2_repository
 
-    def enrichment_service(self) -> EnrichmentDomainService:
-        """Create a EnrichmentDomainService instance."""
-        if not self._enrichment_service:
-            self._enrichment_service = enrichment_domain_service_factory(
-                self.app_context
-            )
-        return self._enrichment_service
+    def enricher(self) -> Enricher:
+        """Create a EnricherDomainService instance."""
+        if not self._enricher_service:
+            self._enricher_service = enricher_domain_service_factory(self.app_context)
+        return self._enricher_service
 
     def sync_scheduler_service(self) -> SyncSchedulerService:
         """Create a SyncSchedulerService instance."""

kodit/application/services/commit_indexing_application_service.py

@@ -8,6 +8,15 @@ from pydantic import AnyUrl
 
 from kodit.application.services.queue_service import QueueService
 from kodit.application.services.reporting import ProgressTracker
+from kodit.domain.enrichments.architecture.physical.physical import (
+    PhysicalArchitectureEnrichment,
+)
+from kodit.domain.enrichments.enricher import Enricher
+from kodit.domain.enrichments.request import (
+    EnrichmentRequest as GenericEnrichmentRequest,
+)
+from kodit.domain.enrichments.usage.api_docs import ENRICHMENT_SUBTYPE_API_DOCS
+from kodit.domain.enrichments.usage.usage import ENRICHMENT_TYPE_USAGE
 from kodit.domain.entities import Task
 from kodit.domain.entities.git import GitFile, GitRepo, SnippetV2
 from kodit.domain.factories.git_repo_factory import GitRepoFactory
@@ -20,17 +29,19 @@ from kodit.domain.protocols import (
 )
 from kodit.domain.services.bm25_service import BM25DomainService
 from kodit.domain.services.embedding_service import EmbeddingDomainService
-from kodit.domain.services.enrichment_service import EnrichmentDomainService
 from kodit.domain.services.git_repository_service import (
     GitRepositoryScanner,
     RepositoryCloner,
 )
+from kodit.domain.services.physical_architecture_service import (
+    ARCHITECTURE_ENRICHMENT_SYSTEM_PROMPT,
+    ARCHITECTURE_ENRICHMENT_TASK_PROMPT,
+    PhysicalArchitectureService,
+)
 from kodit.domain.value_objects import (
     DeleteRequest,
     Document,
     Enrichment,
-    EnrichmentIndexRequest,
-    EnrichmentRequest,
     EnrichmentType,
     IndexRequest,
     LanguageMapping,
@@ -39,12 +50,21 @@ from kodit.domain.value_objects import (
     TaskOperation,
     TrackableType,
 )
+from kodit.infrastructure.slicing.api_doc_extractor import APIDocExtractor
 from kodit.infrastructure.slicing.slicer import Slicer
 from kodit.infrastructure.sqlalchemy.embedding_repository import (
     SqlAlchemyEmbeddingRepository,
 )
+from kodit.infrastructure.sqlalchemy.enrichment_v2_repository import (
+    EnrichmentV2Repository,
+)
 from kodit.infrastructure.sqlalchemy.entities import EmbeddingType
 
+SUMMARIZATION_SYSTEM_PROMPT = """
+You are a professional software developer. You will be given a snippet of code.
+Please provide a concise explanation of the code.
+"""
+
 
 class CommitIndexingApplicationService:
     """Application service for commit indexing operations."""
@@ -65,8 +85,10 @@ class CommitIndexingApplicationService:
         bm25_service: BM25DomainService,
         code_search_service: EmbeddingDomainService,
         text_search_service: EmbeddingDomainService,
-        enrichment_service: EnrichmentDomainService,
         embedding_repository: SqlAlchemyEmbeddingRepository,
+        architecture_service: PhysicalArchitectureService,
+        enrichment_v2_repository: EnrichmentV2Repository,
+        enricher_service: Enricher,
     ) -> None:
         """Initialize the commit indexing application service.
 
@@ -92,8 +114,10 @@ class CommitIndexingApplicationService:
         self.bm25_service = bm25_service
         self.code_search_service = code_search_service
         self.text_search_service = text_search_service
-        self.enrichment_service = enrichment_service
         self.embedding_repository = embedding_repository
+        self.architecture_service = architecture_service
+        self.enrichment_v2_repository = enrichment_v2_repository
+        self.enricher_service = enricher_service
         self._log = structlog.get_logger(__name__)
 
     async def create_git_repository(self, remote_uri: AnyUrl) -> GitRepo:
@@ -153,6 +177,10 @@ class CommitIndexingApplicationService:
                 await self.process_enrich(repository_id, commit_sha)
             elif task.type == TaskOperation.CREATE_SUMMARY_EMBEDDINGS_FOR_COMMIT:
                 await self.process_summary_embeddings(repository_id, commit_sha)
+            elif task.type == TaskOperation.CREATE_ARCHITECTURE_ENRICHMENT_FOR_COMMIT:
+                await self.process_architecture_discovery(repository_id, commit_sha)
+            elif task.type == TaskOperation.CREATE_PUBLIC_API_DOCS_FOR_COMMIT:
+                await self.process_api_docs(repository_id, commit_sha)
             else:
                 raise ValueError(f"Unknown task type: {task.type}")
         else:
@@ -245,16 +273,14 @@ class CommitIndexingApplicationService:
                     snippets = await self.snippet_repository.get_snippets_for_commit(
                         commit_sha
                     )
-                    all_snippet_ids.extend([
-                        snippet.id for snippet in snippets if snippet.id
-                    ])
+                    all_snippet_ids.extend(
+                        [snippet.id for snippet in snippets if snippet.id]
+                    )
 
             # Step 2: Delete from BM25 and embedding indices
             if all_snippet_ids:
                 # Convert to strings as DeleteRequest expects list[str]
-                snippet_id_strings = [
-                    str(snippet_id) for snippet_id in all_snippet_ids
-                ]
+                snippet_id_strings = [str(snippet_id) for snippet_id in all_snippet_ids]
                 delete_request = DeleteRequest(snippet_ids=snippet_id_strings)
                 await self.bm25_service.delete_documents(delete_request)
 
@@ -264,20 +290,27 @@ class CommitIndexingApplicationService:
                         snippet_id
                     )
 
-            # Step 3: Delete snippet associations for all commits
+            # Step 3: Delete enrichments for all commits
+            if commit_shas:
+                await self.enrichment_v2_repository.bulk_delete_enrichments(
+                    entity_type="git_commit",
+                    entity_ids=commit_shas,
+                )
+
+            # Step 4: Delete snippet associations for all commits
             for commit_sha in commit_shas:
                 await self.snippet_repository.delete_snippets_for_commit(commit_sha)
 
-            # Step 4: Delete branches (they reference commits via head_commit_sha)
+            # Step 5: Delete branches (they reference commits via head_commit_sha)
             await self.git_branch_repository.delete_by_repo_id(repository_id)
 
-            # Step 5: Delete tags (they reference commits via target_commit_sha)
+            # Step 6: Delete tags (they reference commits via target_commit_sha)
             await self.git_tag_repository.delete_by_repo_id(repository_id)
 
-            # Step 6: Delete commits and their files
+            # Step 7: Delete commits and their files
             await self.git_commit_repository.delete_by_repo_id(repository_id)
 
-            # Step 7: Finally delete the repository
+            # Step 8: Finally delete the repository
             await self.repo_repository.delete(repo.sanitized_remote_uri)
 
     async def process_snippets_for_commit(
@@ -302,11 +335,7 @@ class CommitIndexingApplicationService:
             if not repo.cloned_path:
                 raise ValueError(f"Repository {repository_id} has never been cloned")
 
-            # Ensure we're on the specific commit for file access
-            await self.scanner.git_adapter.checkout_commit(repo.cloned_path, commit_sha)
-
-            # Get files directly from Git adapter for this specific commit
-            files_data = await self.scanner.git_adapter.get_commit_files(
+            files_data = await self.scanner.git_adapter.get_commit_file_data(
                 repo.cloned_path, commit_sha
             )
 
@@ -456,18 +485,18 @@ class CommitIndexingApplicationService:
                 if snippet.id
             }
 
-            enrichment_request = EnrichmentIndexRequest(
-                requests=[
-                    EnrichmentRequest(snippet_id=snippet_id, text=snippet.content)
-                    for snippet_id, snippet in snippet_map.items()
-                ]
-            )
+            enrichment_requests = [
+                GenericEnrichmentRequest(
+                    id=snippet_id,
+                    text=snippet.content,
+                    system_prompt=SUMMARIZATION_SYSTEM_PROMPT,
+                )
+                for snippet_id, snippet in snippet_map.items()
+            ]
 
             processed = 0
-            async for result in self.enrichment_service.enrich_documents(
-                enrichment_request
-            ):
-                snippet = snippet_map[result.snippet_id]
+            async for result in self.enricher_service.enrich(enrichment_requests):
+                snippet = snippet_map[result.id]
                 snippet.enrichments.append(
                     Enrichment(type=EnrichmentType.SUMMARIZATION, content=result.text)
                 )
@@ -526,6 +555,134 @@ class CommitIndexingApplicationService:
                 processed += len(result)
                 await step.set_current(processed, "Creating text embeddings for commit")
 
+    async def process_architecture_discovery(
+        self, repository_id: int, commit_sha: str
+    ) -> None:
+        """Handle ARCHITECTURE_DISCOVERY task - discover physical architecture."""
+        async with self.operation.create_child(
+            TaskOperation.CREATE_ARCHITECTURE_ENRICHMENT_FOR_COMMIT,
+            trackable_type=TrackableType.KODIT_REPOSITORY,
+            trackable_id=repository_id,
+        ) as step:
+            await step.set_total(3)
+
+            # Check if architecture enrichment already exists for this commit
+            enrichment_repo = self.enrichment_v2_repository
+            existing_enrichments = await enrichment_repo.enrichments_for_entity_type(
+                entity_type="git_commit",
+                entity_ids=[commit_sha],
+            )
+
+            # Check if architecture enrichment already exists
+            has_architecture = any(
+                enrichment.type == "architecture" for enrichment in existing_enrichments
+            )
+
+            if has_architecture:
+                await step.skip("Architecture enrichment already exists for commit")
+                return
+
+            # Get repository path
+            repo = await self.repo_repository.get_by_id(repository_id)
+            if not repo.cloned_path:
+                raise ValueError(f"Repository {repository_id} has never been cloned")
+
+            await step.set_current(1, "Discovering physical architecture")
+
+            # Discover architecture
+            architecture_narrative = (
+                await self.architecture_service.discover_architecture(repo.cloned_path)
+            )
+
+            await step.set_current(2, "Enriching architecture notes with LLM")
+
+            # Enrich the architecture narrative through the enricher
+            enrichment_request = GenericEnrichmentRequest(
+                id=commit_sha,
+                text=ARCHITECTURE_ENRICHMENT_TASK_PROMPT.format(
+                    architecture_narrative=architecture_narrative,
+                ),
+                system_prompt=ARCHITECTURE_ENRICHMENT_SYSTEM_PROMPT,
+            )
+
+            enriched_content = ""
+            async for response in self.enricher_service.enrich([enrichment_request]):
+                enriched_content = response.text
+
+            # Create and save architecture enrichment with enriched content
+            architecture_enrichment = PhysicalArchitectureEnrichment(
+                entity_id=commit_sha,
+                content=enriched_content,
+            )
+
+            await self.enrichment_v2_repository.bulk_save_enrichments(
+                [architecture_enrichment]
+            )
+
+            await step.set_current(3, "Architecture enrichment completed")
+
+    async def process_api_docs(self, repository_id: int, commit_sha: str) -> None:
+        """Handle API_DOCS task - generate API documentation."""
+        async with self.operation.create_child(
+            TaskOperation.CREATE_PUBLIC_API_DOCS_FOR_COMMIT,
+            trackable_type=TrackableType.KODIT_REPOSITORY,
+            trackable_id=repository_id,
+        ) as step:
+            # Check if API docs already exist for this commit
+            existing_enrichments = (
+                await self.enrichment_v2_repository.enrichments_for_entity_type(
+                    entity_type="git_commit",
+                    entity_ids=[commit_sha],
+                )
+            )
+
+            has_api_docs = any(
+                e.type == ENRICHMENT_TYPE_USAGE
+                and e.subtype == ENRICHMENT_SUBTYPE_API_DOCS
+                for e in existing_enrichments
+            )
+
+            if has_api_docs:
+                await step.skip("API docs already exist for commit")
+                return
+
+            # Get repository for metadata
+            repo = await self.repo_repository.get_by_id(repository_id)
+            if not repo:
+                raise ValueError(f"Repository {repository_id} not found")
+            str(repo.sanitized_remote_uri)
+
+            commit = await self.git_commit_repository.get_by_sha(commit_sha)
+
+            # Group files by language
+            lang_files_map: dict[str, list[GitFile]] = defaultdict(list)
+            for file in commit.files:
+                try:
+                    lang = LanguageMapping.get_language_for_extension(file.extension)
+                except ValueError:
+                    continue
+                lang_files_map[lang].append(file)
+
+            all_enrichments = []
+            extractor = APIDocExtractor()
+
+            await step.set_total(len(lang_files_map))
+            for i, (lang, lang_files) in enumerate(lang_files_map.items()):
+                await step.set_current(i, f"Extracting API docs for {lang}")
+                enrichments = extractor.extract_api_docs(
+                    lang_files,
+                    lang,
+                    commit_sha,
+                    include_private=False,
+                )
+                all_enrichments.extend(enrichments)
+
+            # Save all enrichments
+            if all_enrichments:
+                await self.enrichment_v2_repository.bulk_save_enrichments(
+                    all_enrichments
+                )
+
     async def _new_snippets_for_type(
         self, all_snippets: list[SnippetV2], embedding_type: EmbeddingType
     ) -> list[SnippetV2]:

kodit/config.py

@@ -66,9 +66,9 @@ class Endpoint(BaseModel):
         default=None,
         description="Unix socket path for local communication (e.g., /tmp/openai.sock)",
     )
-    timeout: float | None = Field(
-        default=None,
-        description="Request timeout in seconds (default: 30.0)",
+    timeout: float = Field(
+        default=60,
+        description="Request timeout in seconds",
     )
     extra_params: dict[str, Any] | None = Field(
         default=None,

kodit/domain/enrichments/__init__.py

@@ -0,0 +1 @@
+"""Enrichment domain package."""

kodit/domain/enrichments/architecture/__init__.py

@@ -0,0 +1 @@
+"""Architecture enrichment package."""

kodit/domain/enrichments/architecture/architecture.py

@@ -0,0 +1,20 @@
+"""Architecture enrichment domain entity."""
+
+from abc import ABC
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.enrichment import (
+    CommitEnrichment,
+)
+
+ENRICHMENT_TYPE_ARCHITECTURE = "architecture"
+
+
+@dataclass
+class ArchitectureEnrichment(CommitEnrichment, ABC):
+    """Enrichment containing physical architecture discovery for a commit."""
+
+    @property
+    def type(self) -> str:
+        """Return the enrichment type."""
+        return ENRICHMENT_TYPE_ARCHITECTURE

kodit/domain/enrichments/architecture/physical/__init__.py

@@ -0,0 +1 @@
+"""Physical architecture enrichment package."""

kodit/domain/enrichments/architecture/physical/discovery_notes.py

@@ -0,0 +1,14 @@
+"""Physical architecture domain value objects."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ArchitectureDiscoveryNotes:
+    """Rich, narrative observations about repository architecture for LLM consumption."""  # noqa: E501
+
+    repository_context: str  # High-level overview and discovery scope
+    component_observations: list[str]  # Detailed findings about each component
+    connection_observations: list[str]  # How components interact and communicate
+    infrastructure_observations: list[str]  # Deployment, config, operational patterns
+    discovery_metadata: str  # Methodology, confidence, limitations, timestamp

kodit/domain/enrichments/architecture/physical/formatter.py

@@ -0,0 +1,11 @@
+"""Physical architecture formatter protocol."""
+
+from typing import Any, Protocol
+
+
+class PhysicalArchitectureFormatter(Protocol):
+    """Formatter for converting architecture discovery notes to LLM-optimized text."""
+
+    def format_for_llm(self, notes: Any) -> str:
+        """Format architecture discovery notes for LLM consumption."""
+        ...

kodit/domain/enrichments/architecture/physical/physical.py

@@ -0,0 +1,17 @@
+"""Physical architecture enrichment domain entity."""
+
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.architecture.architecture import ArchitectureEnrichment
+
+ENRICHMENT_SUBTYPE_PHYSICAL = "physical"
+
+
+@dataclass
+class PhysicalArchitectureEnrichment(ArchitectureEnrichment):
+    """Enrichment containing physical architecture discovery for a commit."""
+
+    @property
+    def subtype(self) -> str | None:
+        """Return the enrichment subtype."""
+        return ENRICHMENT_SUBTYPE_PHYSICAL

kodit/domain/enrichments/development/__init__.py

@@ -0,0 +1 @@
+"""Development enrichment package."""

kodit/domain/enrichments/development/development.py

@@ -0,0 +1,18 @@
+"""Development enrichment domain entity."""
+
+from abc import ABC
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.enrichment import CommitEnrichment
+
+ENRICHMENT_TYPE_DEVELOPMENT = "development"
+
+
+@dataclass
+class DevelopmentEnrichment(CommitEnrichment, ABC):
+    """Enrichment containing development discovery for a commit."""
+
+    @property
+    def type(self) -> str:
+        """Return the enrichment type."""
+        return ENRICHMENT_TYPE_DEVELOPMENT

kodit/domain/enrichments/development/snippet/__init__.py

@@ -0,0 +1 @@
+"""Snippet enrichment package."""

kodit/domain/enrichments/development/snippet/snippet.py

@@ -0,0 +1,21 @@
+"""Snippet enrichment domain entity."""
+
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.development.development import DevelopmentEnrichment
+
+ENRICHMENT_SUBTYPE_SNIPPET_SUMMARY = "snippet_summary"
+
+
+@dataclass
+class SnippetEnrichment(DevelopmentEnrichment):
+    """Enrichment specific to code snippets."""
+
+    @property
+    def subtype(self) -> str | None:
+        """Return the enrichment subtype."""
+        return ENRICHMENT_SUBTYPE_SNIPPET_SUMMARY
+
+    def entity_type_key(self) -> str:
+        """Return the entity type key this enrichment is for."""
+        return "snippet_v2"

kodit/domain/enrichments/enricher.py

@@ -0,0 +1,17 @@
+"""Enricher interface."""
+
+from collections.abc import AsyncGenerator
+from typing import Protocol
+
+from kodit.domain.enrichments.request import EnrichmentRequest
+from kodit.domain.enrichments.response import EnrichmentResponse
+
+
+class Enricher(Protocol):
+    """Interface for text enrichment with custom prompts."""
+
+    def enrich(
+        self, requests: list[EnrichmentRequest]
+    ) -> AsyncGenerator[EnrichmentResponse, None]:
+        """Enrich a list of requests with custom system prompts."""
+        ...