kodit 0.4.2__py3-none-any.whl → 0.4.3__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.4.2'
-__version_tuple__ = version_tuple = (0, 4, 2)
+__version__ = version = '0.4.3'
+__version_tuple__ = version_tuple = (0, 4, 3)
 
 __commit_id__ = commit_id = None

kodit/app.py

@@ -19,6 +19,9 @@ from kodit.infrastructure.api.v1.routers import (
     search_router,
 )
 from kodit.infrastructure.api.v1.schemas.context import AppLifespanState
+from kodit.infrastructure.sqlalchemy.task_status_repository import (
+    create_task_status_repository,
+)
 from kodit.mcp import mcp
 from kodit.middleware import ASGICancelledErrorMiddleware, logging_middleware
 
@@ -35,7 +38,9 @@ async def app_lifespan(_: FastAPI) -> AsyncIterator[AppLifespanState]:
     # App context has already been configured by the CLI.
     app_context = AppContext()
     db = await app_context.get_db()
-    operation = create_server_operation()
+    operation = create_server_operation(
+        create_task_status_repository(db.session_factory)
+    )
 
     # Start the queue worker service
     _indexing_worker_service = IndexingWorkerService(

kodit/application/factories/code_indexing_factory.py

@@ -51,22 +51,26 @@ from kodit.infrastructure.sqlalchemy.entities import EmbeddingType
 from kodit.infrastructure.sqlalchemy.index_repository import (
     create_index_repository,
 )
+from kodit.infrastructure.sqlalchemy.task_status_repository import (
+    create_task_status_repository,
+)
 
 
 def create_code_indexing_application_service(
     app_context: AppContext,
-    session: AsyncSession,
     session_factory: Callable[[], AsyncSession],
     operation: ProgressTracker,
 ) -> CodeIndexingApplicationService:
     """Create a unified code indexing application service with all dependencies."""
     # Create domain services
-    bm25_service = BM25DomainService(bm25_repository_factory(app_context, session))
+    bm25_service = BM25DomainService(
+        bm25_repository_factory(app_context, session_factory())
+    )
     code_search_service = embedding_domain_service_factory(
-        "code", app_context, session, session_factory
+        "code", app_context, session_factory(), session_factory
     )
     text_search_service = embedding_domain_service_factory(
-        "text", app_context, session, session_factory
+        "text", app_context, session_factory(), session_factory
     )
     enrichment_service = enrichment_domain_service_factory(app_context)
     index_repository = create_index_repository(session_factory=session_factory)
@@ -95,20 +99,17 @@ def create_code_indexing_application_service(
         code_search_service=code_search_service,
         text_search_service=text_search_service,
         enrichment_service=enrichment_service,
-        session=session,
         operation=operation,
     )
 
 
 def create_cli_code_indexing_application_service(
     app_context: AppContext,
-    session: AsyncSession,
     session_factory: Callable[[], AsyncSession],
 ) -> CodeIndexingApplicationService:
     """Create a CLI code indexing application service."""
     return create_code_indexing_application_service(
         app_context,
-        session,
         session_factory,
         create_cli_operation(),
     )
@@ -116,23 +117,25 @@ def create_cli_code_indexing_application_service(
 
 def create_server_code_indexing_application_service(
     app_context: AppContext,
-    session: AsyncSession,
     session_factory: Callable[[], AsyncSession],
 ) -> CodeIndexingApplicationService:
     """Create a server code indexing application service."""
     return create_code_indexing_application_service(
-        app_context, session, session_factory, create_server_operation()
+        app_context,
+        session_factory,
+        create_server_operation(create_task_status_repository(session_factory)),
     )
 
 
 def create_fast_test_code_indexing_application_service(
     app_context: AppContext,
-    session: AsyncSession,
     session_factory: Callable[[], AsyncSession],
 ) -> CodeIndexingApplicationService:
     """Create a fast test code indexing application service."""
     # Create domain services
-    bm25_service = BM25DomainService(bm25_repository_factory(app_context, session))
+    bm25_service = BM25DomainService(
+        bm25_repository_factory(app_context, session_factory())
+    )
     embedding_repository = create_embedding_repository(session_factory=session_factory)
     operation = create_noop_operation()
 
@@ -188,6 +191,5 @@ def create_fast_test_code_indexing_application_service(
         code_search_service=code_search_service,
         text_search_service=text_search_service,
         enrichment_service=enrichment_service,
-        session=session,
         operation=operation,
     )

kodit/application/factories/reporting_factory.py

@@ -1,27 +1,32 @@
 """Reporting factory."""
 
-from kodit.application.services.reporting import OperationType, ProgressTracker
+from kodit.application.services.reporting import ProgressTracker, TaskOperation
 from kodit.config import ReportingConfig
+from kodit.domain.protocols import TaskStatusRepository
+from kodit.infrastructure.reporting.db_progress import DBProgressReportingModule
 from kodit.infrastructure.reporting.log_progress import LoggingReportingModule
 from kodit.infrastructure.reporting.tdqm_progress import TQDMReportingModule
 
 
 def create_noop_operation() -> ProgressTracker:
     """Create a noop reporter."""
-    return ProgressTracker(OperationType.ROOT.value)
+    return ProgressTracker.create(TaskOperation.ROOT)
 
 
 def create_cli_operation(config: ReportingConfig | None = None) -> ProgressTracker:
     """Create a CLI reporter."""
     shared_config = config or ReportingConfig()
-    s = ProgressTracker(OperationType.ROOT.value)
+    s = ProgressTracker.create(TaskOperation.ROOT)
     s.subscribe(TQDMReportingModule(shared_config))
     return s
 
 
-def create_server_operation(config: ReportingConfig | None = None) -> ProgressTracker:
+def create_server_operation(
+    task_status_repository: TaskStatusRepository, config: ReportingConfig | None = None
+) -> ProgressTracker:
     """Create a server reporter."""
     shared_config = config or ReportingConfig()
-    s = ProgressTracker(OperationType.ROOT.value)
+    s = ProgressTracker.create(TaskOperation.ROOT)
     s.subscribe(LoggingReportingModule(shared_config))
+    s.subscribe(DBProgressReportingModule(task_status_repository, shared_config))
     return s

kodit/application/services/auto_indexing_service.py

@@ -62,38 +62,34 @@ class AutoIndexingService:
     ) -> None:
         """Index all configured sources in the background."""
         operation = operation or create_noop_operation()
-        async with self.session_factory() as session:
-            queue_service = QueueService(session_factory=self.session_factory)
-            service = create_code_indexing_application_service(
-                app_context=self.app_context,
-                session=session,
-                session_factory=self.session_factory,
-                operation=operation,
-            )
-
-            for source in sources:
-                try:
-                    # Only auto-index a source if it is new
-                    if await service.does_index_exist(source):
-                        self.log.info("Index already exists, skipping", source=source)
-                        continue
-
-                    self.log.info("Adding auto-indexing task to queue", source=source)
-
-                    # Create index
-                    index = await service.create_index_from_uri(source)
-
-                    await queue_service.enqueue_task(
-                        Task.create_index_update_task(
-                            index.id, QueuePriority.BACKGROUND
-                        )
-                    )
-
-                except Exception as exc:
-                    self.log.exception(
-                        "Failed to auto-index source", source=source, error=str(exc)
-                    )
-                    # Continue with other sources even if one fails
+        queue_service = QueueService(session_factory=self.session_factory)
+        service = create_code_indexing_application_service(
+            app_context=self.app_context,
+            session_factory=self.session_factory,
+            operation=operation,
+        )
+
+        for source in sources:
+            try:
+                # Only auto-index a source if it is new
+                if await service.does_index_exist(source):
+                    self.log.info("Index already exists, skipping", source=source)
+                    continue
+
+                self.log.info("Adding auto-indexing task to queue", source=source)
+
+                # Create index
+                index = await service.create_index_from_uri(source)
+
+                await queue_service.enqueue_task(
+                    Task.create_index_update_task(index.id, QueuePriority.BACKGROUND)
+                )
+
+            except Exception as exc:
+                self.log.exception(
+                    "Failed to auto-index source", source=source, error=str(exc)
+                )
+                # Continue with other sources even if one fails
 
     async def stop(self) -> None:
         """Stop background indexing."""

kodit/application/services/code_indexing_application_service.py

@@ -4,11 +4,10 @@ from dataclasses import replace
 from datetime import UTC, datetime
 
 import structlog
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.application.services.reporting import (
-    OperationType,
     ProgressTracker,
+    TaskOperation,
 )
 from kodit.domain.entities import Index, Snippet
 from kodit.domain.protocols import IndexRepository
@@ -26,6 +25,7 @@ from kodit.domain.value_objects import (
     SearchRequest,
     SearchResult,
     SnippetSearchFilters,
+    TrackableType,
 )
 from kodit.log import log_event
 
@@ -42,7 +42,6 @@ class CodeIndexingApplicationService:
         code_search_service: EmbeddingDomainService,
         text_search_service: EmbeddingDomainService,
         enrichment_service: EnrichmentDomainService,
-        session: AsyncSession,
         operation: ProgressTracker,
     ) -> None:
         """Initialize the code indexing application service."""
