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

kodit/domain/entities/git.py

@@ -0,0 +1,190 @@
+"""Git domain entities."""
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from hashlib import sha256
+from pathlib import Path
+
+from pydantic import AnyUrl, BaseModel
+
+from kodit.domain.value_objects import Enrichment, IndexStatus
+from kodit.utils.path_utils import repo_id_from_uri
+
+
+class GitFile(BaseModel):
+    """File domain entity."""
+
+    created_at: datetime
+    blob_sha: str
+    path: str
+    mime_type: str
+    size: int
+    extension: str
+
+    @property
+    def id(self) -> str:
+        """Get the unique id for a tag."""
+        return self.blob_sha
+
+    @staticmethod
+    def extension_from_path(path: str) -> str:
+        """Get the extension from a path."""
+        if not path or "." not in path:
+            return "unknown"
+        return path.split(".")[-1]
+
+
+class GitCommit(BaseModel):
+    """Commit domain entity."""
+
+    created_at: datetime | None = None  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+    commit_sha: str
+    date: datetime
+    message: str
+    parent_commit_sha: str | None = None  # The first commit in the repo is None
+    files: list[GitFile]
+    author: str
+
+    @property
+    def id(self) -> str:
+        """Get the unique id for a tag."""
+        return self.commit_sha
+
+
+class GitTag(BaseModel):
+    """Git tag domain entity."""
+
+    created_at: datetime  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+    repo_id: int | None = None
+    name: str  # e.g., "v1.0.0", "release-2023"
+    target_commit: GitCommit  # The commit this tag points to
+
+    @property
+    def id(self) -> str:
+        """Get the unique id for a tag."""
+        return f"{self.repo_id}-{self.name}"
+
+    @property
+    def is_version_tag(self) -> bool:
+        """Check if this appears to be a version tag."""
+        import re
+
+        # Simple heuristic for version tags
+        version_pattern = r"^v?\d+\.\d+(\.\d+)?(-\w+)?$"
+        return bool(re.match(version_pattern, self.name))
+
+
+class GitBranch(BaseModel):
+    """Branch domain entity."""
+
+    repo_id: int | None = None  # primary key
+    name: str  # primary key
+    created_at: datetime | None = None  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+    head_commit: GitCommit
+
+
+@dataclass(frozen=True)
+class RepositoryScanResult:
+    """Immutable scan result containing all repository metadata."""
+
+    branches: list[GitBranch]
+    all_commits: list[GitCommit]
+    all_tags: list[GitTag]
+    scan_timestamp: datetime
+    total_files_across_commits: int
+
+
+class GitRepo(BaseModel):
+    """Repository domain entity."""
+
+    id: int | None = None  # Database-generated surrogate key
+    created_at: datetime | None = None  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+    sanitized_remote_uri: AnyUrl  # Business key for lookups
+    remote_uri: AnyUrl  # May include credentials
+
+    # The following may be empty when initially created
+    cloned_path: Path | None = None
+    tracking_branch: GitBranch | None = None
+    last_scanned_at: datetime | None = None
+    num_commits: int = 0  # Total number of commits in this repository
+    num_branches: int = 0  # Total number of branches in this repository
+    num_tags: int = 0  # Total number of tags in this repository
+
+    @staticmethod
+    def create_id(sanitized_remote_uri: AnyUrl) -> str:
+        """Create a unique business key for a repository (kept for compatibility)."""
+        return repo_id_from_uri(sanitized_remote_uri)
+
+    def update_with_scan_result(self, scan_result: RepositoryScanResult) -> None:
+        """Update the GitRepo with a scan result."""
+        # Determine tracking branch (prefer main, then master, then first available)
+        if not self.tracking_branch:
+            tracking_branch = None
+            for preferred_name in ["main", "master"]:
+                tracking_branch = next(
+                    (b for b in scan_result.branches if b.name == preferred_name), None
+                )
+                if tracking_branch:
+                    break
+
+            if not tracking_branch and scan_result.branches:
+                tracking_branch = scan_result.branches[0]
+
+            if not tracking_branch:
+                raise ValueError("No tracking branch found")
+
+            self.tracking_branch = tracking_branch
+
+        self.last_scanned_at = datetime.now(UTC)
+        self.num_commits = len(scan_result.all_commits)
+        self.num_branches = len(scan_result.branches)
+        self.num_tags = len(scan_result.all_tags)
+
+
+class CommitIndex(BaseModel):
+    """Aggregate root for indexed commit data."""
+
+    commit_sha: str
+    created_at: datetime | None = None  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+    snippets: list["SnippetV2"]
+    status: IndexStatus
+    indexed_at: datetime | None = None
+    error_message: str | None = None
+    files_processed: int = 0
+    processing_time_seconds: float = 0.0
+
+    def get_snippet_count(self) -> int:
+        """Get total number of snippets."""
+        return len(self.snippets)
+
+    @property
+    def id(self) -> str:
+        """Get the unique id for a tag."""
+        return self.commit_sha
+
+
+class SnippetV2(BaseModel):
+    """Snippet domain entity."""
+
+    sha: str  # Content addressed ID to prevent duplicates and unnecessary updates
+    created_at: datetime | None = None  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+    derives_from: list[GitFile]
+    content: str
+    enrichments: list[Enrichment] = []
+    extension: str
+
+    @property
+    def id(self) -> str:
+        """Get the unique id for a snippet."""
+        return self.sha
+
+    @staticmethod
+    def compute_sha(content: str) -> str:
+        """Compute the SHA for a snippet."""
+        return sha256(content.encode()).hexdigest()

