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

kodit/infrastructure/mappers/snippet_mapper.py

@@ -0,0 +1,106 @@
+"""Mapping between domain Git entities and SQLAlchemy entities."""
+
+import kodit.domain.entities.git as domain_git_entities
+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[db_entities.Enrichment],
+    ) -> 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,
+            )
+            enrichments.append(enrichment)
+
+        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[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,
+                content=enrichment.content,
+            )
+            db_enrichments.append(db_enrichment)
+        return db_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/mappers/task_status_mapper.py

@@ -0,0 +1,85 @@
+"""Task status mapper."""
+
+from kodit.domain import entities as domain_entities
+from kodit.domain.value_objects import ReportingState, TaskOperation, TrackableType
+from kodit.infrastructure.sqlalchemy import entities as db_entities
+
+
+class TaskStatusMapper:
+    """Mapper for converting between domain TaskStatus and database entities."""
+
+    @staticmethod
+    def from_domain_task_status(
+        task_status: domain_entities.TaskStatus,
+    ) -> db_entities.TaskStatus:
+        """Convert domain TaskStatus to database TaskStatus."""
+        return db_entities.TaskStatus(
+            id=task_status.id,
+            operation=task_status.operation,
+            created_at=task_status.created_at,
+            updated_at=task_status.updated_at,
+            trackable_id=task_status.trackable_id,
+            trackable_type=(
+                task_status.trackable_type.value if task_status.trackable_type else None
+            ),
+            parent=task_status.parent.id if task_status.parent else None,
+            state=(
+                task_status.state.value
+                if isinstance(task_status.state, ReportingState)
+                else task_status.state
+            ),
+            error=task_status.error,
+            total=task_status.total,
+            current=task_status.current,
+            message=task_status.message,
+        )
+
+    @staticmethod
+    def to_domain_task_status(
+        db_status: db_entities.TaskStatus,
+    ) -> domain_entities.TaskStatus:
+        """Convert database TaskStatus to domain TaskStatus."""
+        return domain_entities.TaskStatus(
+            id=db_status.id,
+            operation=TaskOperation(db_status.operation),
+            state=ReportingState(db_status.state),
+            created_at=db_status.created_at,
+            updated_at=db_status.updated_at,
+            trackable_id=db_status.trackable_id,
+            trackable_type=(
+                TrackableType(db_status.trackable_type)
+                if db_status.trackable_type
+                else None
+            ),
+            parent=None,  # Parent relationships need to be reconstructed separately
+            error=db_status.error if db_status.error else None,
+            total=db_status.total,
+            current=db_status.current,
+            message=db_status.message,
+        )
+
+    @staticmethod
+    def to_domain_task_status_with_hierarchy(
+        db_statuses: list[db_entities.TaskStatus],
+    ) -> list[domain_entities.TaskStatus]:
+        """Convert database TaskStatus list to domain with parent-child hierarchy.
+
+        This method performs a two-pass conversion:
+        1. First pass: Convert all DB entities to domain entities
+        2. Second pass: Reconstruct parent-child relationships using ID mapping
+        """
+        # First pass: Convert all database entities to domain entities
+        domain_statuses = [
+            TaskStatusMapper.to_domain_task_status(db_status)
+            for db_status in db_statuses
+        ]
+
+        # Create ID-to-entity mapping for efficient parent lookup
+        id_to_entity = {status.id: status for status in domain_statuses}
+
+        # Second pass: Reconstruct parent-child relationships
+        for db_status, domain_status in zip(db_statuses, domain_statuses, strict=True):
+            if db_status.parent and db_status.parent in id_to_entity:
+                domain_status.parent = id_to_entity[db_status.parent]
+
+        return domain_statuses

kodit/infrastructure/reporting/db_progress.py

@@ -0,0 +1,23 @@
+"""Log progress using structlog."""
+
+import structlog
+
+from kodit.config import ReportingConfig
+from kodit.domain.entities import TaskStatus
+from kodit.domain.protocols import ReportingModule, TaskStatusRepository
+
+
+class DBProgressReportingModule(ReportingModule):
+    """Database progress reporting module."""
+
+    def __init__(
+        self, task_status_repository: TaskStatusRepository, config: ReportingConfig
+    ) -> None:
+        """Initialize the database progress reporting module."""
+        self.task_status_repository = task_status_repository
+        self.config = config
+        self._log = structlog.get_logger(__name__)
+
+    async def on_change(self, progress: TaskStatus) -> None:
+        """On step changed - update task status in database."""
+        await self.task_status_repository.save(progress)

