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

kodit/infrastructure/mappers/index_mapper.py

@@ -0,0 +1,344 @@
+"""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
+
+
+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/snippet_extraction/factories.py

@@ -0,0 +1,13 @@
+"""Factories for creating snippet query providers."""
+
+from pathlib import Path
+
+from kodit.infrastructure.snippet_extraction.snippet_query_provider import (
+    FileSystemSnippetQueryProvider,
+    SnippetQueryProvider,
+)
+
+
+def create_snippet_query_provider() -> SnippetQueryProvider:
+    """Create a snippet query provider."""
+    return FileSystemSnippetQueryProvider(Path(__file__).parent / "languages")

kodit/infrastructure/snippet_extraction/language_detection_service.py

@@ -2,7 +2,7 @@
 
 from pathlib import Path
 
-from kodit.domain.services.snippet_extraction_service import LanguageDetectionService
+from kodit.domain.services.index_service import LanguageDetectionService
 
 
 class FileSystemLanguageDetectionService(LanguageDetectionService):

kodit/infrastructure/snippet_extraction/snippet_query_provider.py

@@ -38,7 +38,6 @@ class FileSystemSnippetQueryProvider(SnippetQueryProvider):
 
         """
         query_path = self.query_directory / f"{language}.scm"
-
         if not query_path.exists():
             raise FileNotFoundError(f"Query file not found: {query_path}")
 

kodit/infrastructure/snippet_extraction/tree_sitter_snippet_extractor.py

@@ -6,7 +6,7 @@ from typing import cast
 from tree_sitter import Node, Query
 from tree_sitter_language_pack import SupportedLanguage, get_language, get_parser
 
-from kodit.domain.services.snippet_extraction_service import SnippetExtractor
+from kodit.domain.services.index_service import SnippetExtractor
 from kodit.infrastructure.snippet_extraction.snippet_query_provider import (
     SnippetQueryProvider,
 )

kodit/infrastructure/sqlalchemy/embedding_repository.py

@@ -4,7 +4,7 @@ import numpy as np
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.domain.entities import Embedding, EmbeddingType
+from kodit.infrastructure.sqlalchemy.entities import Embedding, EmbeddingType
 
 
 class SqlAlchemyEmbeddingRepository:

kodit/infrastructure/sqlalchemy/entities.py

