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

kodit/application/services/indexing_worker_service.py

@@ -8,14 +8,11 @@ from datetime import UTC, datetime
 import structlog
 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.factories.server_factory import ServerFactory
 from kodit.application.services.reporting import ProgressTracker
 from kodit.config import AppContext
 from kodit.domain.entities import Task
-from kodit.domain.value_objects import TaskType
 from kodit.infrastructure.sqlalchemy.task_repository import create_task_repository
 
 
@@ -30,10 +27,12 @@ class IndexingWorkerService:
         self,
         app_context: AppContext,
         session_factory: Callable[[], AsyncSession],
+        server_factory: ServerFactory,
     ) -> None:
         """Initialize the indexing worker service."""
         self.app_context = app_context
         self.session_factory = session_factory
+        self.server_factory = server_factory
         self._worker_task: asyncio.Task | None = None
         self._shutdown_event = asyncio.Event()
         self.task_repository = create_task_repository(session_factory)
@@ -45,7 +44,7 @@ class IndexingWorkerService:
         self._running = True
 
         # Start single worker task
-        self._worker_task = asyncio.create_task(self._worker_loop(operation))
+        self._worker_task = asyncio.create_task(self._worker_loop())
 
         self.log.info(
             "Indexing worker started",
@@ -63,18 +62,20 @@ class IndexingWorkerService:
 
         self.log.info("Indexing worker stopped")
 
-    async def _worker_loop(self, operation: ProgressTracker) -> None:
+    async def _worker_loop(self) -> None:
         self.log.debug("Worker loop started")
 
         while not self._shutdown_event.is_set():
             try:
                 async with self.session_factory() as session:
-                    task = await self.task_repository.take()
+                    task = await self.task_repository.next()
                     await session.commit()
 
                 # If there's a task, process it in a new thread
                 if task:
-                    await self._process_task(task, operation)
+                    await self._process_task(task)
+                    # Only remove the task if it was processed successfully
+                    await self.task_repository.remove(task)
                     continue
 
                 # If no task, sleep for a bit
@@ -90,8 +91,8 @@ class IndexingWorkerService:
 
         self.log.info("Worker loop stopped")
 
-    async def _process_task(self, task: Task, operation: ProgressTracker) -> None:
-        """Process a single task."""
+    async def _process_task(self, task: Task) -> None:
+        """Process a task based on its type."""
         self.log.info(
             "Processing task",
             task_id=task.id,
@@ -105,16 +106,8 @@ class IndexingWorkerService:
         asyncio.set_event_loop(loop)
 
         try:
-            # Process based on task type (currently only INDEX_UPDATE is supported)
-            if task.type is TaskType.INDEX_UPDATE:
-                await self._process_index_update(task, operation)
-            else:
-                self.log.warning(
-                    "Unknown task type",
-                    task_id=task.id,
-                    task_type=task.type,
-                )
-                return
+            commit_service = self.server_factory.commit_indexing_application_service()
+            await commit_service.run_task(task)
         finally:
             loop.close()
 
@@ -124,27 +117,3 @@ class IndexingWorkerService:
             task_id=task.id,
             duration_seconds=duration,
         )
-
-    async def _process_index_update(
-        self, task: Task, operation: ProgressTracker
-    ) -> None:
-        """Process index update/sync task."""
-        index_id = task.payload.get("index_id")
-        if not index_id:
-            raise ValueError("Missing index_id in task payload")
-
-        # Create a fresh database connection for this thread's event loop
-        db = await self.app_context.new_db(run_migrations=True)
-        try:
-            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/queue_service.py

@@ -1,12 +1,13 @@
 """Queue service for managing tasks."""
 
 from collections.abc import Callable
+from typing import Any
 
 import structlog
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.domain.entities import Task
-from kodit.domain.value_objects import TaskType
+from kodit.domain.value_objects import QueuePriority, TaskOperation
 from kodit.infrastructure.sqlalchemy.task_repository import (
     create_task_repository,
 )
@@ -46,9 +47,29 @@ class QueueService:
                 payload=task.payload,
             )
 