kodit/domain/factories/__init__.py

@@ -0,0 +1 @@
+"""Domain factories package."""

kodit/domain/factories/git_repo_factory.py

@@ -0,0 +1,76 @@
+"""Factory for creating GitRepo domain entities."""
+
+from datetime import datetime
+from pathlib import Path
+
+from pydantic import AnyUrl
+
+from kodit.domain.entities import WorkingCopy
+from kodit.domain.entities.git import GitBranch, GitRepo
+
+
+class GitRepoFactory:
+    """Factory for creating GitRepo domain entities."""
+
+    @staticmethod
+    def create_from_remote_uri(remote_uri: AnyUrl) -> GitRepo:
+        """Create a new Git repository from a remote URI."""
+        return GitRepo(
+            remote_uri=remote_uri,
+            sanitized_remote_uri=WorkingCopy.sanitize_git_url(str(remote_uri)),
+        )
+
+    @staticmethod
+    def create_from_components(  # noqa: PLR0913
+        *,
+        repo_id: int | None = None,
+        created_at: datetime | None = None,
+        updated_at: datetime | None = None,
+        sanitized_remote_uri: AnyUrl,
+        remote_uri: AnyUrl,
+        cloned_path: Path | None = None,
+        tracking_branch: GitBranch | None = None,
+        last_scanned_at: datetime | None = None,
+        num_commits: int = 0,
+        num_branches: int = 0,
+        num_tags: int = 0,
+    ) -> GitRepo:
+        """Create a GitRepo from individual components."""
+        return GitRepo(
+            id=repo_id,
+            created_at=created_at,
+            updated_at=updated_at,
+            sanitized_remote_uri=sanitized_remote_uri,
+            remote_uri=remote_uri,
+            cloned_path=cloned_path,
+            tracking_branch=tracking_branch,
+            last_scanned_at=last_scanned_at,
+            num_commits=num_commits,
+            num_branches=num_branches,
+            num_tags=num_tags,
+        )
+
+    @staticmethod
+    def create_from_path_scan(  # noqa: PLR0913
+        *,
+        remote_uri: AnyUrl,
+        sanitized_remote_uri: AnyUrl,
+        repo_path: Path,
+        tracking_branch: GitBranch | None = None,
+        last_scanned_at: datetime | None = None,
+        num_commits: int = 0,
+        num_branches: int = 0,
+        num_tags: int = 0,
+    ) -> GitRepo:
+        """Create a GitRepo from a scanned local repository path."""
+        return GitRepo(
+            id=None,  # Let repository assign database ID
+            sanitized_remote_uri=sanitized_remote_uri,
+            remote_uri=remote_uri,
+            tracking_branch=tracking_branch,
+            cloned_path=repo_path,
+            last_scanned_at=last_scanned_at,
+            num_commits=num_commits,
+            num_branches=num_branches,
+            num_tags=num_tags,
+        )

kodit/domain/protocols.py

@@ -1,19 +1,28 @@
 """Repository protocol interfaces for the domain layer."""
 
