kodit 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

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,211 +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,
-    SnippetListItem,
-)
-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,
-                    )
-                    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_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
-
-        """
-        # 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 content
-        snippet.content = content
-        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[SnippetListItem]:
-        """Search snippets with filters.
-
-        Args:
-            request: The search request containing filters
-
-        Returns:
-            List of matching snippet items
-
-        """
-        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 SnippetListItem to MultiSearchResult for unified display format
-        return [
-            MultiSearchResult(
-                id=item.id,
-                uri=item.source_uri,
-                content=item.content,
-                original_scores=[],
-            )
-            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."""

kodit/infrastructure/cloning/folder/factory.py

@@ -1,128 +0,0 @@
-"""Factory for creating folder-based working copies."""
-
-from pathlib import Path
-
-import structlog
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.entities import AuthorFileMapping, Source, SourceType
-from kodit.domain.interfaces import NullProgressCallback, ProgressCallback
-from kodit.domain.repositories import SourceRepository
-from kodit.domain.value_objects import ProgressEvent
-from kodit.infrastructure.cloning.folder.working_copy import FolderWorkingCopyProvider
-from kodit.infrastructure.cloning.metadata import (
-    FolderFileMetadataExtractor,
-    NoOpAuthorExtractor,
-)
-
-
-class FolderSourceFactory:
-    """Factory for creating folder sources."""
-
-    def __init__(
-        self,
-        repository: SourceRepository,
-        working_copy: FolderWorkingCopyProvider,
-        session: AsyncSession,
-    ) -> None:
-        """Initialize the source factory."""
-        self.log = structlog.get_logger(__name__)
-        self.repository = repository
-        self.working_copy = working_copy
-        self.metadata_extractor = FolderFileMetadataExtractor()
-        self.author_extractor = NoOpAuthorExtractor()
-        self.session = session
-
-    async def create(
-        self, uri: str, progress_callback: ProgressCallback | None = None
-    ) -> Source:
-        """Create a folder source from a path."""
-        # Use null callback if none provided
-        if progress_callback is None:
-            progress_callback = NullProgressCallback()
-
-        directory = Path(uri).expanduser().resolve()
-
-        # Check if source already exists
-        source = await self.repository.get_by_uri(directory.as_uri())
-        if source:
-            self.log.info("Source already exists, reusing...", source_id=source.id)
-            return source
-
-        # Validate directory exists
-        if not directory.exists():
-            msg = f"Folder does not exist: {directory}"
-            raise ValueError(msg)
-
-        # Prepare working copy
-        clone_path = await self.working_copy.prepare(directory.as_uri())
-
-        # Create source record
-        source = await self.repository.save(
-            Source(
-                uri=directory.as_uri(),
-                cloned_path=str(clone_path),
-                source_type=SourceType.FOLDER,
-            )
-        )
-
-        # Commit source creation so we get an ID for foreign key relationships
-        await self.session.commit()
-
-        # Get all files to process
-        files = [f for f in clone_path.rglob("*") if f.is_file()]
-
-        # Process files
-        await self._process_files(source, files, progress_callback)
-
-        # Commit file processing
-        await self.session.commit()
-
-        return source
-
-    async def _process_files(
-        self, source: Source, files: list[Path], progress_callback: ProgressCallback
-    ) -> None:
-        """Process files for a source."""
-        total_files = len(files)
-
-        # Notify start of operation
-        await progress_callback.on_progress(
-            ProgressEvent(
-                operation="process_files",
-                current=0,
-                total=total_files,
-                message="Processing files...",
-            )
-        )
-
-        for i, path in enumerate(files, 1):
-            if not path.is_file():
-                continue
-
-            # Extract file metadata
-            file_record = await self.metadata_extractor.extract(path, source)
-            await self.repository.create_file(file_record)
-
-            # Extract authors
-            authors = await self.author_extractor.extract(path, source)
-            for author in authors:
-                await self.repository.upsert_author_file_mapping(
-                    AuthorFileMapping(
-                        author_id=author.id,
-                        file_id=file_record.id,
-                    )
-                )
-
-            # Update progress
-            await progress_callback.on_progress(
-                ProgressEvent(
-                    operation="process_files",
-                    current=i,
-                    total=total_files,
-                    message=f"Processing {path.name}...",
-                )
-            )
-
-        # Notify completion
-        await progress_callback.on_complete("process_files")

kodit/infrastructure/cloning/folder/working_copy.py

@@ -1,38 +0,0 @@
-"""Working copy provider for folder-based sources."""
-
-import shutil
-from pathlib import Path
-
-
-class FolderWorkingCopyProvider:
-    """Working copy provider for folder-based sources."""
-
-    def __init__(self, clone_dir: Path) -> None:
-        """Initialize the provider."""
-        self.clone_dir = clone_dir
-
-    async def prepare(self, uri: str) -> Path:
-        """Prepare a folder working copy."""
-        # Handle file:// URIs
-        if uri.startswith("file://"):
-            from urllib.parse import urlparse
-
-            parsed = urlparse(uri)
-            directory = Path(parsed.path).expanduser().resolve()
-        else:
-            directory = Path(uri).expanduser().resolve()
-
-        # Clone into a local directory
-        clone_path = self.clone_dir / directory.as_posix().replace("/", "_")
-        clone_path.mkdir(parents=True, exist_ok=True)
-
-        # Copy all files recursively, preserving directory structure, ignoring
-        # hidden files
-        shutil.copytree(
-            directory,
-            clone_path,
-            ignore=shutil.ignore_patterns(".*"),
-            dirs_exist_ok=True,
-        )
-
-        return clone_path