@@ -53,7 +52,6 @@ class CodeIndexingApplicationService:
         self.code_search_service = code_search_service
         self.text_search_service = text_search_service
         self.enrichment_service = enrichment_service
-        self.session = session
         self.operation = operation
         self.log = structlog.get_logger(__name__)
 
@@ -67,7 +65,7 @@ class CodeIndexingApplicationService:
     async def create_index_from_uri(self, uri: str) -> Index:
         """Create a new index for a source."""
         log_event("kodit.index.create")
-        with self.operation.create_child(OperationType.CREATE_INDEX.value) as operation:
+        async with self.operation.create_child(TaskOperation.CREATE_INDEX) as operation:
             # Check if index already exists
             sanitized_uri, _ = self.index_domain_service.sanitize_uri(uri)
             self.log.info("Creating index from URI", uri=str(sanitized_uri))
@@ -86,14 +84,16 @@ class CodeIndexingApplicationService:
 
             # Create new index
             self.log.info("Creating index", uri=str(sanitized_uri))
-            index = await self.index_repository.create(sanitized_uri, working_copy)
-            await self.session.commit()
-            return index
+            return await self.index_repository.create(sanitized_uri, working_copy)
 
     async def run_index(self, index: Index) -> None:
         """Run the complete indexing process for a specific index."""
         # Create a new operation