-from collections.abc import Sequence
-from typing import Protocol
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Protocol
 
 from pydantic import AnyUrl
 
 from kodit.domain.entities import (
-    Index,
-    Snippet,
-    SnippetWithContext,
     Task,
     TaskStatus,
-    WorkingCopy,
 )
-from kodit.domain.value_objects import MultiSearchRequest, TaskType
+from kodit.domain.entities.git import (
+    GitBranch,
+    GitCommit,
+    GitRepo,
+    GitTag,
+    SnippetV2,
+)
+from kodit.domain.value_objects import (
+    FusionRequest,
+    FusionResult,
+    MultiSearchRequest,
+    TaskOperation,
+)
 
 
 class TaskRepository(Protocol):
@@ -30,96 +39,286 @@ class TaskRepository(Protocol):
         """Get a task by ID."""
         ...
 
-    async def take(self) -> Task | None:
+    async def next(self) -> Task | None:
         """Take a task for processing."""
         ...
 
+    async def remove(self, task: Task) -> None:
+        """Remove a task."""
+        ...
+
     async def update(self, task: Task) -> None:
         """Update a task."""
         ...
 
-    async def list(self, task_type: TaskType | None = None) -> list[Task]:
+    async def list(self, task_operation: TaskOperation | None = None) -> list[Task]:
         """List tasks with optional status filter."""
         ...
 
 
-class IndexRepository(Protocol):
-    """Repository interface for Index entities."""
+class ReportingModule(Protocol):
+    """Reporting module."""
 
-    async def create(self, uri: AnyUrl, working_copy: WorkingCopy) -> Index:
-        """Create an index for a source."""
+    async def on_change(self, progress: TaskStatus) -> None:
+        """On step changed."""
         ...
 
-    async def update(self, index: Index) -> None:
-        """Update an index."""
-        ...
 
-    async def get(self, index_id: int) -> Index | None:
-        """Get an index by ID."""
-        ...
+class TaskStatusRepository(Protocol):
+    """Repository interface for persisting progress state only."""
 
-    async def delete(self, index: Index) -> None:
-        """Delete an index."""
+    async def save(self, status: TaskStatus) -> None:
+        """Save a progress state."""
         ...
 
-    async def all(self) -> list[Index]:
-        """List all indexes."""
+    async def load_with_hierarchy(
+        self, trackable_type: str, trackable_id: int
+    ) -> list[TaskStatus]:
+        """Load progress states with IDs and parent IDs from database."""
         ...
 
-    async def get_by_uri(self, uri: AnyUrl) -> Index | None:
-        """Get an index by source URI."""
+    async def delete(self, status: TaskStatus) -> None:
+        """Delete a progress state."""
         ...
 
-    async def update_index_timestamp(self, index_id: int) -> None:
-        """Update the timestamp of an index."""
-        ...
 
-    async def add_snippets(self, index_id: int, snippets: list[Snippet]) -> None:
-        """Add snippets to an index."""
-        ...
+class GitCommitRepository(ABC):
+    """Repository for Git commits."""
 
-    async def update_snippets(self, index_id: int, snippets: list[Snippet]) -> None:
-        """Update snippets for an index."""
-        ...
+    @abstractmethod
+    async def get_by_sha(self, commit_sha: str) -> GitCommit:
+        """Get a commit by its SHA."""
 
-    async def delete_snippets(self, index_id: int) -> None:
-        """Delete all snippets from an index."""
-        ...
+    @abstractmethod
+    async def get_by_repo_id(self, repo_id: int) -> list[GitCommit]:
+        """Get all commits for a repository."""
 
-    async def delete_snippets_by_file_ids(self, file_ids: list[int]) -> None:
-        """Delete snippets by file IDs."""
-        ...
+    @abstractmethod
+    async def save(self, commit: GitCommit, repo_id: int) -> GitCommit:
+        """Save a commit to a repository."""
 
-    async def search(self, request: MultiSearchRequest) -> Sequence[SnippetWithContext]:
-        """Search snippets with filters."""
-        ...
+    @abstractmethod
+    async def save_bulk(self, commits: list[GitCommit], repo_id: int) -> None:
+        """Bulk save commits to a repository."""
 
-    async def get_snippets_by_ids(self, ids: list[int]) -> list[SnippetWithContext]:
-        """Get snippets by their IDs."""
-        ...
+    @abstractmethod
+    async def exists(self, commit_sha: str) -> bool:
+        """Check if a commit exists."""
 
