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

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