kodit 0.4.3__py3-none-any.whl → 0.5.1__py3-none-any.whl

kodit/infrastructure/cloning/metadata.py

@@ -1,98 +0,0 @@
-"""Metadata extraction for cloned sources."""
-
-import mimetypes
-from datetime import UTC, datetime
-from hashlib import sha256
-from pathlib import Path
-
-import aiofiles
-import git
-from pydantic import AnyUrl
-
-from kodit.domain.entities import Author, File
-from kodit.domain.value_objects import FileProcessingStatus, SourceType
-
-
-class FileMetadataExtractor:
-    """File metadata extractor."""
-
-    def __init__(self, source_type: SourceType) -> None:
-        """Initialize the extractor."""
-        self.source_type = source_type
-
-    async def extract(self, file_path: Path) -> File:
-        """Extract metadata from a file."""
-        if self.source_type == SourceType.GIT:
-            created_at, updated_at = await self._get_git_timestamps(file_path)
-        else:
-            created_at, updated_at = await self._get_file_system_timestamps(file_path)
-
-        # Read file content and calculate metadata
-        async with aiofiles.open(file_path, "rb") as f:
-            content = await f.read()
-            mime_type = mimetypes.guess_type(file_path)
-            sha = sha256(content).hexdigest()
-            if self.source_type == SourceType.GIT:
-                authors = await self._extract_git_authors(file_path)
-            else:
-                authors = []
-
-            return File(
-                created_at=created_at,
-                updated_at=updated_at,
-                uri=AnyUrl(file_path.resolve().absolute().as_uri()),
-                mime_type=mime_type[0]
-                if mime_type and mime_type[0]
-                else "application/octet-stream",
-                sha256=sha,
-                authors=authors,
-                file_processing_status=FileProcessingStatus.ADDED,
-            )
-
-    async def _get_git_timestamps(self, file_path: Path) -> tuple[datetime, datetime]:
-        """Get timestamps from Git history."""
-        git_repo = git.Repo(file_path.parent, search_parent_directories=True)
-        commits = list(git_repo.iter_commits(paths=str(file_path), all=True))
-
-        if commits:
-            last_modified_at = commits[0].committed_datetime
-            first_modified_at = commits[-1].committed_datetime
-            return first_modified_at, last_modified_at
-        # Fallback to current time if no commits found
-        now = datetime.now(UTC)
-        return now, now
-
-    async def _get_file_system_timestamps(
-        self,
-        file_path: Path,
-    ) -> tuple[datetime, datetime]:
-        """Get timestamps from file system."""
-        stat = file_path.stat()
-        file_created_at = datetime.fromtimestamp(stat.st_ctime, UTC)
-        file_modified_at = datetime.fromtimestamp(stat.st_mtime, UTC)
-        return file_created_at, file_modified_at
-
-    async def _extract_git_authors(self, file_path: Path) -> list[Author]:
-        """Extract authors from a Git file."""
-        git_repo = git.Repo(file_path.parent, search_parent_directories=True)
-
-        try:
-            # Get the file's blame
-            blames = git_repo.blame("HEAD", str(file_path))
-
-            # Extract the blame's authors
-            actors = [
-                commit.author
-                for blame in blames or []
-                for commit in blame
-                if isinstance(commit, git.Commit)
-            ]
-
-            # Get or create the authors in the database
-            return [
-                Author(name=actor.name or "", email=actor.email or "")
-                for actor in actors
-            ]
-        except git.GitCommandError:
-            # Handle cases where file might not be tracked
-            return []

kodit/infrastructure/enrichment/__init__.py

@@ -1 +0,0 @@
-"""Infrastructure enrichment module."""

kodit/infrastructure/enrichment/enrichment_factory.py

