kodit 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

kodit/domain/services/bm25_service.py

@@ -0,0 +1,124 @@
+"""Domain services for BM25 operations."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+
+from kodit.domain.value_objects import (
+    BM25DeleteRequest,
+    BM25IndexRequest,
+    BM25SearchRequest,
+    BM25SearchResult,
+)
+
+
+class BM25Repository(ABC):
+    """Abstract interface for BM25 repository."""
+
+    @abstractmethod
+    async def index_documents(self, request: BM25IndexRequest) -> None:
+        """Index documents for BM25 search."""
+
+    @abstractmethod
+    async def search(self, request: BM25SearchRequest) -> Sequence[BM25SearchResult]:
+        """Search documents using BM25."""
+
+    @abstractmethod
+    async def delete_documents(self, request: BM25DeleteRequest) -> None:
+        """Delete documents from the BM25 index."""
+
+
+class BM25DomainService:
+    """Domain service for BM25 operations."""
+
+    def __init__(self, repository: BM25Repository) -> None:
+        """Initialize the BM25 domain service.
+
+        Args:
+            repository: The BM25 repository for persistence operations
+
+        """
+        self.repository = repository
+
+    async def index_documents(self, request: BM25IndexRequest) -> None:
+        """Index documents using domain business rules.
+
+        Args:
+            request: The indexing request containing documents to index
+
+        Raises:
+            ValueError: If the request is invalid
+
+        """
+        # Domain logic: validate request
+        if not request.documents:
+            raise ValueError("Cannot index empty document list")
+
+        # Domain logic: filter out invalid documents
+        valid_documents = [
+            doc
+            for doc in request.documents
+            if doc.snippet_id is not None and doc.text and doc.text.strip()
+        ]
+
+        if not valid_documents:
+            raise ValueError("No valid documents to index")
+
+        # Domain logic: create new request with validated documents
+        validated_request = BM25IndexRequest(documents=valid_documents)
+        await self.repository.index_documents(validated_request)
+
+    async def search(self, request: BM25SearchRequest) -> Sequence[BM25SearchResult]:
+        """Search documents using domain business rules.
+
+        Args:
+            request: The search request
+
+        Returns:
+            Sequence of search results
+
+        Raises:
+            ValueError: If the request is invalid
+
+        """
+        # Domain logic: validate request
+        if not request.query or not request.query.strip():
+            raise ValueError("Search query cannot be empty")
+
+        if request.top_k <= 0:
+            raise ValueError("Top-k must be positive")
+
+        # Domain logic: normalize query
+        normalized_query = request.query.strip()
+        normalized_request = BM25SearchRequest(
+            query=normalized_query, top_k=request.top_k
+        )
+
+        return await self.repository.search(normalized_request)
+
+    async def delete_documents(self, request: BM25DeleteRequest) -> None:
+        """Delete documents using domain business rules.
+
+        Args:
+            request: The deletion request
+
+        Raises:
+            ValueError: If the request is invalid
+
+        """
+        # Domain logic: validate request
+        if not request.snippet_ids:
+            raise ValueError("Cannot delete empty snippet ID list")
+
+        # Domain logic: filter out invalid IDs
+        valid_ids = [
+            snippet_id
+            for snippet_id in request.snippet_ids
+            if snippet_id is not None and snippet_id > 0
+        ]
+
+        if not valid_ids:
+            raise ValueError("No valid snippet IDs to delete")
+
+        # Domain logic: create new request with validated IDs
+        validated_request = BM25DeleteRequest(snippet_ids=valid_ids)
+        await self.repository.delete_documents(validated_request)

kodit/domain/services/embedding_service.py

@@ -0,0 +1,155 @@
+"""Domain services for embedding operations."""
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator, Sequence
+
+from kodit.domain.entities import EmbeddingType
+from kodit.domain.value_objects import (
+    EmbeddingRequest,
+    EmbeddingResponse,
+    IndexResult,
+    VectorIndexRequest,
+    VectorSearchQueryRequest,
+    VectorSearchResult,
+)
+
+
+class EmbeddingProvider(ABC):
+    """Abstract interface for embedding provider."""
+
+    @abstractmethod
+    def embed(
+        self, data: list[EmbeddingRequest]
+    ) -> AsyncGenerator[list[EmbeddingResponse], None]:
+        """Embed a list of strings."""
+
+
+class VectorSearchRepository(ABC):
+    """Abstract interface for vector search repository."""
+
+    @abstractmethod
+    def index_documents(
+        self, request: VectorIndexRequest
+    ) -> AsyncGenerator[list[IndexResult], None]:
+        """Index documents for vector search."""
+
+    @abstractmethod
+    async def search(
+        self, request: VectorSearchQueryRequest
+    ) -> Sequence[VectorSearchResult]:
+        """Search documents using vector similarity."""
+
+    @abstractmethod
+    async def has_embedding(
+        self, snippet_id: int, embedding_type: EmbeddingType
+    ) -> bool:
+        """Check if a snippet has an embedding."""
+
+
+class EmbeddingDomainService:
+    """Domain service for embedding operations."""
+
+    def __init__(
+        self,
+        embedding_provider: EmbeddingProvider,
+        vector_search_repository: VectorSearchRepository,
+    ) -> None:
+        """Initialize the embedding domain service.
+
+        Args:
+            embedding_provider: The embedding provider for generating embeddings
+            vector_search_repository: The vector search repository for persistence
+
+        """
+        self.embedding_provider = embedding_provider
+        self.vector_search_repository = vector_search_repository
+
+    async def index_documents(
+        self, request: VectorIndexRequest
+    ) -> AsyncGenerator[list[IndexResult], None]:
+        """Index documents using domain business rules.
+
+        Args:
+            request: The indexing request containing documents to index
+
+        Yields:
+            Lists of IndexResult for each batch processed
+
+        Raises:
+            ValueError: If the request is invalid
+
+        """
+        # Domain logic: validate request
+        if not request.documents:
+            return
+
+        # Domain logic: filter out invalid documents
+        valid_documents = [
+            doc
+            for doc in request.documents
+            if doc.snippet_id is not None and doc.text and doc.text.strip()
+        ]
+
+        if not valid_documents:
+            return
+
+        # Domain logic: create new request with validated documents
+        validated_request = VectorIndexRequest(documents=valid_documents)
+        async for result in self.vector_search_repository.index_documents(
+            validated_request
+        ):
+            yield result
+
+    async def search(
+        self, request: VectorSearchQueryRequest
+    ) -> Sequence[VectorSearchResult]:
+        """Search documents using domain business rules.
+
+        Args:
+            request: The search request
+
+        Returns:
+            Sequence of search results
+
+        Raises:
+            ValueError: If the request is invalid
+
+        """
+        # Domain logic: validate request
+        if not request.query or not request.query.strip():
+            raise ValueError("Search query cannot be empty")
+
+        if request.top_k <= 0:
+            raise ValueError("Top-k must be positive")
+
+        # Domain logic: normalize query
+        normalized_query = request.query.strip()
+        normalized_request = VectorSearchQueryRequest(
+            query=normalized_query, top_k=request.top_k
+        )
+
+        return await self.vector_search_repository.search(normalized_request)
+
+    async def has_embedding(
+        self, snippet_id: int, embedding_type: EmbeddingType
+    ) -> bool:
+        """Check if a snippet has an embedding using domain business rules.
+
+        Args:
+            snippet_id: The snippet ID to check
+            embedding_type: The type of embedding to check
+
+        Returns:
+            True if the snippet has an embedding, False otherwise
+
+        Raises:
+            ValueError: If the snippet_id is invalid
+
+        """
+        # Domain logic: validate snippet_id
+        if snippet_id is None or snippet_id <= 0:
+            raise ValueError("Snippet ID must be positive")
+
+        return await self.vector_search_repository.has_embedding(
+            snippet_id, embedding_type
+        )

kodit/domain/services/enrichment_service.py

@@ -0,0 +1,48 @@
+"""Domain service for enrichment operations."""
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+
+from kodit.domain.value_objects import (
+    EnrichmentIndexRequest,
+    EnrichmentRequest,
+    EnrichmentResponse,
+)
+
+
+class EnrichmentProvider(ABC):
+    """Abstract enrichment provider interface."""
+
+    @abstractmethod
+    def enrich(
+        self, requests: list[EnrichmentRequest]
+    ) -> AsyncGenerator[EnrichmentResponse, None]:
+        """Enrich a list of requests."""
+
+
+class EnrichmentDomainService:
+    """Domain service for enrichment operations."""
+
+    def __init__(self, enrichment_provider: EnrichmentProvider) -> None:
+        """Initialize the enrichment domain service.
+
+        Args:
+            enrichment_provider: The enrichment provider to use.
+
+        """
+        self.enrichment_provider = enrichment_provider
+
+    async def enrich_documents(
+        self, request: EnrichmentIndexRequest
+    ) -> AsyncGenerator[EnrichmentResponse, None]:
+        """Enrich documents using the enrichment provider.
+
+        Args:
+            request: The enrichment index request.
+
+        Yields:
+            Enrichment responses as they are processed.
+
+        """
+        async for response in self.enrichment_provider.enrich(request.requests):
+            yield response

kodit/domain/services/ignore_service.py

@@ -0,0 +1,45 @@
+"""Domain service for ignore patterns."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class IgnorePatternProvider(ABC):
+    """Abstract interface for ignore pattern providers."""
+
+    @abstractmethod
+    def should_ignore(self, path: Path) -> bool:
+        """Check if a path should be ignored.
+
+        Args:
+            path: The path to check.
+
+        Returns:
+            True if the path should be ignored, False otherwise.
+
+        """
+
+
+class IgnoreService:
+    """Domain service for managing ignore patterns."""
+
+    def __init__(self, ignore_pattern_provider: IgnorePatternProvider) -> None:
+        """Initialize the ignore service.
+
+        Args:
+            ignore_pattern_provider: The ignore pattern provider to use.
+
+        """
+        self.ignore_pattern_provider = ignore_pattern_provider
+
+    def should_ignore(self, path: Path) -> bool:
+        """Check if a path should be ignored.
+
+        Args:
+            path: The path to check.
+
+        Returns:
+            True if the path should be ignored, False otherwise.
+
+        """
+        return self.ignore_pattern_provider.should_ignore(path)