-    async def list_tasks(self, task_type: TaskType | None = None) -> list[Task]:
+    async def enqueue_tasks(
+        self,
+        tasks: list[TaskOperation],
+        base_priority: QueuePriority,
+        payload: dict[str, Any],
+    ) -> None:
+        """Queue repository tasks."""
+        priority_offset = len(tasks) * 10
+        for task in tasks:
+            await self.enqueue_task(
+                Task.create(
+                    task,
+                    base_priority + priority_offset,
+                    payload,
+                )
+            )
+            priority_offset -= 10
+
+    async def list_tasks(
+        self, task_operation: TaskOperation | None = None
+    ) -> list[Task]:
         """List all tasks in the queue."""
-        return await self.task_repository.list(task_type)
+        return await self.task_repository.list(task_operation)
 
     async def get_task(self, task_id: str) -> Task | None:
         """Get a specific task by ID."""

kodit/application/services/reporting.py

@@ -82,7 +82,6 @@ class ProgressTracker:
     async def skip(self, reason: str) -> None:
         """Skip the step."""
         self.task_status.skip(reason)
-        await self.notify_subscribers()
 
     def subscribe(self, subscriber: "ReportingModule") -> None:
         """Subscribe to the step."""
@@ -91,7 +90,6 @@ class ProgressTracker:
     async def set_total(self, total: int) -> None:
         """Set the total for the step."""
         self.task_status.set_total(total)
-        await self.notify_subscribers()
 
     async def set_current(self, current: int, message: str | None = None) -> None:
         """Progress the step."""

kodit/application/services/sync_scheduler.py

@@ -1,18 +1,16 @@
 """Service for scheduling periodic sync operations."""
 
 import asyncio
-from collections.abc import Callable
 from contextlib import suppress
 
 import structlog
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.application.services.queue_service import QueueService
-from kodit.domain.entities import Task
-from kodit.domain.services.index_query_service import IndexQueryService
-from kodit.domain.value_objects import QueuePriority
-from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
-from kodit.infrastructure.sqlalchemy.index_repository import create_index_repository
+from kodit.domain.protocols import GitRepoRepository
+from kodit.domain.value_objects import (
+    PrescribedOperations,
+    QueuePriority,
+)
 
 
 class SyncSchedulerService:
@@ -20,10 +18,12 @@ class SyncSchedulerService:
 
     def __init__(
         self,
-        session_factory: Callable[[], AsyncSession],
+        queue_service: QueueService,
+        repo_repository: GitRepoRepository,
     ) -> None:
         """Initialize the sync scheduler service."""
-        self.session_factory = session_factory
+        self.queue_service = queue_service
+        self.repo_repository = repo_repository
         self.log = structlog.get_logger(__name__)
         self._sync_task: asyncio.Task | None = None
         self._shutdown_event = asyncio.Event()
@@ -67,28 +67,12 @@ class SyncSchedulerService:
         """Perform a sync operation on all indexes."""
         self.log.info("Starting sync operation")
 
-        # Create services
-        queue_service = QueueService(session_factory=self.session_factory)
-        index_query_service = IndexQueryService(
-            index_repository=create_index_repository(
-                session_factory=self.session_factory
-            ),
-            fusion_service=ReciprocalRankFusionService(),
-        )
-
-        # Get all existing indexes
-        all_indexes = await index_query_service.list_indexes()
-
-        if not all_indexes:
-            self.log.info("No indexes found to sync")
-            return
-
-        self.log.info("Adding sync tasks to queue", count=len(all_indexes))
-
-        # Sync each index
-        for index in all_indexes:
-            await queue_service.enqueue_task(
-                Task.create_index_update_task(index.id, QueuePriority.BACKGROUND)
+        # Sync each index - queue all 5 tasks with priority ordering
+        for repo in await self.repo_repository.get_all():
+            await self.queue_service.enqueue_tasks(
+                tasks=PrescribedOperations.SYNC_REPOSITORY,
+                base_priority=QueuePriority.BACKGROUND,
+                payload={"repository_id": repo.id},
             )
 
         self.log.info("Sync operation completed")