kodit 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

kodit/domain/services/indexing_service.py

@@ -1,204 +0,0 @@
-"""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,
-    SnippetWithContext,
-)
-
-
-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[SnippetWithContext]:
-        """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[SnippetWithContext]:
-        """Get snippets by IDs.
-
-        Args:
-            ids: List of snippet IDs to retrieve.
-
-        Returns:
-            List of SnippetWithFile objects containing file and snippet information.
-
-        """
-        return await self.index_repository.list_snippets_by_ids(ids)

kodit/domain/services/snippet_extraction_service.py

@@ -1,89 +0,0 @@
-"""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)

kodit/domain/services/snippet_service.py

@@ -1,215 +0,0 @@
-"""Domain service for snippet operations."""
-
-from pathlib import Path
-from typing import Any
-
-import structlog
-
-from kodit.domain.entities import Snippet
-from kodit.domain.enums import SnippetExtractionStrategy
-from kodit.domain.interfaces import ProgressCallback
-from kodit.domain.repositories import FileRepository, SnippetRepository
-from kodit.domain.services.snippet_extraction_service import (
-    SnippetExtractionDomainService,
-)
-from kodit.domain.value_objects import (
-    MultiSearchRequest,
-    MultiSearchResult,
-    SnippetExtractionRequest,
-    SnippetWithContext,
-)
-from kodit.reporting import Reporter
-
-
-class SnippetDomainService:
-    """Domain service for snippet-related operations.
-
-    This service consolidates snippet operations that were previously
-    spread between application services. It handles:
-    - Snippet extraction from files
-    - Snippet persistence
-    - Snippet querying and filtering
-    """
-
-    def __init__(
-        self,
-        snippet_extraction_service: SnippetExtractionDomainService,
-        snippet_repository: SnippetRepository,
-        file_repository: FileRepository,
-    ) -> None:
-        """Initialize the snippet domain service.
-
-        Args:
-            snippet_extraction_service: Service for extracting snippets from files
-            snippet_repository: Repository for snippet persistence
-            file_repository: Repository for file operations
-
-        """
-        self.snippet_extraction_service = snippet_extraction_service
-        self.snippet_repository = snippet_repository
-        self.file_repository = file_repository
-        self.log = structlog.get_logger(__name__)
-
-    async def extract_and_create_snippets(
-        self,
-        index_id: int,
-        strategy: SnippetExtractionStrategy,
-        progress_callback: ProgressCallback | None = None,
-    ) -> list[Snippet]:
-        """Extract snippets from all files in an index and persist them.
-
-        This method combines the extraction and persistence logic that was
-        previously split between domain and application services.
-
-        Args:
-            index_id: The ID of the index to create snippets for
-            strategy: The extraction strategy to use
-            progress_callback: Optional callback for progress reporting
-
-        Returns:
-            List of created Snippet entities with IDs assigned
-
-        """
-        files = await self.file_repository.get_files_for_index(index_id)
-        created_snippets = []
-
-        reporter = Reporter(self.log, progress_callback)
-        await reporter.start(
-            "create_snippets", len(files), "Creating snippets from files..."
-        )
-
-        for i, file in enumerate(files, 1):
-            if not self._should_process_file(file):
-                continue
-
-            try:
-                # Extract snippets from file
-                request = SnippetExtractionRequest(Path(file.cloned_path), strategy)
-                result = await self.snippet_extraction_service.extract_snippets(request)
-
-                # Create and persist snippet entities
-                for snippet_content in result.snippets:
-                    snippet = Snippet(
-                        file_id=file.id,
-                        index_id=index_id,
-                        content=snippet_content,
-                        summary="",  # Initially empty, will be populated by enrichment
-                    )
-                    saved_snippet = await self.snippet_repository.save(snippet)
-                    created_snippets.append(saved_snippet)
-
-            except (OSError, ValueError) as e:
-                self.log.debug(
-                    "Skipping file",
-                    file=file.cloned_path,
-                    error=str(e),
-                )
-                continue
-
-            await reporter.step(
-                "create_snippets",
-                current=i,
-                total=len(files),
-                message=f"Processing {file.cloned_path}...",
-            )
-
-        await reporter.done("create_snippets")
-        return created_snippets
-
-    async def get_snippets_for_index(self, index_id: int) -> list[Snippet]:
-        """Get all snippets for a specific index.
-
-        Args:
-            index_id: The ID of the index
-
-        Returns:
-            List of Snippet entities for the index
-
-        """
-        # This delegates to the repository but provides a domain-level interface
-        return list(await self.snippet_repository.get_by_index(index_id))
-
-    async def update_snippet_summary(self, snippet_id: int, summary: str) -> None:
-        """Update the summary of an existing snippet."""
-        # Get the snippet first to ensure it exists
-        snippet = await self.snippet_repository.get(snippet_id)
-        if not snippet:
-            msg = f"Snippet not found: {snippet_id}"
-            raise ValueError(msg)
-
-        # Update the summary
-        snippet.summary = summary
-        await self.snippet_repository.save(snippet)
-
-    async def delete_snippets_for_index(self, index_id: int) -> None:
-        """Delete all snippets for a specific index.
-
-        Args:
-            index_id: The ID of the index
-
-        """
-        await self.snippet_repository.delete_by_index(index_id)
-
-    async def search_snippets(
-        self, request: MultiSearchRequest
-    ) -> list[SnippetWithContext]:
-        """Search snippets with filters.
-
-        Args:
-            request: The search request containing filters
-
-        Returns:
-            List of matching snippet items with context
-
-        """
-        return list(await self.snippet_repository.search(request))
-
-    async def list_snippets(
-        self, file_path: str | None = None, source_uri: str | None = None
-    ) -> list[MultiSearchResult]:
-        """List snippets with optional filtering.
-
-        Args:
-            file_path: Optional file path to filter by
-            source_uri: Optional source URI to filter by
-
-        Returns:
-            List of search results matching the criteria
-
-        """
-        snippet_items = await self.snippet_repository.list_snippets(
-            file_path, source_uri
-        )
-        # Convert SnippetWithContext to MultiSearchResult for unified display format
-        return [
-            MultiSearchResult(
-                id=item.snippet.id,
-                content=item.snippet.content,
-                original_scores=[],  # No scores for list operation
-                source_uri=item.source.uri,
-                relative_path=MultiSearchResult.calculate_relative_path(
-                    item.file.cloned_path, item.source.cloned_path
-                ),
-                language=MultiSearchResult.detect_language_from_extension(
-                    item.file.extension
-                ),
-                authors=[author.name for author in item.authors],
-                created_at=item.snippet.created_at,
-                summary=item.snippet.summary,
-            )
-            for item in snippet_items
-        ]
-
-    def _should_process_file(self, file: Any) -> bool:
-        """Check if a file should be processed for snippet extraction.
-
-        Args:
-            file: The file to check
-
-        Returns:
-            True if the file should be processed
-
-        """
-        # Skip unsupported file types
-        mime_blacklist = ["unknown/unknown"]
-        return file.mime_type not in mime_blacklist

kodit/domain/services/source_service.py

@@ -1,85 +0,0 @@
-"""Source service rewritten to work directly with AsyncSession."""
-
-from collections.abc import Callable
-from pathlib import Path
-
-import structlog
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
-
-from kodit.domain.entities import Source
-from kodit.domain.interfaces import ProgressCallback
-from kodit.domain.repositories import SourceRepository
-from kodit.infrastructure.cloning.folder.factory import FolderSourceFactory
-from kodit.infrastructure.cloning.folder.working_copy import FolderWorkingCopyProvider
-from kodit.infrastructure.cloning.git.factory import (
-    GitSourceFactory,
-    GitWorkingCopyProvider,
-)
-from kodit.infrastructure.git.git_utils import is_valid_clone_target
-from kodit.infrastructure.sqlalchemy.repository import SqlAlchemySourceRepository
-
-
-class SourceService:
-    """Source service."""
-
-    def __init__(
-        self,
-        clone_dir: Path,
-        session_factory: async_sessionmaker[AsyncSession] | Callable[[], AsyncSession],
-    ) -> None:
-        """Initialize the source service."""
-        self.clone_dir = clone_dir
-        self._session_factory = session_factory
-        self.log = structlog.get_logger(__name__)
-
-    async def get(self, source_id: int) -> Source:
-        """Get a source."""
-        async with self._session_factory() as session:
-            repo = SqlAlchemySourceRepository(session)
-
-            source = await repo.get(source_id)
-            if source is None:
-                raise ValueError(f"Source not found: {source_id}")
-
-            return source
-
-    async def create(
-        self, uri_or_path_like: str, progress_callback: ProgressCallback | None = None
-    ) -> Source:
-        """Create a source."""
-        async with self._session_factory() as session:
-            repo = SqlAlchemySourceRepository(session)
-            git_factory, folder_factory = self._build_factories(repo, session)
-
-            if is_valid_clone_target(uri_or_path_like):
-                source = await git_factory.create(uri_or_path_like, progress_callback)
-            elif Path(uri_or_path_like).is_dir():
-                source = await folder_factory.create(
-                    uri_or_path_like, progress_callback
-                )
-            else:
-                raise ValueError(f"Unsupported source: {uri_or_path_like}")
-
-            # Factories handle their own commits now
-            return source
-
-    def _build_factories(
-        self, repository: SourceRepository, session: AsyncSession
-    ) -> tuple[GitSourceFactory, FolderSourceFactory]:
-        # Git-specific collaborators
-        git_wc = GitWorkingCopyProvider(self.clone_dir)
-        git_factory = GitSourceFactory(
-            repository=repository,
-            working_copy=git_wc,
-            session=session,
-        )
-
-        # Folder-specific collaborators
-        fold_wc = FolderWorkingCopyProvider(self.clone_dir)
-        folder_factory = FolderSourceFactory(
-            repository=repository,
-            working_copy=fold_wc,
-            session=session,
-        )
-
-        return git_factory, folder_factory

kodit/infrastructure/cloning/folder/__init__.py

@@ -1 +0,0 @@
-"""Folder cloning infrastructure."""