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

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/git_mapper.py

@@ -0,0 +1,193 @@
+"""Mapping between domain Git entities and SQLAlchemy entities."""
+
+from collections import defaultdict
+from pathlib import Path
+
+from pydantic import AnyUrl
+
+import kodit.domain.entities.git as domain_git_entities
+from kodit.infrastructure.sqlalchemy import entities as db_entities
+
+
+class GitMapper:
+    """Mapper for converting between domain Git entities and database entities."""
+
+    def to_domain_commits(
+        self,
+        db_commits: list[db_entities.GitCommit],
+        db_commit_files: list[db_entities.GitCommitFile],
+    ) -> list[domain_git_entities.GitCommit]:
+        """Convert SQLAlchemy GitCommit to domain GitCommit."""
+        commit_files_map = defaultdict(list)
+        for file in db_commit_files:
+            commit_files_map[file.commit_sha].append(file.blob_sha)
+
+        commit_domain_files_map = defaultdict(list)
+        for file in db_commit_files:
+            commit_domain_files_map[file.commit_sha].append(
+                domain_git_entities.GitFile(
+                    created_at=file.created_at,
+                    blob_sha=file.blob_sha,
+                    path=file.path,
+                    mime_type=file.mime_type,
+                    size=file.size,
+                    extension=file.extension,
+                )
+            )
+
+        domain_commits = []
+        for db_commit in db_commits:
+            domain_commit = domain_git_entities.GitCommit(
+                created_at=db_commit.created_at,
+                updated_at=db_commit.updated_at,
+                commit_sha=db_commit.commit_sha,
+                date=db_commit.date,
+                message=db_commit.message,
+                parent_commit_sha=db_commit.parent_commit_sha,
+                files=commit_domain_files_map[db_commit.commit_sha],
+                author=db_commit.author,
+            )
+            domain_commits.append(domain_commit)
+        return domain_commits
+
+    def to_domain_branches(
+        self,
+        db_branches: list[db_entities.GitBranch],
+        domain_commits: list[domain_git_entities.GitCommit],
+    ) -> list[domain_git_entities.GitBranch]:
+        """Convert SQLAlchemy GitBranch to domain GitBranch."""
+        commit_map = {commit.commit_sha: commit for commit in domain_commits}
+        domain_branches = []
+        for db_branch in db_branches:
+            if db_branch.head_commit_sha not in commit_map:
+                raise ValueError(
+                    f"Commit {db_branch.head_commit_sha} for "
+                    f"branch {db_branch.name} not found in commits: {commit_map.keys()}"
+                )
+            domain_branch = domain_git_entities.GitBranch(
+                repo_id=db_branch.repo_id,
+                name=db_branch.name,
+                created_at=db_branch.created_at,
+                updated_at=db_branch.updated_at,
+                head_commit=commit_map[db_branch.head_commit_sha],
+            )
+            domain_branches.append(domain_branch)
+        return domain_branches
+
+    def to_domain_tags(
+        self,
+        db_tags: list[db_entities.GitTag],
+        domain_commits: list[domain_git_entities.GitCommit],
+    ) -> list[domain_git_entities.GitTag]:
+        """Convert SQLAlchemy GitTag to domain GitTag."""
+        commit_map = {commit.commit_sha: commit for commit in domain_commits}
+        domain_tags = []
+        for db_tag in db_tags:
+            if db_tag.target_commit_sha not in commit_map:
+                raise ValueError(
+                    f"Commit {db_tag.target_commit_sha} for tag {db_tag.name} not found"
+                )
+            domain_tag = domain_git_entities.GitTag(
+                created_at=db_tag.created_at,
+                updated_at=db_tag.updated_at,
+                repo_id=db_tag.repo_id,
+                name=db_tag.name,
+                target_commit=commit_map[db_tag.target_commit_sha],
+            )
+            domain_tags.append(domain_tag)
+        return domain_tags
+
+    def to_domain_tracking_branch(
+        self,
+        db_tracking_branch: db_entities.GitTrackingBranch | None,
+        db_tracking_branch_entity: db_entities.GitBranch | None,
+        domain_commits: list[domain_git_entities.GitCommit],
+    ) -> domain_git_entities.GitBranch | None:
+        """Convert SQLAlchemy GitTrackingBranch to domain GitBranch."""
+        if db_tracking_branch is None or db_tracking_branch_entity is None:
+            return None
+
+        commit_map = {commit.commit_sha: commit for commit in domain_commits}
+        if db_tracking_branch_entity.head_commit_sha not in commit_map:
+            raise ValueError(
+                f"Commit {db_tracking_branch_entity.head_commit_sha} for "
+                f"tracking branch {db_tracking_branch.name} not found"
+            )
+
+        return domain_git_entities.GitBranch(
+            repo_id=db_tracking_branch_entity.repo_id,
+            name=db_tracking_branch_entity.name,
+            created_at=db_tracking_branch_entity.created_at,
+            updated_at=db_tracking_branch_entity.updated_at,
+            head_commit=commit_map[db_tracking_branch_entity.head_commit_sha],
+        )
+
+    def to_domain_git_repo(  # noqa: PLR0913
+        self,
+        db_repo: db_entities.GitRepo,
+        db_tracking_branch_entity: db_entities.GitBranch | None,
+        db_commits: list[db_entities.GitCommit],
+        db_tags: list[db_entities.GitTag],
+        db_commit_files: list[db_entities.GitCommitFile],
+        db_tracking_branch: db_entities.GitTrackingBranch | None,
+    ) -> domain_git_entities.GitRepo:
+        """Convert SQLAlchemy GitRepo to domain GitRepo."""
+        # Build commits needed for tags and tracking branch
+        domain_commits = self.to_domain_commits(
+            db_commits=db_commits, db_commit_files=db_commit_files
+        )
+        self.to_domain_tags(
+            db_tags=db_tags, domain_commits=domain_commits
+        )
+        tracking_branch = self.to_domain_tracking_branch(
+            db_tracking_branch=db_tracking_branch,
+            db_tracking_branch_entity=db_tracking_branch_entity,
+            domain_commits=domain_commits,
+        )
+
+        from kodit.domain.factories.git_repo_factory import GitRepoFactory
+
+        return GitRepoFactory.create_from_components(
+            repo_id=db_repo.id,
+            created_at=db_repo.created_at,
+            updated_at=db_repo.updated_at,
+            sanitized_remote_uri=AnyUrl(db_repo.sanitized_remote_uri),
+            remote_uri=AnyUrl(db_repo.remote_uri),
+            tracking_branch=tracking_branch,
+            cloned_path=Path(db_repo.cloned_path) if db_repo.cloned_path else None,
+            last_scanned_at=db_repo.last_scanned_at,
+            num_commits=db_repo.num_commits,
+            num_branches=db_repo.num_branches,
+            num_tags=db_repo.num_tags,
+        )
+
+    def to_domain_commit_index(
+        self,
+        db_commit_index: db_entities.CommitIndex,
+        snippets: list[domain_git_entities.SnippetV2],
+    ) -> domain_git_entities.CommitIndex:
+        """Convert SQLAlchemy CommitIndex to domain CommitIndex."""
+        return domain_git_entities.CommitIndex(
+            commit_sha=db_commit_index.commit_sha,
+            created_at=db_commit_index.created_at,
+            updated_at=db_commit_index.updated_at,
+            snippets=snippets,
+            status=domain_git_entities.IndexStatus(db_commit_index.status),
+            indexed_at=db_commit_index.indexed_at,
+            error_message=db_commit_index.error_message,
+            files_processed=db_commit_index.files_processed,
+            processing_time_seconds=float(db_commit_index.processing_time_seconds),
+        )
+
+    def from_domain_commit_index(
+        self, domain_commit_index: domain_git_entities.CommitIndex
+    ) -> db_entities.CommitIndex:
+        """Convert domain CommitIndex to SQLAlchemy CommitIndex."""
+        return db_entities.CommitIndex(
+            commit_sha=domain_commit_index.commit_sha,
+            status=domain_commit_index.status,
+            indexed_at=domain_commit_index.indexed_at,
+            error_message=domain_commit_index.error_message,
+            files_processed=domain_commit_index.files_processed,
+            processing_time_seconds=domain_commit_index.processing_time_seconds,
+        )