-        with self.operation.create_child(OperationType.RUN_INDEX.value) as operation:
+        async with self.operation.create_child(
+            TaskOperation.RUN_INDEX,
+            trackable_type=TrackableType.INDEX,
+            trackable_id=index.id,
+        ) as operation:
             # TODO(philwinder): Move this into a reporter # noqa: TD003, FIX002
             log_event("kodit.index.run")
 
@@ -102,7 +102,9 @@ class CodeIndexingApplicationService:
                 raise ValueError(msg)
 
             # Refresh working copy
-            with operation.create_child("Refresh working copy") as step:
+            async with operation.create_child(
+                TaskOperation.REFRESH_WORKING_COPY
+            ) as step:
                 index.source.working_copy = (
                     await self.index_domain_service.refresh_working_copy(
                         index.source.working_copy, step
@@ -110,11 +112,13 @@ class CodeIndexingApplicationService:
                 )
                 if len(index.source.working_copy.changed_files()) == 0:
                     self.log.info("No new changes to index", index_id=index.id)
-                    step.skip("No new changes to index")
+                    await step.skip("No new changes to index")
                     return
 
             # Delete the old snippets from the files that have changed
-            with operation.create_child("Delete old snippets") as step:
+            async with operation.create_child(
+                TaskOperation.DELETE_OLD_SNIPPETS
+            ) as step:
                 await self.index_repository.delete_snippets_by_file_ids(
                     [
                         file.id
@@ -124,7 +128,7 @@ class CodeIndexingApplicationService:
                 )
 
             # Extract and create snippets (domain service handles progress)
-            with operation.create_child("Extract snippets") as step:
+            async with operation.create_child(TaskOperation.EXTRACT_SNIPPETS) as step:
                 index = await self.index_domain_service.extract_snippets_from_index(
                     index=index, step=step
                 )
@@ -140,20 +144,22 @@ class CodeIndexingApplicationService:
                     self.log.info(
                         "No snippets to index after extraction", index_id=index.id
                     )
-                    step.skip("No snippets to index after extraction")
+                    await step.skip("No snippets to index after extraction")
                     return
 
             # Create BM25 index
             self.log.info("Creating keyword index")
-            with operation.create_child("Create BM25 index") as step:
+            async with operation.create_child(TaskOperation.CREATE_BM25_INDEX) as step:
                 await self._create_bm25_index(index.snippets)
 
             # Create code embeddings
-            with operation.create_child("Create code embeddings") as step:
+            async with operation.create_child(
+                TaskOperation.CREATE_CODE_EMBEDDINGS
+            ) as step:
                 await self._create_code_embeddings(index.snippets, step)
 
             # Enrich snippets
-            with operation.create_child("Enrich snippets") as step:
+            async with operation.create_child(TaskOperation.ENRICH_SNIPPETS) as step:
                 enriched_snippets = (
                     await self.index_domain_service.enrich_snippets_in_index(
                         snippets=index.snippets,
@@ -164,15 +170,21 @@ class CodeIndexingApplicationService:
                 await self.index_repository.update_snippets(index.id, enriched_snippets)
 
             # Create text embeddings (on enriched content)
-            with operation.create_child("Create text embeddings") as step:
+            async with operation.create_child(
+                TaskOperation.CREATE_TEXT_EMBEDDINGS
+            ) as step:
                 await self._create_text_embeddings(enriched_snippets, step)
 
             # Update index timestamp
-            with operation.create_child("Update index timestamp") as step:
+            async with operation.create_child(
+                TaskOperation.UPDATE_INDEX_TIMESTAMP
+            ) as step:
                 await self.index_repository.update_index_timestamp(index.id)
 
             # After indexing, clear the file processing statuses
-            with operation.create_child("Clear file processing statuses") as step:
+            async with operation.create_child(
+                TaskOperation.CLEAR_FILE_PROCESSING_STATUSES
+            ) as step:
                 index.source.working_copy.clear_file_processing_statuses()
                 await self.index_repository.update(index)
 
@@ -340,7 +352,7 @@ class CodeIndexingApplicationService:
     async def _create_code_embeddings(
         self, snippets: list[Snippet], reporting_step: ProgressTracker
     ) -> None:
-        reporting_step.set_total(len(snippets))
+        await reporting_step.set_total(len(snippets))
         processed = 0
         async for result in self.code_search_service.index_documents(
             IndexRequest(
@@ -352,7 +364,9 @@ class CodeIndexingApplicationService:
             )
         ):
             processed += len(result)
-            reporting_step.set_current(processed)
+            await reporting_step.set_current(
+                processed, f"Creating code embeddings for {processed} snippets"
+            )
 
     async def _create_text_embeddings(
         self, snippets: list[Snippet], reporting_step: ProgressTracker
@@ -372,16 +386,20 @@ class CodeIndexingApplicationService:
                     continue
 
         if not documents_with_summaries:
-            reporting_step.skip("No snippets with summaries to create text embeddings")
+            await reporting_step.skip(
+                "No snippets with summaries to create text embeddings"
+            )
             return
 
-        reporting_step.set_total(len(documents_with_summaries))
+        await reporting_step.set_total(len(documents_with_summaries))
         processed = 0
         async for result in self.text_search_service.index_documents(
             IndexRequest(documents=documents_with_summaries)
         ):
             processed += len(result)
-            reporting_step.set_current(processed)
+            await reporting_step.set_current(
+                processed, f"Creating text embeddings for {processed} snippets"
+            )
 
     async def delete_index(self, index: Index) -> None:
         """Delete an index."""
@@ -390,4 +408,3 @@ class CodeIndexingApplicationService:
 
         # Delete index from the database
         await self.index_repository.delete(index)
-        await self.session.commit()

kodit/application/services/indexing_worker_service.py

@@ -136,17 +136,15 @@ class IndexingWorkerService:
         # Create a fresh database connection for this thread's event loop
         db = await self.app_context.new_db(run_migrations=True)
         try:
-            async with db.session_factory() as session:
-                service = create_code_indexing_application_service(
-                    app_context=self.app_context,
-                    session=session,
-                    session_factory=self.session_factory,
-                    operation=operation,
-                )
-                index = await service.index_repository.get(index_id)
-                if not index:
-                    raise ValueError(f"Index not found: {index_id}")
-
-                await service.run_index(index)
+            service = create_code_indexing_application_service(
+                app_context=self.app_context,
+                session_factory=self.session_factory,
+                operation=operation,
+            )
+            index = await service.index_repository.get(index_id)
+            if not index:
+                raise ValueError(f"Index not found: {index_id}")
+
+            await service.run_index(index)
         finally:
             await db.close()

kodit/application/services/reporting.py

@@ -1,86 +1,104 @@
 """Reporting."""
 
-from enum import StrEnum
-from types import TracebackType
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING
 
 import structlog
 
-from kodit.domain.value_objects import Progress, ReportingState
+from kodit.domain.entities import TaskStatus
+from kodit.domain.value_objects import TaskOperation, TrackableType
 
 if TYPE_CHECKING:
     from kodit.domain.protocols import ReportingModule
 
 
-class OperationType(StrEnum):
-    """Operation type."""
-
-    ROOT = "kodit.root"
-    CREATE_INDEX = "kodit.index.create"
-    RUN_INDEX = "kodit.index.run"
+class ProgressTracker:
+    """Progress tracker.
 
+    Provides a reactive wrapper around TaskStatus domain entities that automatically
+    propagates state changes to the database and reporting modules. This pattern was
+    chosen over a traditional service-repository approach because:
+    - State changes must trigger immediate side effects (database writes, notifications)
+    - Multiple consumers need real-time updates without polling
+    - The wrapper pattern allows transparent interception of all state mutations
 
-class ProgressTracker:
-    """Progress tracker."""
+    The tracker monitors all modifications to the underlying TaskStatus and ensures
+    consistency across all downstream systems.
+    """
 
-    def __init__(self, name: str, parent: "ProgressTracker | None" = None) -> None:
+    def __init__(
+        self,
+        task_status: TaskStatus,
+    ) -> None:
         """Initialize the progress tracker."""
-        self._parent: ProgressTracker | None = parent
-        self._children: list[ProgressTracker] = []
+        self.task_status = task_status
         self._log = structlog.get_logger(__name__)
         self._subscribers: list[ReportingModule] = []
-        self._snapshot: Progress = Progress(name=name, state=ReportingState.IN_PROGRESS)
-
-    def __enter__(self) -> "ProgressTracker":
-        """Enter the operation."""
-        self._notify_subscribers()
-        return self
 
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        """Exit the operation."""
-        if exc_value:
-            self._snapshot = self._snapshot.with_error(exc_value)
-            self._snapshot = self._snapshot.with_state(
-                ReportingState.FAILED, str(exc_value)
+    @staticmethod
+    def create(
+        operation: TaskOperation,
+        parent: "TaskStatus | None" = None,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> "ProgressTracker":
+        """Create a progress tracker."""
+        return ProgressTracker(
+            TaskStatus.create(
+                operation=operation,
+                trackable_type=trackable_type,
+                trackable_id=trackable_id,
+                parent=parent,
             )
+        )
 
-        if self._snapshot.state == ReportingState.IN_PROGRESS:
-            self._snapshot = self._snapshot.with_progress(100)
-            self._snapshot = self._snapshot.with_state(ReportingState.COMPLETED)
-        self._notify_subscribers()
-
-    def create_child(self, name: str) -> "ProgressTracker":
+    @asynccontextmanager
+    async def create_child(
+        self,
+        operation: TaskOperation,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> AsyncGenerator["ProgressTracker", None]:
         """Create a child step."""
-        s = ProgressTracker(name, self)
-        self._children.append(s)
-        for subscriber in self._subscribers:
-            s.subscribe(subscriber)
-        return s
-
-    def skip(self, reason: str | None = None) -> None:
+        c = ProgressTracker.create(
+            operation=operation,
+            parent=self.task_status,
+            trackable_type=trackable_type or self.task_status.trackable_type,
+            trackable_id=trackable_id or self.task_status.trackable_id,
+        )
+        try:
+            for subscriber in self._subscribers:
+                c.subscribe(subscriber)
+
+            await c.notify_subscribers()
+            yield c
+        except Exception as e:  # noqa: BLE001
+            c.task_status.fail(str(e))
+        finally:
+            c.task_status.complete()
+            await c.notify_subscribers()
+
+    async def skip(self, reason: str) -> None:
         """Skip the step."""
-        self._snapshot = self._snapshot.with_state(ReportingState.SKIPPED, reason or "")
+        self.task_status.skip(reason)
+        await self.notify_subscribers()
 
     def subscribe(self, subscriber: "ReportingModule") -> None:
         """Subscribe to the step."""
         self._subscribers.append(subscriber)
 
-    def set_total(self, total: int) -> None:
+    async def set_total(self, total: int) -> None:
         """Set the total for the step."""
-        self._snapshot = self._snapshot.with_total(total)
-        self._notify_subscribers()
+        self.task_status.set_total(total)
+        await self.notify_subscribers()
 
-    def set_current(self, current: int) -> None:
+    async def set_current(self, current: int, message: str | None = None) -> None:
         """Progress the step."""
-        self._snapshot = self._snapshot.with_progress(current)
-        self._notify_subscribers()
+        self.task_status.set_current(current, message)
+        await self.notify_subscribers()
 
-    def _notify_subscribers(self) -> None:
-        """Notify the subscribers."""
+    async def notify_subscribers(self) -> None:
+        """Notify the subscribers only if progress has changed."""
         for subscriber in self._subscribers:
-            subscriber.on_change(self._snapshot)
+            await subscriber.on_change(self.task_status)