kodit/domain/services/indexing_service.py

@@ -0,0 +1,203 @@
+"""Domain service for indexing operations."""
+
+from abc import ABC, abstractmethod
+
+from kodit.domain.entities import Snippet
+from kodit.domain.value_objects import (
+    FusionRequest,
+    FusionResult,
+    IndexCreateRequest,
+    IndexView,
+)
+
+
+class IndexRepository(ABC):
+    """Abstract index repository interface."""
+
+    @abstractmethod
+    async def create_index(self, source_id: int) -> IndexView:
+        """Create a new index for a source."""
+
+    @abstractmethod
+    async def get_index_by_id(self, index_id: int) -> IndexView | None:
+        """Get an index by its ID."""
+
+    @abstractmethod
+    async def get_index_by_source_id(self, source_id: int) -> IndexView | None:
+        """Get an index by its source ID."""
+
+    @abstractmethod
+    async def list_indexes(self) -> list[IndexView]:
+        """List all indexes."""
+
+    @abstractmethod
+    async def update_index_timestamp(self, index_id: int) -> None:
+        """Update the timestamp of an index."""
+
+    @abstractmethod
+    async def delete_all_snippets(self, index_id: int) -> None:
+        """Delete all snippets for an index."""
+
+    @abstractmethod
+    async def get_snippets_for_index(self, index_id: int) -> list[Snippet]:
+        """Get all snippets for an index."""
+
+    @abstractmethod
+    async def add_snippet(self, snippet: dict) -> None:
+        """Add a snippet to the database."""
+
+    @abstractmethod
+    async def update_snippet_content(self, snippet_id: int, content: str) -> None:
+        """Update the content of an existing snippet."""
+
+    @abstractmethod
+    async def list_snippets_by_ids(self, ids: list[int]) -> list[tuple[dict, dict]]:
+        """List snippets by IDs."""
+
+
+class FusionService(ABC):
+    """Abstract fusion service interface."""
+
+    @abstractmethod
+    def reciprocal_rank_fusion(
+        self, rankings: list[list[FusionRequest]], k: float = 60
+    ) -> list[FusionResult]:
+        """Perform reciprocal rank fusion on search results."""
+
+
+class IndexingDomainService:
+    """Domain service for indexing operations."""
+
+    def __init__(
+        self, index_repository: IndexRepository, fusion_service: FusionService
+    ) -> None:
+        """Initialize the indexing domain service.
+
+        Args:
+            index_repository: Repository for index operations
+            fusion_service: Service for result fusion
+
+        """
+        self.index_repository = index_repository
+        self.fusion_service = fusion_service
+
+    async def create_index(self, request: IndexCreateRequest) -> IndexView:
+        """Create a new index.
+
+        Args:
+            request: The index create request.
+
+        Returns:
+            The created index view.
+
+        """
+        return await self.index_repository.create_index(request.source_id)
+
+    async def get_index(self, index_id: int) -> IndexView | None:
+        """Get an index by its ID.
+
+        Args:
+            index_id: The ID of the index to retrieve.
+
+        Returns:
+            The index view if found, None otherwise.
+
+        """
+        return await self.index_repository.get_index_by_id(index_id)
+
+    async def get_index_by_source_id(self, source_id: int) -> IndexView | None:
+        """Get an index by its source ID.
+
+        Args:
+            source_id: The ID of the source to retrieve an index for.
+
+        Returns:
+            The index view if found, None otherwise.
+
+        """
+        return await self.index_repository.get_index_by_source_id(source_id)
+
+    async def list_indexes(self) -> list[IndexView]:
+        """List all indexes.
+
+        Returns:
+            A list of index views.
+
+        """
+        return await self.index_repository.list_indexes()
+
+    async def update_index_timestamp(self, index_id: int) -> None:
+        """Update the timestamp of an index.
+
+        Args:
+            index_id: The ID of the index to update.
+
+        """
+        await self.index_repository.update_index_timestamp(index_id)
+
+    async def delete_all_snippets(self, index_id: int) -> None:
+        """Delete all snippets for an index.
+
+        Args:
+            index_id: The ID of the index to delete snippets for.
+
+        """
+        await self.index_repository.delete_all_snippets(index_id)
+
+    async def get_snippets_for_index(self, index_id: int) -> list[Snippet]:
+        """Get all snippets for an index.
+
+        Args:
+            index_id: The ID of the index to get snippets for.
+
+        Returns:
+            A list of Snippet entities.
+
+        """
+        return await self.index_repository.get_snippets_for_index(index_id)
+
+    async def add_snippet(self, snippet: dict) -> None:
+        """Add a snippet to the database.
+
+        Args:
+            snippet: The snippet to add.
+
+        """
+        await self.index_repository.add_snippet(snippet)
+
+    async def update_snippet_content(self, snippet_id: int, content: str) -> None:
+        """Update the content of an existing snippet.
+
+        Args:
+            snippet_id: The ID of the snippet to update.
+            content: The new content for the snippet.
+
+        """
+        await self.index_repository.update_snippet_content(snippet_id, content)
+
+    def perform_fusion(
+        self, rankings: list[list[FusionRequest]], k: float = 60
+    ) -> list[FusionResult]:
+        """Perform fusion on search results.
+
+        Args:
+            rankings: List of rankings to fuse.
+            k: Parameter for reciprocal rank fusion.
+
+        Returns:
+            Fused search results.
+
+        """
+        return self.fusion_service.reciprocal_rank_fusion(rankings, k)
+
+    async def get_snippets_by_ids(self, ids: list[int]) -> list[tuple[dict, dict]]:
+        """Get snippets by IDs.
+
+        Args:
+            ids: List of snippet IDs to retrieve.
+
+        Returns:
+            List of (file, snippet) tuples.
+
+        """
+        return await self.index_repository.list_snippets_by_ids(ids)

