kodit 0.4.1__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.1'
-__version_tuple__ = version_tuple = (0, 4, 1)
+__version__ = version = '0.4.3'
+__version_tuple__ = version_tuple = (0, 4, 3)
 
 __commit_id__ = commit_id = None

kodit/app.py

@@ -8,6 +8,7 @@ from fastapi import FastAPI, Response
 from fastapi.responses import RedirectResponse
 
 from kodit._version import version
+from kodit.application.factories.reporting_factory import create_server_operation
 from kodit.application.services.auto_indexing_service import AutoIndexingService
 from kodit.application.services.indexing_worker_service import IndexingWorkerService
 from kodit.application.services.sync_scheduler import SyncSchedulerService
@@ -18,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
 
@@ -34,20 +38,23 @@ 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(
+        create_task_status_repository(db.session_factory)
+    )
 
     # Start the queue worker service
     _indexing_worker_service = IndexingWorkerService(
         app_context=app_context,
         session_factory=db.session_factory,
     )
-    await _indexing_worker_service.start()
+    await _indexing_worker_service.start(operation)
 
     # Start auto-indexing service
     _auto_indexing_service = AutoIndexingService(
         app_context=app_context,
         session_factory=db.session_factory,
     )
-    await _auto_indexing_service.start_background_indexing()
+    await _auto_indexing_service.start_background_indexing(operation)
 
     # Start sync scheduler service
     if app_context.periodic_sync.enabled:

kodit/application/factories/code_indexing_factory.py

@@ -1,10 +1,20 @@
 """Factory for creating the unified code indexing application service."""
 
+from collections.abc import Callable
+
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from kodit.application.factories.reporting_factory import (
+    create_cli_operation,
+    create_noop_operation,
+    create_server_operation,
+)
 from kodit.application.services.code_indexing_application_service import (
     CodeIndexingApplicationService,
 )
+from kodit.application.services.reporting import (
+    ProgressTracker,
+)
 from kodit.config import AppContext
 from kodit.domain.services.bm25_service import BM25DomainService
 from kodit.domain.services.embedding_service import EmbeddingDomainService
@@ -35,23 +45,35 @@ from kodit.infrastructure.slicing.language_detection_service import (
     FileSystemLanguageDetectionService,
 )
 from kodit.infrastructure.sqlalchemy.embedding_repository import (
-    SqlAlchemyEmbeddingRepository,
+    create_embedding_repository,
 )
 from kodit.infrastructure.sqlalchemy.entities import EmbeddingType
-from kodit.infrastructure.sqlalchemy.index_repository import SqlAlchemyIndexRepository
+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))
-    code_search_service = embedding_domain_service_factory("code", app_context, session)
-    text_search_service = embedding_domain_service_factory("text", app_context, session)
+    bm25_service = BM25DomainService(
+        bm25_repository_factory(app_context, session_factory())
+    )
+    code_search_service = embedding_domain_service_factory(
+        "code", app_context, session_factory(), session_factory
+    )
+    text_search_service = embedding_domain_service_factory(
+        "text", app_context, session_factory(), session_factory
+    )
     enrichment_service = enrichment_domain_service_factory(app_context)
-    index_repository = SqlAlchemyIndexRepository(session=session)
+    index_repository = create_index_repository(session_factory=session_factory)
     # Use the unified language mapping from the domain layer
     language_map = LanguageMapping.get_extension_to_language_map()
 
@@ -77,18 +99,45 @@ 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_factory: Callable[[], AsyncSession],
+) -> CodeIndexingApplicationService:
+    """Create a CLI code indexing application service."""
+    return create_code_indexing_application_service(
+        app_context,
+        session_factory,
+        create_cli_operation(),
+    )
+
+
+def create_server_code_indexing_application_service(
+    app_context: AppContext,
+    session_factory: Callable[[], AsyncSession],
+) -> CodeIndexingApplicationService:
+    """Create a server code indexing application service."""
+    return create_code_indexing_application_service(
+        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))
-    embedding_repository = SqlAlchemyEmbeddingRepository(session=session)
+    bm25_service = BM25DomainService(
+        bm25_repository_factory(app_context, session_factory())
+    )
+    embedding_repository = create_embedding_repository(session_factory=session_factory)
+    operation = create_noop_operation()
 
     code_search_repository = LocalVectorSearchRepository(
         embedding_repository=embedding_repository,
@@ -116,7 +165,7 @@ def create_fast_test_code_indexing_application_service(
         enrichment_provider=NullEnrichmentProvider()
     )
 
-    index_repository = SqlAlchemyIndexRepository(session=session)
+    index_repository = create_index_repository(session_factory=session_factory)
     # Use the unified language mapping from the domain layer
     language_map = LanguageMapping.get_extension_to_language_map()
 
@@ -142,5 +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

@@ -0,0 +1,32 @@
+"""Reporting factory."""
+
+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.create(TaskOperation.ROOT)
+
+
+def create_cli_operation(config: ReportingConfig | None = None) -> ProgressTracker:
+    """Create a CLI reporter."""
+    shared_config = config or ReportingConfig()
+    s = ProgressTracker.create(TaskOperation.ROOT)
+    s.subscribe(TQDMReportingModule(shared_config))
+    return s
+
+
+def create_server_operation(
+    task_status_repository: TaskStatusRepository, config: ReportingConfig | None = None
+) -> ProgressTracker:
+    """Create a server reporter."""
+    shared_config = config or ReportingConfig()
+    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

@@ -11,7 +11,9 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from kodit.application.factories.code_indexing_factory import (
     create_code_indexing_application_service,
 )
+from kodit.application.factories.reporting_factory import create_noop_operation
 from kodit.application.services.queue_service import QueueService
+from kodit.application.services.reporting import ProgressTracker
 from kodit.config import AppContext
 from kodit.domain.entities import Task
 from kodit.domain.value_objects import QueuePriority
@@ -31,8 +33,11 @@ class AutoIndexingService:
         self.log = structlog.get_logger(__name__)
         self._indexing_task: asyncio.Task | None = None
 
-    async def start_background_indexing(self) -> None:
+    async def start_background_indexing(
+        self, operation: ProgressTracker | None = None
+    ) -> None:
         """Start background indexing of configured sources."""
+        operation = operation or create_noop_operation()
         if (
             not self.app_context.auto_indexing
             or len(self.app_context.auto_indexing.sources) == 0
@@ -48,40 +53,43 @@ class AutoIndexingService:
 
         auto_sources = [source.uri for source in self.app_context.auto_indexing.sources]
         self.log.info("Starting background indexing", num_sources=len(auto_sources))
-        self._indexing_task = asyncio.create_task(self._index_sources(auto_sources))
+        self._indexing_task = asyncio.create_task(
+            self._index_sources(auto_sources, operation)
+        )
 
-    async def _index_sources(self, sources: list[str]) -> None:
+    async def _index_sources(
+        self, sources: list[str], operation: ProgressTracker | None = None
+    ) -> None:
         """Index all configured sources in the background."""
-        async with self.session_factory() as session:
-            queue_service = QueueService(session=session)
-            service = create_code_indexing_application_service(
-                app_context=self.app_context,
-                session=session,
-            )
-
-            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
+        operation = operation or create_noop_operation()
+        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."""