kodit 0.5.0__py3-none-any.whl → 0.5.2__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.2'
+__version_tuple__ = version_tuple = (0, 5, 2)
 
 __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
 
@@ -11,10 +12,17 @@ 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
 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 +35,14 @@ 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.domain.tracking.resolution_service import TrackableResolutionService
 from kodit.infrastructure.bm25.local_bm25_repository import LocalBM25Repository
 from kodit.infrastructure.bm25.vectorchord_bm25_repository import (
     VectorChordBM25Repository,
@@ -40,17 +51,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 +86,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 +110,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 +128,33 @@ 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
+        self._trackable_resolution_service: TrackableResolutionService | None = None
+        self._enrichment_query_service: EnrichmentQueryService | 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 +238,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 +292,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."""
@@ -309,3 +357,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/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/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

@@ -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."""