kodit/infrastructure/reporting/log_progress.py

@@ -1,13 +1,13 @@
 """Log progress using structlog."""
 
-import time
 from datetime import UTC, datetime
 
 import structlog
 
 from kodit.config import ReportingConfig
+from kodit.domain.entities import TaskStatus
 from kodit.domain.protocols import ReportingModule
-from kodit.domain.value_objects import Progress, ProgressState, ReportingState
+from kodit.domain.value_objects import ReportingState
 
 
 class LoggingReportingModule(ReportingModule):
@@ -19,47 +19,22 @@ class LoggingReportingModule(ReportingModule):
         self._log = structlog.get_logger(__name__)
         self._last_log_time: datetime = datetime.now(UTC)
 
-    def on_change(self, step: Progress) -> None:
+    async def on_change(self, progress: TaskStatus) -> None:
         """On step changed."""
         current_time = datetime.now(UTC)
-        time_since_last_log = current_time - self._last_log_time
+        step = progress
 
-        if (
-            step.state != ReportingState.IN_PROGRESS
-            or time_since_last_log >= self.config.log_time_interval
-        ):
+        if step.state == ReportingState.FAILED:
+            self._log.exception(
+                step.operation,
+                state=step.state,
+                completion_percent=step.completion_percent,
+                error=step.error,
+            )
+        else:
             self._log.info(
-                step.name,
+                step.operation,
                 state=step.state,
-                message=step.message,
                 completion_percent=step.completion_percent,
             )
             self._last_log_time = current_time
-
-
-class LogProgress(Progress):
-    """Log progress using structlog with time-based throttling."""
-
-    def __init__(self, config: ReportingConfig | None = None) -> None:
-        """Initialize the log progress."""
-        self.log = structlog.get_logger()
-        self.config = config or ReportingConfig()
-        self.last_log_time: float = 0
-
-    def on_update(self, state: ProgressState) -> None:
-        """Log the progress with time-based throttling."""
-        current_time = time.time()
-        time_since_last_log = current_time - self.last_log_time
-
-        if time_since_last_log >= self.config.log_time_interval.total_seconds():
-            self.log.info(
-                "Progress...",
-                operation=state.operation,
-                percentage=state.percentage,
-                message=state.message,
-            )
-            self.last_log_time = current_time
-
-    def on_complete(self) -> None:
-        """Log the completion."""
-        self.log.info("Completed")

kodit/infrastructure/reporting/telemetry_progress.py

@@ -0,0 +1,21 @@
+"""Log progress using telemetry."""
+
+import structlog
+
+from kodit.domain.entities import TaskStatus
+from kodit.domain.protocols import ReportingModule
+from kodit.log import log_event
+
+
+class TelemetryProgressReportingModule(ReportingModule):
+    """Database progress reporting module."""
+
+    def __init__(self) -> None:
+        """Initialize the logging reporting module."""
+        self._log = structlog.get_logger(__name__)
+
+    async def on_change(self, progress: TaskStatus) -> None:
+        """On step changed."""
+        log_event(
+            progress.operation,
+        )

kodit/infrastructure/slicing/slicer.py

@@ -14,7 +14,7 @@ import structlog
 from tree_sitter import Node, Parser, Tree
 from tree_sitter_language_pack import get_language
 
-from kodit.domain.entities import File, Snippet
+from kodit.domain.entities.git import GitFile, SnippetV2
 from kodit.domain.value_objects import LanguageMapping
 
 
@@ -149,9 +149,9 @@ class Slicer:
         """Initialize an empty slicer."""
         self.log = structlog.get_logger(__name__)
 