@@ -0,0 +1,203 @@
+"""SQLAlchemy entities."""
+
+from datetime import UTC, datetime
+from enum import Enum
+
+from git import Actor
+from sqlalchemy import (
+    DateTime,
+    ForeignKey,
+    Integer,
+    String,
+    UnicodeText,
+    UniqueConstraint,
+)
+from sqlalchemy import Enum as SQLAlchemyEnum
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from sqlalchemy.types import JSON
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+    """Base class for all models."""
+
+
+class CommonMixin:
+    """Common mixin for all models."""
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), default=lambda: datetime.now(UTC)
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(UTC),
+        onupdate=lambda: datetime.now(UTC),
+    )
+
+
+class SourceType(Enum):
+    """The type of source."""
+
+    UNKNOWN = 0
+    FOLDER = 1
+    GIT = 2
+
+
+class Source(Base, CommonMixin):
+    """Base model for tracking code sources.
+
+    This model serves as the parent table for different types of sources.
+    It provides common fields and relationships for all source types.
+
+    Attributes:
+        id: The unique identifier for the source.
+        created_at: Timestamp when the source was created.
+        updated_at: Timestamp when the source was last updated.
+        cloned_uri: A URI to a copy of the source on the local filesystem.
+        uri: The URI of the source.
+
+    """
+
+    __tablename__ = "sources"
+    uri: Mapped[str] = mapped_column(String(1024), index=True, unique=True)
+    cloned_path: Mapped[str] = mapped_column(String(1024), index=True)
+    type: Mapped[SourceType] = mapped_column(
+        SQLAlchemyEnum(SourceType), default=SourceType.UNKNOWN, index=True
+    )
+
+    def __init__(self, uri: str, cloned_path: str, source_type: SourceType) -> None:
+        """Initialize a new Source instance for typing purposes."""
+        super().__init__()
+        self.uri = uri
+        self.cloned_path = cloned_path
+        self.type = source_type
+
+
+class Author(Base, CommonMixin):
+    """Author model."""
+
+    __tablename__ = "authors"
+
+    __table_args__ = (UniqueConstraint("name", "email", name="uix_author"),)
+
+    name: Mapped[str] = mapped_column(String(255), index=True)
+    email: Mapped[str] = mapped_column(String(255), index=True)
+
+    @staticmethod
+    def from_actor(actor: Actor) -> "Author":
+        """Create an Author from an Actor."""
+        return Author(name=actor.name, email=actor.email)
+
+
+class AuthorFileMapping(Base, CommonMixin):
+    """Author file mapping model."""
+
+    __tablename__ = "author_file_mappings"
+
+    __table_args__ = (
+        UniqueConstraint("author_id", "file_id", name="uix_author_file_mapping"),
+    )
+
+    author_id: Mapped[int] = mapped_column(ForeignKey("authors.id"), index=True)
+    file_id: Mapped[int] = mapped_column(ForeignKey("files.id"), index=True)
+
+
+class File(Base, CommonMixin):
+    """File model."""
+
+    __tablename__ = "files"
+
+    source_id: Mapped[int] = mapped_column(ForeignKey("sources.id"))
+    mime_type: Mapped[str] = mapped_column(String(255), default="", index=True)
+    uri: Mapped[str] = mapped_column(String(1024), default="", index=True)
+    cloned_path: Mapped[str] = mapped_column(String(1024), index=True)
+    sha256: Mapped[str] = mapped_column(String(64), default="", index=True)
+    size_bytes: Mapped[int] = mapped_column(Integer, default=0)
+    extension: Mapped[str] = mapped_column(String(255), default="", index=True)
+    file_processing_status: Mapped[int] = mapped_column(Integer, default=0)
+
+    def __init__(  # noqa: PLR0913
+        self,
+        created_at: datetime,
+        updated_at: datetime,
+        source_id: int,
+        mime_type: str,
+        uri: str,
+        cloned_path: str,
+        sha256: str,
+        size_bytes: int,
+        extension: str,
+        file_processing_status: int,
+    ) -> None:
+        """Initialize a new File instance for typing purposes."""
+        super().__init__()
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self.source_id = source_id
+        self.mime_type = mime_type
+        self.uri = uri
+        self.cloned_path = cloned_path
+        self.sha256 = sha256
+        self.size_bytes = size_bytes
+        self.extension = extension
+        self.file_processing_status = file_processing_status
+
+
+class EmbeddingType(Enum):
+    """Embedding type."""
+
+    CODE = 1
+    TEXT = 2
+
+
+class Embedding(Base, CommonMixin):
+    """Embedding model."""
+
+    __tablename__ = "embeddings"
+
+    snippet_id: Mapped[int] = mapped_column(ForeignKey("snippets.id"), index=True)
+    type: Mapped[EmbeddingType] = mapped_column(
+        SQLAlchemyEnum(EmbeddingType), index=True
+    )
+    embedding: Mapped[list[float]] = mapped_column(JSON)
+
+
+class Index(Base, CommonMixin):
+    """Index model."""
+
+    __tablename__ = "indexes"
+
+    source_id: Mapped[int] = mapped_column(
+        ForeignKey("sources.id"), unique=True, index=True
+    )
+
+    def __init__(self, source_id: int) -> None:
+        """Initialize the index."""
+        super().__init__()
+        self.source_id = source_id
+
+
+class Snippet(Base, CommonMixin):
+    """Snippet model."""
+
+    __tablename__ = "snippets"
+
+    file_id: Mapped[int] = mapped_column(ForeignKey("files.id"), index=True)
+    index_id: Mapped[int] = mapped_column(ForeignKey("indexes.id"), index=True)
+    content: Mapped[str] = mapped_column(UnicodeText, default="")
+    summary: Mapped[str] = mapped_column(UnicodeText, default="")
+
+    def __init__(
+        self,
+        file_id: int,
+        index_id: int,
+        content: str,
+        summary: str = "",
+    ) -> None:
+        """Initialize the snippet."""
+        super().__init__()
+        self.file_id = file_id
+        self.index_id = index_id
+        self.content = content
+        self.summary = summary

kodit/infrastructure/sqlalchemy/file_repository.py

@@ -5,8 +5,8 @@ from collections.abc import Sequence
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.domain.entities import File, Index
 from kodit.domain.repositories import FileRepository
+from kodit.infrastructure.sqlalchemy.entities import File, Index
 
 
 class SqlAlchemyFileRepository(FileRepository):