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

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

kodit/infrastructure/cloning/git/factory.py

@@ -1,153 +0,0 @@
-"""Factory for creating git-based working copies."""
-
-import tempfile
-from pathlib import Path
-
-import git
-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.services.ignore_service import IgnoreService
-from kodit.domain.value_objects import ProgressEvent
-from kodit.infrastructure.cloning.git.working_copy import GitWorkingCopyProvider
-from kodit.infrastructure.cloning.metadata import (
-    GitAuthorExtractor,
-    GitFileMetadataExtractor,
-)
-from kodit.infrastructure.git.git_utils import sanitize_git_url
-from kodit.infrastructure.ignore.ignore_pattern_provider import GitIgnorePatternProvider
-
-
-class GitSourceFactory:
-    """Factory for creating git-based working copies."""
-
-    def __init__(
-        self,
-        repository: SourceRepository,
-        working_copy: GitWorkingCopyProvider,
-        session: AsyncSession,
-    ) -> None:
-        """Initialize the source factory."""
-        self.log = structlog.get_logger(__name__)
-        self.repository = repository
-        self.working_copy = working_copy
-        self.metadata_extractor = GitFileMetadataExtractor()
-        self.author_extractor = GitAuthorExtractor(repository)
-        self.session = session
-
-    async def create(
-        self, uri: str, progress_callback: ProgressCallback | None = None
-    ) -> Source:
-        """Create a git source from a URI."""
-        # Use null callback if none provided
-        if progress_callback is None:
-            progress_callback = NullProgressCallback()
-
-        # Normalize the URI
-        # Never log the raw URI in production
-        self.log.debug("Normalising git uri", uri="[REDACTED]" + uri[-4:])
-        with tempfile.TemporaryDirectory() as temp_dir:
-            git.Repo.clone_from(uri, temp_dir)
-            remote = git.Repo(temp_dir).remote()
-            uri = remote.url
-
-        # Sanitize the URI to remove any credentials
-        sanitized_uri = sanitize_git_url(uri)
-        self.log.debug("Sanitized git uri", sanitized_uri=sanitized_uri)
-
-        # Check if source already exists
-        self.log.debug("Checking if source already exists", uri=sanitized_uri)
-        source = await self.repository.get_by_uri(sanitized_uri)
-
-        if source:
-            self.log.info("Source already exists, reusing...", source_id=source.id)
-            return source
-
-        # Prepare working copy (use original URI for cloning, sanitized for storage)
-        clone_path = await self.working_copy.prepare(uri)
-
-        # Create source record
-        self.log.debug("Creating source", uri=sanitized_uri, clone_path=str(clone_path))
-        source = await self.repository.save(
-            Source(
-                uri=sanitized_uri,
-                cloned_path=str(clone_path),
-                source_type=SourceType.GIT,
-            )
-        )
-
-        # Commit source creation so we get an ID for foreign key relationships
-        await self.session.commit()
-
-        # Get files to process using ignore patterns
-        ignore_provider = GitIgnorePatternProvider(clone_path)
-        ignore_service = IgnoreService(ignore_provider)
-        files = [
-            f
-            for f in clone_path.rglob("*")
-            if f.is_file() and not ignore_service.should_ignore(f)
-        ]
-
-        # Process files
-        self.log.info("Inspecting files", source_id=source.id, num_files=len(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)
-
-            # Commit authors so they get IDs before creating mappings
-            if authors:
-                await self.session.commit()
-
-            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/indexing/index_repository.py

@@ -1,286 +0,0 @@
-"""Infrastructure implementation of the index repository."""
-
-from datetime import UTC, datetime
-from typing import TypeVar
-
-from sqlalchemy import delete, func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.entities import (
-    Author,
-    AuthorFileMapping,
-    Embedding,
-    File,
-    Index,
-    Snippet,
-    Source,
-)
-from kodit.domain.services.indexing_service import IndexRepository
-from kodit.domain.value_objects import (
-    IndexView,
-    SnippetWithContext,
-)
-
-T = TypeVar("T")
-
-
-class SQLAlchemyIndexRepository(IndexRepository):
-    """SQLAlchemy implementation of the index repository."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize the index repository.
-
-        Args:
-            session: The SQLAlchemy async session to use for database operations.
-
-        """
-        self.session = session
-
-    async def create_index(self, source_id: int) -> IndexView:
-        """Create a new index for a source.
-
-        Args:
-            source_id: The ID of the source to create an index for.
-
-        Returns:
-            The created index view.
-
-        """
-        # Check if index already exists
-        existing_index = await self.get_index_by_source_id(source_id)
-        if existing_index:
-            return existing_index
-
-        index = Index(source_id=source_id)
-        self.session.add(index)
-
-        # Get source for the view
-        source_query = select(Source).where(Source.id == source_id)
-        source_result = await self.session.execute(source_query)
-        source = source_result.scalar_one()
-
-        return IndexView(
-            id=index.id,
-            created_at=index.created_at,
-            updated_at=index.updated_at,
-            source=source.uri,
-            num_snippets=0,
-        )
-
-    async def _get_index_view(self, index: Index, source: Source) -> IndexView:
-        """Create an IndexView from Index and Source entities.
-
-        Args:
-            index: The index entity
-            source: The source entity
-
-        Returns:
-            The index view
-
-        """
-        num_snippets = await self.num_snippets_for_index(index.id)
-        return IndexView(
-            id=index.id,
-            created_at=index.created_at,
-            updated_at=index.updated_at,
-            source=source.uri,
-            num_snippets=num_snippets,
-        )
-
-    async def get_index_by_id(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.
-
-        """
-        query = (
-            select(Index, Source)
-            .join(Source, Index.source_id == Source.id)
-            .where(Index.id == index_id)
-        )
-        result = await self.session.execute(query)
-        row = result.first()
-
-        if not row:
-            return None
-
-        index, source = row
-        return await self._get_index_view(index, source)
-
-    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.
-
-        """
-        query = (
-            select(Index, Source)
-            .join(Source, Index.source_id == Source.id)
-            .where(Index.source_id == source_id)
-        )
-        result = await self.session.execute(query)
-        row = result.first()
-
-        if not row:
-            return None
-
-        index, source = row
-        return await self._get_index_view(index, source)
-
-    async def list_indexes(self) -> list[IndexView]:
-        """List all indexes.
-
-        Returns:
-            A list of index views.
-
-        """
-        query = select(Index, Source).join(
-            Source, Index.source_id == Source.id, full=True
-        )
-        result = await self.session.execute(query)
-        rows = result.tuples()
-
-        indexes = []
-        for index, source in rows:
-            index_view = await self._get_index_view(index, source)
-            indexes.append(index_view)
-
-        return 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.
-
-        """
-        query = select(Index).where(Index.id == index_id)
-        result = await self.session.execute(query)
-        index = result.scalar_one_or_none()
-
-        if index:
-            index.updated_at = datetime.now(UTC)
-
-    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.
-
-        """
-        # First get all snippets for this index
-        snippets = await self.get_snippets_for_index(index_id)
-
-        # Delete all embeddings for these snippets, if there are any
-        for snippet in snippets:
-            query = delete(Embedding).where(Embedding.snippet_id == snippet.id)
-            await self.session.execute(query)
-
-        # Now delete the snippets
-        query = delete(Snippet).where(Snippet.index_id == index_id)
-        await self.session.execute(query)
-
-    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.
-
-        """
-        query = select(Snippet).where(Snippet.index_id == index_id)
-        result = await self.session.execute(query)
-        return list(result.scalars())
-
-    async def add_snippet(self, snippet: dict) -> None:
-        """Add a snippet to the database.
-
-        Args:
-            snippet: The snippet to add.
-
-        """
-        db_snippet = Snippet(
-            file_id=snippet["file_id"],
-            index_id=snippet["index_id"],
-            content=snippet["content"],
-            summary=snippet.get("summary", ""),
-        )
-        self.session.add(db_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.
-
-        """
-        query = select(Snippet).where(Snippet.id == snippet_id)
-        result = await self.session.execute(query)
-        snippet = result.scalar_one_or_none()
-
-        if snippet:
-            snippet.content = content
-            # SQLAlchemy will automatically track this change
-
-    async def list_snippets_by_ids(self, ids: list[int]) -> list[SnippetWithContext]:
-        """List snippets by IDs."""
-        query = (
-            select(Snippet, File, Source, Author)
-            .where(Snippet.id.in_(ids))
-            .join(File, Snippet.file_id == File.id)
-            .join(Source, File.source_id == Source.id)
-            .outerjoin(AuthorFileMapping, AuthorFileMapping.file_id == File.id)
-            .outerjoin(Author, AuthorFileMapping.author_id == Author.id)
-        )
-        rows = await self.session.execute(query)
-
-        # Group results by snippet ID and collect authors
-        id_to_result: dict[int, SnippetWithContext] = {}
-        for snippet, file, source, author in rows.all():
-            if snippet.id not in id_to_result:
-                id_to_result[snippet.id] = SnippetWithContext(
-                    snippet=snippet,
-                    file=file,
-                    source=source,
-                    authors=[],
-                )
-            # Add author if it exists (outer join might return None)
-            if author is not None:
-                id_to_result[snippet.id].authors.append(author)
-
-        # Check that all IDs are present
-        if len(id_to_result) != len(ids):
-            # Create a list of missing IDs
-            missing_ids = [
-                snippet_id for snippet_id in ids if snippet_id not in id_to_result
-            ]
-            msg = f"Some IDs are not present: {missing_ids}"
-            raise ValueError(msg)
-
-        # Rebuild the list in the same order that it was passed in
-        return [id_to_result[i] for i in ids]
-
-    async def num_snippets_for_index(self, index_id: int) -> int:
-        """Get the number of snippets for an index.
-
-        Args:
-            index_id: The ID of the index.
-
-        Returns:
-            The number of snippets.
-
-        """
-        query = select(func.count()).where(Snippet.index_id == index_id)
-        result = await self.session.execute(query)
-        return result.scalar_one()

kodit/infrastructure/indexing/snippet_domain_service_factory.py

@@ -1,37 +0,0 @@
-"""Factory for creating snippet domain service."""
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.domain.services.snippet_service import SnippetDomainService
-from kodit.infrastructure.snippet_extraction.snippet_extraction_factory import (
-    create_snippet_extraction_domain_service,
-)
-from kodit.infrastructure.sqlalchemy.file_repository import SqlAlchemyFileRepository
-from kodit.infrastructure.sqlalchemy.snippet_repository import (
-    SqlAlchemySnippetRepository,
-)
-
-
-def snippet_domain_service_factory(session: AsyncSession) -> SnippetDomainService:
-    """Create a snippet domain service with all dependencies.
-
-    Args:
-        session: The database session
-
-    Returns:
-        Configured snippet domain service
-
-    """
-    # Create domain service for snippet extraction
-    snippet_extraction_service = create_snippet_extraction_domain_service()
-
-    # Create repositories
-    snippet_repository = SqlAlchemySnippetRepository(session)
-    file_repository = SqlAlchemyFileRepository(session)
-
-    # Create and return the domain service
-    return SnippetDomainService(
-        snippet_extraction_service=snippet_extraction_service,
-        snippet_repository=snippet_repository,
-        file_repository=file_repository,
-    )

kodit/infrastructure/snippet_extraction/__init__.py

@@ -1 +0,0 @@
-"""Infrastructure services for snippet extraction."""

kodit/infrastructure/snippet_extraction/language_detection_service.py

@@ -1,39 +0,0 @@
-"""Infrastructure implementation for language detection."""
-
-from pathlib import Path
-
-from kodit.domain.services.snippet_extraction_service import LanguageDetectionService
-
-
-class FileSystemLanguageDetectionService(LanguageDetectionService):
-    """Infrastructure implementation for language detection."""
-
-    def __init__(self, language_map: dict[str, str]) -> None:
-        """Initialize the language detection service.
-
-        Args:
-            language_map: Mapping of file extensions to programming languages
-
-        """
-        self.language_map = language_map
-
-    async def detect_language(self, file_path: Path) -> str:
-        """Detect language based on file extension.
-
-        Args:
-            file_path: Path to the file to detect language for
-
-        Returns:
-            The detected programming language
-
-        Raises:
-            ValueError: If the language is not supported
-
-        """
-        suffix = file_path.suffix.removeprefix(".").lower()
-        language = self.language_map.get(suffix)
-
-        if language is None:
-            raise ValueError(f"Unsupported language for file suffix: {suffix}")
-
-        return language

kodit/infrastructure/snippet_extraction/languages/csharp.scm

@@ -1,12 +0,0 @@
-(method_declaration
-  name: (identifier) @function.name
-  body: (block) @function.body
-) @function.def
-
-(class_declaration
-  name: (identifier) @class.name
-) @class.def
-
-(using_directive) @import.name
-
-(identifier) @ident