kodit/domain/services/snippet_extraction_service.py

@@ -0,0 +1,89 @@
+"""Domain services for snippet extraction."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
+from pathlib import Path
+
+from kodit.domain.enums import SnippetExtractionStrategy
+from kodit.domain.value_objects import SnippetExtractionRequest, SnippetExtractionResult
+
+
+class LanguageDetectionService(ABC):
+    """Abstract interface for language detection service."""
+
+    @abstractmethod
+    async def detect_language(self, file_path: Path) -> str:
+        """Detect the programming language of a file."""
+
+
+class SnippetExtractor(ABC):
+    """Abstract interface for snippet extraction."""
+
+    @abstractmethod
+    async def extract(self, file_path: Path, language: str) -> list[str]:
+        """Extract snippets from a file."""
+
+
+class SnippetExtractionService(ABC):
+    """Domain service for extracting snippets from source code."""
+
+    @abstractmethod
+    async def extract_snippets(
+        self, request: SnippetExtractionRequest
+    ) -> SnippetExtractionResult:
+        """Extract snippets from a file using the specified strategy."""
+
+
+class SnippetExtractionDomainService:
+    """Domain service implementation for snippet extraction business logic."""
+
+    def __init__(
+        self,
+        language_detector: LanguageDetectionService,
+        snippet_extractors: Mapping[SnippetExtractionStrategy, SnippetExtractor],
+    ) -> None:
+        """Initialize the snippet extraction domain service.
+
+        Args:
+            language_detector: Service for detecting programming languages
+            snippet_extractors: Dictionary mapping strategies to extractor
+                implementations
+
+        """
+        self.language_detector = language_detector
+        self.snippet_extractors = snippet_extractors
+
+    async def extract_snippets(
+        self, request: SnippetExtractionRequest
+    ) -> SnippetExtractionResult:
+        """Extract snippets from a file using the specified strategy.
+
+        Args:
+            request: The snippet extraction request
+
+        Returns:
+            SnippetExtractionResult containing the extracted snippets and
+            detected language
+
+        Raises:
+            ValueError: If the file doesn't exist or strategy is unsupported
+
+        """
+        # Domain logic: validate file exists
+        if not request.file_path.exists():
+            raise ValueError(f"File does not exist: {request.file_path}")
+
+        # Domain logic: detect language
+        language = await self.language_detector.detect_language(request.file_path)
+
+        # Domain logic: choose strategy and extractor
+        if request.strategy not in self.snippet_extractors:
+            raise ValueError(f"Unsupported extraction strategy: {request.strategy}")
+
+        extractor = self.snippet_extractors[request.strategy]
+        snippets = await extractor.extract(request.file_path, language)
+
+        # Domain logic: filter out empty snippets
+        filtered_snippets = [snippet for snippet in snippets if snippet.strip()]
+
+        return SnippetExtractionResult(snippets=filtered_snippets, language=language)