-    def extract_snippets(  # noqa: C901
-        self, files: list[File], language: str = "python"
-    ) -> list[Snippet]:
+    def extract_snippets_from_git_files(  # noqa: C901
+        self, files: list[GitFile], language: str = "python"
+    ) -> list[SnippetV2]:
         """Extract code snippets from a list of files.
 
         Args:
@@ -187,10 +187,10 @@ class Slicer:
             raise RuntimeError(f"Failed to load {language} parser: {e}") from e
 
         # Create mapping from Paths to File objects and extract paths
-        path_to_file_map: dict[Path, File] = {}
+        path_to_file_map: dict[Path, GitFile] = {}
         file_paths: list[Path] = []
         for file in files:
-            file_path = file.as_path()
+            file_path = Path(file.path)
 
             # Validate file matches language
             if not self._file_matches_language(file_path.suffix, language):
@@ -225,7 +225,7 @@ class Slicer:
         self._build_reverse_call_graph(state)
 
         # Extract snippets for all functions
-        snippets = []
+        snippets: list[SnippetV2] = []
         for qualified_name in state.def_index:
             snippet_content = self._get_snippet(
                 qualified_name,
@@ -234,7 +234,7 @@ class Slicer:
                 {"max_depth": 2, "max_functions": 8},
             )
             if "not found" not in snippet_content:
-                snippet = self._create_snippet_entity(
+                snippet = self._create_snippet_entity_from_git_files(
                     qualified_name, snippet_content, language, state, path_to_file_map
                 )
                 snippets.append(snippet)
@@ -247,8 +247,8 @@ class Slicer:
             return False
 
         try:
-            return (
-                language == LanguageMapping.get_language_for_extension(file_extension)
+            return language == LanguageMapping.get_language_for_extension(
+                file_extension
             )
         except ValueError:
             # Extension not supported, so it doesn't match any language
@@ -614,7 +614,8 @@ class Slicer:
             if callers:
                 snippet_lines.append("")
                 snippet_lines.append("# === USAGE EXAMPLES ===")
-                for caller in list(callers)[:2]:  # Show up to 2 examples
+                # Show up to 2 examples, sorted for deterministic order
+                for caller in sorted(callers)[:2]:
                     call_line = self._find_function_call_line(
                         caller, function_name, state, file_contents
                     )
@@ -625,37 +626,37 @@ class Slicer:
 
         return "\n".join(snippet_lines)
 
-    def _create_snippet_entity(
+    def _create_snippet_entity_from_git_files(
         self,
         qualified_name: str,
         snippet_content: str,
         language: str,
         state: AnalyzerState,
-        path_to_file_map: dict[Path, File],
-    ) -> Snippet:
+        path_to_file_map: dict[Path, GitFile],
+    ) -> SnippetV2:
         """Create a Snippet domain entity from extracted content."""
         # Determine all files that this snippet derives from
-        derives_from_files = self._find_source_files_for_snippet(
+        derives_from_files = self._find_source_files_for_snippet_from_git_files(
             qualified_name, snippet_content, state, path_to_file_map
         )
 
         # Create the snippet entity
-        snippet = Snippet(derives_from=derives_from_files)
-
-        # Add the original content
-        snippet.add_original_content(snippet_content, language)
-
-        return snippet
+        return SnippetV2(
+            derives_from=derives_from_files,
+            content=snippet_content,
+            extension=language,
+            sha=SnippetV2.compute_sha(snippet_content),
+        )
 
-    def _find_source_files_for_snippet(
+    def _find_source_files_for_snippet_from_git_files(
         self,
         qualified_name: str,
         snippet_content: str,
         state: AnalyzerState,
-        path_to_file_map: dict[Path, File],
-    ) -> list[File]:
+        path_to_file_map: dict[Path, GitFile],
+    ) -> list[GitFile]:
         """Find all source files that a snippet derives from."""
-        source_files: list[File] = []
+        source_files: list[GitFile] = []
         source_file_paths: set[Path] = set()
 
         # Add the primary function's file
@@ -835,7 +836,7 @@ class Slicer:
             # Add direct dependencies
             to_visit.extend(
                 (callee, depth + 1)
-                for callee in state.call_graph.get(current, set())
+                for callee in sorted(state.call_graph.get(current, set()))
                 if callee not in visited and callee in state.def_index
             )
 
@@ -850,26 +851,26 @@ class Slicer:
         in_degree: dict[str, int] = defaultdict(int)
         graph: dict[str, set[str]] = defaultdict(set)
 
-        for func in functions:
-            for callee in state.call_graph.get(func, set()):
+        for func in sorted(functions):
+            for callee in sorted(state.call_graph.get(func, set())):
                 if callee in functions:
                     graph[func].add(callee)
                     in_degree[callee] += 1
 
         # Find roots
-        queue = [f for f in functions if in_degree[f] == 0]
+        queue = [f for f in sorted(functions) if in_degree[f] == 0]
         result = []
 
         while queue:
             current = queue.pop(0)
             result.append(current)
-            for neighbor in graph[current]:
+            for neighbor in sorted(graph[current]):
                 in_degree[neighbor] -= 1
                 if in_degree[neighbor] == 0:
                     queue.append(neighbor)
 
         # Add any remaining (cycles)
-        for func in functions:
+        for func in sorted(functions):
             if func not in result:
                 result.append(func)