+    @abstractmethod
+    async def delete_by_repo_id(self, repo_id: int) -> None:
+        """Delete all commits for a repository."""
 
-class ReportingModule(Protocol):
-    """Reporting module."""
+    @abstractmethod
+    async def count_by_repo_id(self, repo_id: int) -> int:
+        """Count the number of commits for a repository."""
 
-    async def on_change(self, progress: TaskStatus) -> None:
-        """On step changed."""
-        ...
 
+class GitBranchRepository(ABC):
+    """Repository for Git branches."""
 
-class TaskStatusRepository(Protocol):
-    """Repository interface for persisting progress state only."""
+    @abstractmethod
+    async def get_by_name(self, branch_name: str, repo_id: int) -> GitBranch:
+        """Get a branch by name and repository ID."""
 
-    async def save(self, status: TaskStatus) -> None:
-        """Save a progress state."""
-        ...
+    @abstractmethod
+    async def get_by_repo_id(self, repo_id: int) -> list[GitBranch]:
+        """Get all branches for a repository."""
 
-    async def load_with_hierarchy(
-        self, trackable_type: str, trackable_id: int
-    ) -> list[TaskStatus]:
-        """Load progress states with IDs and parent IDs from database."""
-        ...
+    @abstractmethod
+    async def save(self, branch: GitBranch, repo_id: int) -> GitBranch:
+        """Save a branch to a repository."""
 