kodit/infrastructure/mappers/snippet_mapper.py

@@ -0,0 +1,104 @@
+"""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
+
+
+class SnippetMapper:
+    """Mapper for converting between domain Git entities and database entities."""
+
+    def to_domain_snippet_v2(
+        self,
+        db_snippet: db_entities.SnippetV2,
+        db_files: list[db_entities.GitCommitFile],
+        db_enrichments: list[EnrichmentV2],
+    ) -> domain_git_entities.SnippetV2:
+        """Convert SQLAlchemy SnippetV2 to domain SnippetV2."""
+        # Convert enrichments from SnippetEnrichment to Enrichment value objects
+        enrichments: list[Enrichment] = [
+            Enrichment(
+                type=EnrichmentType.SUMMARIZATION,
+                content=enrichment.content,
+            )
+            for enrichment in db_enrichments
+        ]
+
+        derives_from = [
+            domain_git_entities.GitFile(
+                created_at=file.created_at,
+                blob_sha=file.blob_sha,
+                path=file.path,
+                mime_type=file.mime_type,
+                size=file.size,
+                extension=file.extension,
+            )
+            for file in db_files
+        ]
+
+        return domain_git_entities.SnippetV2(
+            sha=db_snippet.sha,
+            created_at=db_snippet.created_at,
+            updated_at=db_snippet.updated_at,
+            derives_from=derives_from,
+            content=db_snippet.content,
+            enrichments=enrichments,
+            extension=db_snippet.extension,
+        )
+
+    def from_domain_snippet_v2(
+        self, domain_snippet: domain_git_entities.SnippetV2
+    ) -> db_entities.SnippetV2:
+        """Convert domain SnippetV2 to SQLAlchemy SnippetV2."""
+        return db_entities.SnippetV2(
+            sha=domain_snippet.sha,
+            content=domain_snippet.content,
+            extension=domain_snippet.extension,
+        )
+
+    def from_domain_enrichments(
+        self,
+        snippet_sha: str,
+        enrichments: list[Enrichment],
+    ) -> list[SnippetEnrichment]:
+        """Convert domain enrichments to SnippetEnrichment entities."""
+        return [
+            SnippetEnrichment(
+                entity_id=snippet_sha,
+                content=enrichment.content,
+            )
+            for enrichment in enrichments
+        ]
+
+    def to_domain_commit_index(
+        self,
+        db_commit_index: db_entities.CommitIndex,
+        snippets: list[domain_git_entities.SnippetV2],
+    ) -> domain_git_entities.CommitIndex:
+        """Convert SQLAlchemy CommitIndex to domain CommitIndex."""
+        return domain_git_entities.CommitIndex(
+            commit_sha=db_commit_index.commit_sha,
+            created_at=db_commit_index.created_at,
+            updated_at=db_commit_index.updated_at,
+            snippets=snippets,
+            status=domain_git_entities.IndexStatus(db_commit_index.status),
+            indexed_at=db_commit_index.indexed_at,
+            error_message=db_commit_index.error_message,
+            files_processed=db_commit_index.files_processed,
+            processing_time_seconds=float(db_commit_index.processing_time_seconds),
+        )
+
+    def from_domain_commit_index(
+        self, domain_commit_index: domain_git_entities.CommitIndex
+    ) -> db_entities.CommitIndex:
+        """Convert domain CommitIndex to SQLAlchemy CommitIndex."""
+        return db_entities.CommitIndex(
+            commit_sha=domain_commit_index.commit_sha,
+            status=domain_commit_index.status,
+            indexed_at=domain_commit_index.indexed_at,
+            error_message=domain_commit_index.error_message,
+            files_processed=domain_commit_index.files_processed,
+            processing_time_seconds=domain_commit_index.processing_time_seconds,
+        )

kodit/infrastructure/mappers/task_mapper.py

@@ -1,43 +1,10 @@
 """Task mapper for the task queue."""
 
-from typing import ClassVar
-
 from kodit.domain.entities import Task
-from kodit.domain.value_objects import TaskType
+from kodit.domain.value_objects import TaskOperation
 from kodit.infrastructure.sqlalchemy import entities as db_entities
 
 
-class TaskTypeMapper:
-    """Maps between domain QueuedTaskType and SQLAlchemy TaskType."""
-
-    # Map TaskType enum to QueuedTaskType
-    TASK_TYPE_MAPPING: ClassVar[dict[db_entities.TaskType, TaskType]] = {
-        db_entities.TaskType.INDEX_UPDATE: TaskType.INDEX_UPDATE,
-    }
-
-    @staticmethod
-    def to_domain_type(task_type: db_entities.TaskType) -> TaskType:
-        """Convert SQLAlchemy TaskType to domain QueuedTaskType."""
-        if task_type not in TaskTypeMapper.TASK_TYPE_MAPPING:
-            raise ValueError(f"Unknown task type: {task_type}")
-        return TaskTypeMapper.TASK_TYPE_MAPPING[task_type]
-
-    @staticmethod
-    def from_domain_type(task_type: TaskType) -> db_entities.TaskType:
-        """Convert domain QueuedTaskType to SQLAlchemy TaskType."""
-        if task_type not in TaskTypeMapper.TASK_TYPE_MAPPING.values():
-            raise ValueError(f"Unknown task type: {task_type}")
-
-        # Find value in TASK_TYPE_MAPPING
-        return next(
-            (
-                db_task_type
-                for db_task_type, domain_task_type in TaskTypeMapper.TASK_TYPE_MAPPING.items()  # noqa: E501
-                if domain_task_type == task_type
-            )
-        )
-
-
 class TaskMapper:
     """Maps between domain QueuedTask and SQLAlchemy Task entities.
 
