graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/application/use_cases/index_batch_use_case.py

@@ -0,0 +1,153 @@
+"""
+IndexBatchUseCase Implementation (Task 8.3)
+
+Orchestrates batch indexing of multiple repositories.
+Validates repositories and delegates to IndexingOrchestrator.
+"""
+from pathlib import Path
+from typing import Callable
+import structlog
+
+from src.config.settings import Settings
+from src.application.dtos.index_batch_request import IndexBatchRequest
+from src.application.dtos.index_batch_response import IndexBatchResponse
+from src.application.dtos.repository_index_result import RepositoryIndexResult
+from src.application.use_cases.indexing_orchestrator import IndexingOrchestrator
+from src.application.services.progress_tracker import ProgressUpdate
+
+
+logger = structlog.get_logger(__name__)
+
+
+class IndexBatchUseCase:
+    """
+    Use Case for batch indexing multiple repositories.
+
+    Responsibilities:
+    - Validate repository list (non-empty, paths exist)
+    - Resolve full paths from REPOSITORIES_PATH base
+    - Delegate parallel processing to IndexingOrchestrator
+    - Aggregate success/failure results
+
+    Requirements: 2.1, 2.2, 2.3, 2.4, 2.5, 2.9, 2.10, 2.11
+    """
+
+    def __init__(self, orchestrator: IndexingOrchestrator, settings: Settings):
+        """
+        Initialize use case.
+
+        Args:
+            orchestrator: IndexingOrchestrator for parallel processing
+            settings: Settings with REPOSITORIES_PATH configured
+        """
+        self.orchestrator = orchestrator
+        self.settings = settings
+
+    async def execute(
+        self,
+        request: IndexBatchRequest,
+        progress_callback: Callable[[str, ProgressUpdate], None] | None = None
+    ) -> IndexBatchResponse:
+        """
+        Process multiple repositories in parallel.
+
+        Args:
+            request: Request with repository names and parallel limit
+            progress_callback: Optional callback (repo_name, progress_update)
+
+        Returns:
+            IndexBatchResponse with success/failure counts and details
+
+        Raises:
+            ValueError: If repository list empty or no valid repos found
+        """
+        # Precondition: repositories not empty
+        if not request.repositories:
+            raise ValueError("Lista de repositórios não pode estar vazia")
+
+        # Resolve base path
+        base_path = Path(self.settings.repository.repositories_path)
+
+        logger.info(
+            "batch_indexing_requested",
+            base_path=str(base_path),
+            repositories=request.repositories,
+            parallel=request.parallel
+        )
+
+        # Validate base path exists
+        if not base_path.exists():
+            error_msg = f"Repositories base path does not exist: {base_path}"
+            logger.error("base_path_not_found", path=str(base_path))
+            raise ValueError(error_msg)
+
+        # Resolve full paths and validate existence
+        valid_paths: list[Path] = []
+
+        for repo_name in request.repositories:
+            repo_path = base_path / repo_name
+
+            if not repo_path.exists():
+                logger.warning(
+                    "repository_not_found",
+                    repository=repo_name,
+                    expected_path=str(repo_path)
+                )
+                continue
+
+            valid_paths.append(repo_path)
+            logger.debug(
+                "repository_validated",
+                repository=repo_name,
+                path=str(repo_path)
+            )
+
+        # If no valid repositories, error
+        if not valid_paths:
+            error_msg = (
+                f"Nenhum repositório válido encontrado em {base_path}. "
+                f"Requisitados: {request.repositories}"
+            )
+            logger.error("no_valid_repositories", requested=request.repositories)
+            raise ValueError(error_msg)
+
+        logger.info(
+            "batch_processing_starting",
+            valid_repositories=len(valid_paths),
+            parallel=request.parallel
+        )
+
+        # Delegate to orchestrator
+        batch_result = await self.orchestrator.process_batch(
+            repositories=valid_paths,
+            parallel=request.parallel,
+            progress_callback=progress_callback
+        )
+
+        # Convert BatchProcessingResult to IndexBatchResponse
+        response = IndexBatchResponse(
+            total_processed=batch_result.total_processed,
+            success_count=batch_result.success_count,
+            failed_count=batch_result.failed_count,
+            results=[
+                RepositoryIndexResult(
+                    repository=result.repository_name,
+                    status=result.status,
+                    files_processed=result.files_processed if result.status == "success" else None,
+                    chunks_created=result.chunks_created if result.status == "success" else None,
+                    nodes_created=result.nodes_created if result.status == "success" else None,
+                    relationships_created=result.relationships_created if result.status == "success" else None,
+                    error_message=result.error_message
+                )
+                for result in batch_result.results
+            ]
+        )
+
+        logger.info(
+            "batch_processing_completed",
+            total=response.total_processed,
+            success=response.success_count,
+            failed=response.failed_count
+        )
+
+        return response