-    async def delete(self, status: TaskStatus) -> None:
-        """Delete a progress state."""
-        ...
+    @abstractmethod
+    async def save_bulk(self, branches: list[GitBranch], repo_id: int) -> None:
+        """Bulk save branches to a repository."""
+
+    @abstractmethod
+    async def exists(self, branch_name: str, repo_id: int) -> bool:
+        """Check if a branch exists."""
+
+    @abstractmethod
+    async def delete_by_repo_id(self, repo_id: int) -> None:
+        """Delete all branches for a repository."""
+
+    @abstractmethod
+    async def count_by_repo_id(self, repo_id: int) -> int:
+        """Count the number of branches for a repository."""
+
+
+class GitTagRepository(ABC):
+    """Repository for Git tags."""
+
+    @abstractmethod
+    async def get_by_name(self, tag_name: str, repo_id: int) -> GitTag:
+        """Get a tag by name and repository ID."""
+
+    @abstractmethod
+    async def get_by_repo_id(self, repo_id: int) -> list[GitTag]:
+        """Get all tags for a repository."""
+
+    @abstractmethod
+    async def save(self, tag: GitTag, repo_id: int) -> GitTag:
+        """Save a tag to a repository."""
+
+    @abstractmethod
+    async def save_bulk(self, tags: list[GitTag], repo_id: int) -> None:
+        """Bulk save tags to a repository."""
+
+    @abstractmethod
+    async def exists(self, tag_name: str, repo_id: int) -> bool:
+        """Check if a tag exists."""
+
+    @abstractmethod
+    async def delete_by_repo_id(self, repo_id: int) -> None:
+        """Delete all tags for a repository."""
+
+    @abstractmethod
+    async def count_by_repo_id(self, repo_id: int) -> int:
+        """Count the number of tags for a repository."""
+
+
+class GitRepoRepository(ABC):
+    """Repository pattern for GitRepo aggregate.
+
+    GitRepo is the aggregate root that owns branches, commits, and tags.
+    This repository handles persistence of the entire aggregate.
+    """
+
+    @abstractmethod
+    async def save(self, repo: GitRepo) -> GitRepo:
+        """Save or update a repository with all its branches, commits, and tags.
+
+        This method persists the entire aggregate:
+        - The GitRepo entity itself
+        - All associated branches
+        - All associated commits
+        - All associated tags
+        """
+
+    @abstractmethod
+    async def get_by_id(self, repo_id: int) -> GitRepo:
+        """Get repository by ID with all associated data."""
+
+    @abstractmethod
+    async def get_by_uri(self, sanitized_uri: AnyUrl) -> GitRepo:
+        """Get repository by sanitized URI with all associated data."""
+
+    @abstractmethod
+    async def get_by_commit(self, commit_sha: str) -> GitRepo:
+        """Get repository by commit SHA with all associated data."""
+
+    @abstractmethod
+    async def get_all(self) -> list[GitRepo]:
+        """Get all repositories."""
+
+    @abstractmethod
+    async def delete(self, sanitized_uri: AnyUrl) -> bool:
+        """Delete a repository."""
+
+
+
+class GitAdapter(ABC):
+    """Abstract interface for Git operations."""
+
+    @abstractmethod
+    async def clone_repository(self, remote_uri: str, local_path: Path) -> None:
+        """Clone a repository to local path."""
+
+    @abstractmethod
+    async def checkout_commit(self, local_path: Path, commit_sha: str) -> None:
+        """Checkout a specific commit in the repository."""
+
+    @abstractmethod
+    async def pull_repository(self, local_path: Path) -> None:
+        """Pull latest changes for existing repository."""
+
+    @abstractmethod
+    async def get_all_branches(self, local_path: Path) -> list[dict[str, Any]]:
+        """Get all branches in repository."""
+
+    @abstractmethod
+    async def get_branch_commits(
+        self, local_path: Path, branch_name: str
+    ) -> list[dict[str, Any]]:
+        """Get commit history for a specific branch."""
+
+    @abstractmethod
+    async def get_commit_files(
+        self, local_path: Path, commit_sha: str
+    ) -> list[dict[str, Any]]:
+        """Get all files in a specific commit."""
+
+    @abstractmethod
+    async def repository_exists(self, local_path: Path) -> bool:
+        """Check if repository exists at local path."""
+
+    @abstractmethod
+    async def get_commit_details(
+        self, local_path: Path, commit_sha: str
+    ) -> dict[str, Any]:
+        """Get details of a specific commit."""
+
+    @abstractmethod
+    async def ensure_repository(self, remote_uri: str, local_path: Path) -> None:
+        """Ensure repository exists at local path."""
+
+    @abstractmethod
+    async def get_file_content(
+        self, local_path: Path, commit_sha: str, file_path: str
+    ) -> bytes:
+        """Get file content at specific commit."""
+
+    @abstractmethod
+    async def get_latest_commit_sha(
+        self, local_path: Path, branch_name: str = "HEAD"
+    ) -> str:
+        """Get the latest commit SHA for a branch."""
+
+    @abstractmethod
+    async def get_all_tags(self, local_path: Path) -> list[dict[str, Any]]:
+        """Get all tags in repository."""
+
+    @abstractmethod
+    async def get_all_commits_bulk(self, local_path: Path) -> dict[str, dict[str, Any]]:
+        """Get all commits from all branches in bulk for efficiency."""
+
+    @abstractmethod
+    async def get_branch_commit_shas(
+        self, local_path: Path, branch_name: str
+    ) -> list[str]:
+        """Get only commit SHAs for a branch (much faster than full commit data)."""
+
+
+class SnippetRepositoryV2(ABC):
+    """Repository for snippet operations."""
+
+    @abstractmethod
+    async def save_snippets(self, commit_sha: str, snippets: list[SnippetV2]) -> None:
+        """Batch save snippets for a commit."""
+
+    @abstractmethod
+    async def get_snippets_for_commit(self, commit_sha: str) -> list[SnippetV2]:
+        """Get all snippets for a specific commit."""
+
+    @abstractmethod
+    async def delete_snippets_for_commit(self, commit_sha: str) -> None:
+        """Delete all snippet associations for a commit."""
+
+    @abstractmethod
+    async def search(self, request: MultiSearchRequest) -> list[SnippetV2]:
+        """Search snippets with filters."""
+
+    @abstractmethod
+    async def get_by_ids(self, ids: list[str]) -> list[SnippetV2]:
+        """Get snippets by their 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."""

kodit/domain/services/bm25_service.py

@@ -105,7 +105,11 @@ class BM25DomainService:
         valid_ids = [
             snippet_id
             for snippet_id in request.snippet_ids
-            if snippet_id is not None and snippet_id > 0
+            if (
+                snippet_id is not None
+                and snippet_id != "0"
+                and not snippet_id.startswith("-")
+            )
         ]
 
         if not valid_ids:

kodit/domain/services/embedding_service.py

@@ -91,6 +91,9 @@ class EmbeddingDomainService:
         if not valid_documents:
             return
 
+        # TODO(Phil): We should handle the embedding of the documents here, then use the
+        # repo to simply store the embeddings.
+
         # Domain logic: create new request with validated documents
         validated_request = IndexRequest(documents=valid_documents)
         async for result in self.vector_search_repository.index_documents(