@@ -1,52 +0,0 @@
-"""Enrichment factory for creating enrichment domain services."""
-
-from kodit.config import AppContext, Endpoint
-from kodit.domain.services.enrichment_service import (
-    EnrichmentDomainService,
-    EnrichmentProvider,
-)
-from kodit.infrastructure.enrichment.litellm_enrichment_provider import (
-    LiteLLMEnrichmentProvider,
-)
-from kodit.infrastructure.enrichment.local_enrichment_provider import (
-    LocalEnrichmentProvider,
-)
-from kodit.log import log_event
-
-
-def _get_endpoint_configuration(app_context: AppContext) -> Endpoint | None:
-    """Get the endpoint configuration for the enrichment service.
-
-    Args:
-        app_context: The application context.
-
-    Returns:
-        The endpoint configuration or None.
-
-    """
-    return app_context.enrichment_endpoint or None
-
-
-def enrichment_domain_service_factory(
-    app_context: AppContext,
-) -> EnrichmentDomainService:
-    """Create an enrichment domain service.
-
-    Args:
-        app_context: The application context.
-
-    Returns:
-        An enrichment domain service instance.
-
-    """
-    endpoint = _get_endpoint_configuration(app_context)
-
-    enrichment_provider: EnrichmentProvider | None = None
-    if endpoint:
-        log_event("kodit.enrichment", {"provider": "litellm"})
-        enrichment_provider = LiteLLMEnrichmentProvider(endpoint=endpoint)
-    else:
-        log_event("kodit.enrichment", {"provider": "local"})
-        enrichment_provider = LocalEnrichmentProvider()
-
-    return EnrichmentDomainService(enrichment_provider=enrichment_provider)

kodit/infrastructure/enrichment/null_enrichment_provider.py

@@ -1,19 +0,0 @@
-"""Null enrichment provider for testing."""
-
-import re
-from collections.abc import AsyncGenerator
-
-from kodit.domain.services.enrichment_service import EnrichmentProvider
-from kodit.domain.value_objects import EnrichmentRequest, EnrichmentResponse
-
-
-class NullEnrichmentProvider(EnrichmentProvider):
-    """Null enrichment provider that returns empty responses."""
-
-    async def enrich(
-        self, requests: list[EnrichmentRequest]
-    ) -> AsyncGenerator[EnrichmentResponse, None]:
-        """Only keep alphabetic characters."""
-        for request in requests:
-            response = re.sub(r"[^a-zA-Z]", " ", request.text)
-            yield EnrichmentResponse(snippet_id=request.snippet_id, text=response)

kodit/infrastructure/mappers/index_mapper.py