@@ -52,13 +19,12 @@ class TaskMapper:
         Since QueuedTask doesn't have status fields, we store processing
         state in the payload.
         """
-        # Get the task type
-        task_type = TaskTypeMapper.to_domain_type(record.type)
-
+        if record.type not in TaskOperation.__members__.values():
+            raise ValueError(f"Unknown operation: {record.type}")
         # The dedup_key becomes the id in the domain entity
         return Task(
             id=record.dedup_key,  # Use dedup_key as the unique identifier
-            type=task_type,
+            type=TaskOperation(record.type),
             priority=record.priority,
             payload=record.payload or {},
             created_at=record.created_at,
@@ -68,14 +34,9 @@ class TaskMapper:
     @staticmethod
     def from_domain_task(task: Task) -> db_entities.Task:
         """Convert domain QueuedTask to SQLAlchemy Task record."""
-        if task.type not in TaskTypeMapper.TASK_TYPE_MAPPING.values():
-            raise ValueError(f"Unknown task type: {task.type}")
-
-        # Find value in TASK_TYPE_MAPPING
-        task_type = TaskTypeMapper.from_domain_type(task.type)
         return db_entities.Task(
             dedup_key=task.id,
-            type=task_type,
+            type=task.type.value,
             payload=task.payload,
             priority=task.priority,
         )

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