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

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,287 @@ 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 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 from the git tree."""
+
+    @abstractmethod
+    async def get_commit_file_data(
+        self, local_path: Path, commit_sha: str
+    ) -> list[dict[str, Any]]:
+        """Get file metadata for a commit, with files checked out to disk."""
+
+    @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(

kodit/domain/services/enrichment_service.py

@@ -1,48 +1,27 @@
 """Domain service for enrichment operations."""
 
-from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator
 
-from kodit.domain.value_objects import (
-    EnrichmentIndexRequest,
-    EnrichmentRequest,
-    EnrichmentResponse,
-)
-
-
-class EnrichmentProvider(ABC):
-    """Abstract enrichment provider interface."""
-
-    @abstractmethod
-    def enrich(
-        self, requests: list[EnrichmentRequest]
-    ) -> AsyncGenerator[EnrichmentResponse, None]:
-        """Enrich a list of requests."""
+from kodit.domain.enrichments.enricher import Enricher
+from kodit.domain.enrichments.request import EnrichmentRequest
+from kodit.domain.enrichments.response import EnrichmentResponse
 
 
 class EnrichmentDomainService:
     """Domain service for enrichment operations."""
 
-    def __init__(self, enrichment_provider: EnrichmentProvider) -> None:
-        """Initialize the enrichment domain service.
-
-        Args:
-            enrichment_provider: The enrichment provider to use.
-
-        """
-        self.enrichment_provider = enrichment_provider
+    def __init__(self, enricher: Enricher) -> None:
+        """Initialize the enrichment domain service."""
+        self.enricher = enricher
 
     async def enrich_documents(
-        self, request: EnrichmentIndexRequest
+        self, requests: list[EnrichmentRequest]
     ) -> AsyncGenerator[EnrichmentResponse, None]:
-        """Enrich documents using the enrichment provider.
-
-        Args:
-            request: The enrichment index request.
+        """Enrich documents using the enricher.
 
         Yields:
             Enrichment responses as they are processed.
 
         """
-        async for response in self.enrichment_provider.enrich(request.requests):
+        async for response in self.enricher.enrich(requests):
             yield response