@@ -1,345 +0,0 @@
-"""Mapping between domain Index aggregate and SQLAlchemy entities."""
-
-from datetime import UTC, datetime
-from pathlib import Path
-
-from pydantic import AnyUrl
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-import kodit.domain.entities as domain_entities
-from kodit.domain.value_objects import (
-    FileProcessingStatus,
-    SourceType,
-)
-from kodit.infrastructure.sqlalchemy import entities as db_entities
-
-
-# TODO(Phil): Make this a pure mapper without any DB access # noqa: TD003, FIX002
-class IndexMapper:
-    """Mapper for converting between domain Index aggregate and database entities."""
-
-    def __init__(self, session: AsyncSession) -> None:
-        """Initialize mapper with database session."""
-        self._session = session
-
-    async def to_domain_index(
-        self, db_index: db_entities.Index
-    ) -> domain_entities.Index:
-        """Convert SQLAlchemy Index to domain Index aggregate.
-
-        Loads the full aggregate including Source, WorkingCopy, Files, and Snippets.
-        """
-        # Load the source
-        db_source = await self._session.get(db_entities.Source, db_index.source_id)
-        if not db_source:
-            raise ValueError(f"Source not found for index {db_index.id}")
-
-        # Load files for the source
-        files_stmt = select(db_entities.File).where(
-            db_entities.File.source_id == db_source.id
-        )
-        db_files = (await self._session.scalars(files_stmt)).all()
-
-        # Convert files to domain
-        domain_files = []
-        for db_file in db_files:
-            # Load authors for this file
-            authors_stmt = (
-                select(db_entities.Author)
-                .join(db_entities.AuthorFileMapping)
-                .where(db_entities.AuthorFileMapping.file_id == db_file.id)
-            )
-            db_authors = (await self._session.scalars(authors_stmt)).all()
-
-            domain_authors = [
-                domain_entities.Author(
-                    id=author.id, name=author.name, email=author.email
-                )
-                for author in db_authors
-            ]
-
-            domain_file = domain_entities.File(
-                id=db_file.id,
-                created_at=db_file.created_at,
-                updated_at=db_file.updated_at,
-                uri=AnyUrl(db_file.uri),
-                sha256=db_file.sha256,
-                authors=domain_authors,
-                mime_type=db_file.mime_type,
-                file_processing_status=FileProcessingStatus(
-                    db_file.file_processing_status
-                ),
-            )
-            domain_files.append(domain_file)
-
-        # Create working copy
-        working_copy = domain_entities.WorkingCopy(
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            remote_uri=AnyUrl(db_source.uri),
-            cloned_path=Path(db_source.cloned_path),
-            source_type=SourceType(db_source.type.value),
-            files=domain_files,
-        )
-
-        # Create source
-        domain_source = domain_entities.Source(
-            id=db_source.id,
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            working_copy=working_copy,
-        )
-
-        # Load snippets for this index
-        snippets_stmt = select(db_entities.Snippet).where(
-            db_entities.Snippet.index_id == db_index.id
-        )
-        db_snippets = (await self._session.scalars(snippets_stmt)).all()
-
-        domain_snippets = []
-        for db_snippet in db_snippets:
-            domain_snippet = await self.to_domain_snippet(db_snippet, domain_files)
-            domain_snippets.append(domain_snippet)
-
-        # Create index aggregate
-        return domain_entities.Index(
-            id=db_index.id,
-            created_at=db_index.created_at,
-            updated_at=db_index.updated_at,
-            source=domain_source,
-            snippets=domain_snippets,
-        )
-
-    async def to_domain_source(
-        self, db_source: db_entities.Source
-    ) -> domain_entities.Source:
-        """Convert SQLAlchemy Source to domain Source."""
-        # Load files for the source
-        files_stmt = select(db_entities.File).where(
-            db_entities.File.source_id == db_source.id
-        )
-        db_files = (await self._session.scalars(files_stmt)).all()
-
-        # Convert files to domain
-        domain_files = []
-        for db_file in db_files:
-            # Load authors for this file
-            authors_stmt = (
-                select(db_entities.Author)
-                .join(db_entities.AuthorFileMapping)
-                .where(db_entities.AuthorFileMapping.file_id == db_file.id)
-            )
-            db_authors = (await self._session.scalars(authors_stmt)).all()
-
-            domain_authors = [
-                domain_entities.Author(
-                    id=author.id, name=author.name, email=author.email
-                )
-                for author in db_authors
-            ]
-
-            domain_file = domain_entities.File(
-                id=db_file.id,
-                created_at=db_file.created_at,
-                updated_at=db_file.updated_at,
-                uri=AnyUrl(db_file.uri),
-                sha256=db_file.sha256,
-                authors=domain_authors,
-                mime_type=db_file.mime_type,
-                file_processing_status=FileProcessingStatus(
-                    db_file.file_processing_status
-                ),
-            )
-            domain_files.append(domain_file)
-
-        # Create working copy
-        working_copy = domain_entities.WorkingCopy(
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            remote_uri=AnyUrl(db_source.uri),
-            cloned_path=Path(db_source.cloned_path),
-            source_type=SourceType(db_source.type.value),
-            files=domain_files,
-        )
-
-        # Create source
-        return domain_entities.Source(
-            id=db_source.id,
-            created_at=db_source.created_at,
-            updated_at=db_source.updated_at,
-            working_copy=working_copy,
-        )
-
-    async def to_domain_file(self, db_file: db_entities.File) -> domain_entities.File:
-        """Convert SQLAlchemy File to domain File."""
-        # Load authors for this file
-        authors_stmt = (
-            select(db_entities.Author)
-            .join(db_entities.AuthorFileMapping)
-            .where(db_entities.AuthorFileMapping.file_id == db_file.id)
-        )
-        db_authors = (await self._session.scalars(authors_stmt)).all()
-
-        domain_authors = [
-            domain_entities.Author(id=author.id, name=author.name, email=author.email)
-            for author in db_authors
-        ]
-
-        return domain_entities.File(
-            id=db_file.id,
-            created_at=db_file.created_at,
-            updated_at=db_file.updated_at,
-            uri=AnyUrl(db_file.uri),
-            sha256=db_file.sha256,
-            authors=domain_authors,
-            mime_type=db_file.mime_type,
-            file_processing_status=FileProcessingStatus(db_file.file_processing_status),
-        )
-
-    async def to_domain_snippet(
-        self, db_snippet: db_entities.Snippet, domain_files: list[domain_entities.File]
-    ) -> domain_entities.Snippet:
-        """Convert SQLAlchemy Snippet to domain Snippet."""
-        # Find the file this snippet derives from
-        derives_from = []
-        for domain_file in domain_files:
-            if domain_file.id == db_snippet.file_id:
-                derives_from.append(domain_file)
-                break
-
-        # Create domain snippet with original content
-        domain_snippet = domain_entities.Snippet(
-            id=db_snippet.id,
-            created_at=db_snippet.created_at,
-            updated_at=db_snippet.updated_at,
-            derives_from=derives_from,
-        )
-
-        # Add original content
-        if db_snippet.content:
-            domain_snippet.add_original_content(db_snippet.content, "unknown")
-
-        # Add summary content if it exists
-        if db_snippet.summary:
-            domain_snippet.add_summary(db_snippet.summary)
-
-        return domain_snippet
-
-    async def from_domain_index(  # noqa: C901
-        self, domain_index: domain_entities.Index
-    ) -> tuple[
-        db_entities.Index,
-        db_entities.Source,
-        list[db_entities.File],
-        list[db_entities.Author],
-    ]:
-        """Convert domain Index aggregate to SQLAlchemy entities.
-
-        Returns all the entities that need to be persisted.
-        """
-        # Create source entity
-        db_source = db_entities.Source(
-            uri=str(domain_index.source.working_copy.remote_uri),
-            cloned_path=str(domain_index.source.working_copy.cloned_path),
-            source_type=db_entities.SourceType(
-                domain_index.source.working_copy.source_type.value
-            ),
-        )
-        if domain_index.source.id:
-            db_source.id = domain_index.source.id
-        if domain_index.source.created_at:
-            db_source.created_at = domain_index.source.created_at
-        if domain_index.source.updated_at:
-            db_source.updated_at = domain_index.source.updated_at
-
-        # Create index entity
-        # Will be set after source is saved
-        db_index = db_entities.Index(source_id=db_source.id or 0)
-        if domain_index.id:
-            db_index.id = domain_index.id
-        if domain_index.created_at:
-            db_index.created_at = domain_index.created_at
-        if domain_index.updated_at:
-            db_index.updated_at = domain_index.updated_at
-
-        # Create file entities
-        db_files = []
-        all_authors = []
-
-        for domain_file in domain_index.source.working_copy.files:
-            now = datetime.now(UTC)
-            db_file = db_entities.File(
-                created_at=domain_file.created_at or now,
-                updated_at=domain_file.updated_at or now,
-                source_id=db_source.id or 0,  # Will be set after source is saved
-                mime_type="",  # Would need to be determined
-                uri=str(domain_file.uri),
-                # Would need to be determined from working copy + relative path
-                cloned_path="",
-                sha256=domain_file.sha256,
-                size_bytes=0,  # Would need to be determined
-                extension="",  # Would need to be determined
-                file_processing_status=domain_file.file_processing_status.value,
-            )
-            if domain_file.id:
-                db_file.id = domain_file.id
-
-            db_files.append(db_file)
-            all_authors.extend(domain_file.authors)
-
-        # Create unique author entities
-        unique_authors = {}
-        for author in all_authors:
-            key = (author.name, author.email)
-            if key not in unique_authors:
-                db_author = db_entities.Author(name=author.name, email=author.email)
-                if author.id:
-                    db_author.id = author.id
-                unique_authors[key] = db_author
-
-        return db_index, db_source, db_files, list(unique_authors.values())
-
-    async def from_domain_snippet(
-        self, domain_snippet: domain_entities.Snippet, index_id: int
-    ) -> db_entities.Snippet:
-        """Convert domain Snippet to SQLAlchemy Snippet."""
-        # Get file ID from derives_from (use first file if multiple)
-        if not domain_snippet.derives_from:
-            raise ValueError("Snippet must derive from at least one file")
-
-        file_id = domain_snippet.derives_from[0].id
-        if file_id is None:
-            raise ValueError("File must have an ID")
-
-        db_snippet = db_entities.Snippet(
-            file_id=file_id,
-            index_id=index_id,
-            content=domain_snippet.original_text(),
-            summary=domain_snippet.summary_text(),
-        )
-
-        if domain_snippet.id:
-            db_snippet.id = domain_snippet.id
-        if domain_snippet.created_at:
-            db_snippet.created_at = domain_snippet.created_at
-        if domain_snippet.updated_at:
-            db_snippet.updated_at = domain_snippet.updated_at
-
-        return db_snippet
-
-    async def load_snippets_for_index(
-        self, index_id: int, domain_files: list[domain_entities.File]
-    ) -> list[domain_entities.Snippet]:
-        """Load all snippets for an index and convert to domain entities."""
-        stmt = select(db_entities.Snippet).where(
-            db_entities.Snippet.index_id == index_id
-        )
-        db_snippets = (await self._session.scalars(stmt)).all()
-
-        domain_snippets = []
-        for db_snippet in db_snippets:
-            domain_snippet = await self.to_domain_snippet(db_snippet, domain_files)
-            domain_snippets.append(domain_snippet)
-
-        return domain_snippets

kodit/infrastructure/reporting/tdqm_progress.py

@@ -1,38 +0,0 @@
-"""TQDM progress."""
-
-from tqdm import tqdm
-
-from kodit.config import ReportingConfig
-from kodit.domain.entities import TaskStatus
-from kodit.domain.protocols import ReportingModule
-from kodit.domain.value_objects import ReportingState
-
-
-class TQDMReportingModule(ReportingModule):
-    """TQDM reporting module."""
-
-    def __init__(self, config: ReportingConfig) -> None:
-        """Initialize the TQDM reporting module."""
-        self.config = config
-        self.pbar = tqdm()
-
-    async def on_change(self, progress: TaskStatus) -> None:
-        """On step changed."""
-        step = progress
-        if step.state == ReportingState.COMPLETED:
-            self.pbar.close()
-            return
-
-        self.pbar.set_description(step.operation)
-        self.pbar.refresh()
-        # Update description if message is provided
-        if step.error:
-            # Fix the event message to a specific size so it's not jumping around
-            # If it's too small, add spaces
-            # If it's too large, truncate
-            if len(step.error) < 30:
-                self.pbar.set_description(step.error + " " * (30 - len(step.error)))
-            else:
-                self.pbar.set_description(step.error[-30:])
-        else:
-            self.pbar.set_description(step.operation)

kodit/infrastructure/slicing/language_detection_service.py

@@ -1,18 +0,0 @@
-"""Language detection service implementation."""
-
-from pathlib import Path
-
-from kodit.domain.services.index_service import LanguageDetectionService
-
-
-class FileSystemLanguageDetectionService(LanguageDetectionService):
-    """Simple file extension based language detection service."""
-
-    def __init__(self, language_map: dict[str, str]) -> None:
-        """Initialize with a mapping of extensions to languages."""
-        self._language_map = language_map
-
-    async def detect_language(self, file_path: Path) -> str:
-        """Detect language based on file extension."""
-        extension = file_path.suffix.lstrip(".")
-        return self._language_map.get(extension, "unknown")