kodit 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

kodit/domain/entities/git.py

@@ -2,20 +2,40 @@
 
 from dataclasses import dataclass
 from datetime import UTC, datetime
+from enum import StrEnum
 from hashlib import sha256
 from pathlib import Path
 
-from pydantic import AnyUrl, BaseModel
+from pydantic import AnyUrl, BaseModel, Field
 
 from kodit.domain.value_objects import Enrichment, IndexStatus
 from kodit.utils.path_utils import repo_id_from_uri
 
 
+class TrackingType(StrEnum):
+    """Tracking type."""
+
+    BRANCH = "branch"
+    TAG = "tag"
+    COMMIT_SHA = "commit_sha"
+
+
+DEFAULT_TRACKING_BRANCH = "main"
+
+
+class TrackingConfig(BaseModel, frozen=True):
+    """Tracking configuration for a repository."""
+
+    type: str = Field(..., description="The type of tracking to use.")
+    name: str = Field(..., description="The name of the tracking to use.")
+
+
 class GitFile(BaseModel):
     """File domain entity."""
 
     created_at: datetime
     blob_sha: str
+    commit_sha: str
     path: str
     mime_type: str
     size: int
@@ -40,10 +60,10 @@ class GitCommit(BaseModel):
     created_at: datetime | None = None  # Is populated by repository
     updated_at: datetime | None = None  # Is populated by repository
     commit_sha: str
+    repo_id: int  # Repository this commit belongs to
     date: datetime
     message: str
     parent_commit_sha: str | None = None  # The first commit in the repo is None
-    files: list[GitFile]
     author: str
 
     @property
@@ -59,7 +79,7 @@ class GitTag(BaseModel):
     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
+    target_commit_sha: str
 
     @property
     def id(self) -> str:
@@ -79,11 +99,11 @@ class GitTag(BaseModel):
 class GitBranch(BaseModel):
     """Branch domain entity."""
 
-    repo_id: int | None = None  # primary key
-    name: str  # primary key
+    repo_id: int
+    name: str
     created_at: datetime | None = None  # Is populated by repository
     updated_at: datetime | None = None  # Is populated by repository
-    head_commit: GitCommit
+    head_commit_sha: str
 
 
 @dataclass(frozen=True)
@@ -92,6 +112,7 @@ class RepositoryScanResult:
 
     branches: list[GitBranch]
     all_commits: list[GitCommit]
+    all_files: list[GitFile]
     all_tags: list[GitTag]
     scan_timestamp: datetime
     total_files_across_commits: int
@@ -108,11 +129,13 @@ class GitRepo(BaseModel):
 
     # 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
+    tracking_config: TrackingConfig = TrackingConfig(
+        type=TrackingType.BRANCH, name=DEFAULT_TRACKING_BRANCH
+    )
 
     @staticmethod
     def create_id(sanitized_remote_uri: AnyUrl) -> str:
@@ -121,24 +144,6 @@ class GitRepo(BaseModel):
 
     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)

kodit/domain/factories/git_repo_factory.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from pydantic import AnyUrl
 
 from kodit.domain.entities import WorkingCopy
-from kodit.domain.entities.git import GitBranch, GitRepo
+from kodit.domain.entities.git import GitRepo, TrackingConfig, TrackingType
 
 
 class GitRepoFactory:
@@ -29,13 +29,27 @@ class GitRepoFactory:
         sanitized_remote_uri: AnyUrl,
         remote_uri: AnyUrl,
         cloned_path: Path | None = None,
-        tracking_branch: GitBranch | None = None,
+        tracking_config: TrackingConfig | 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."""
+        if tracking_config is not None:
+            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_config=tracking_config,
+                last_scanned_at=last_scanned_at,
+                num_commits=num_commits,
+                num_branches=num_branches,
+                num_tags=num_tags,
+            )
         return GitRepo(
             id=repo_id,
             created_at=created_at,
@@ -43,7 +57,6 @@ class GitRepoFactory:
             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,
@@ -56,7 +69,7 @@ class GitRepoFactory:
         remote_uri: AnyUrl,
         sanitized_remote_uri: AnyUrl,
         repo_path: Path,
-        tracking_branch: GitBranch | None = None,
+        tracking_branch_name: str,
         last_scanned_at: datetime | None = None,
         num_commits: int = 0,
         num_branches: int = 0,
@@ -67,7 +80,9 @@ class GitRepoFactory:
             id=None,  # Let repository assign database ID
             sanitized_remote_uri=sanitized_remote_uri,
             remote_uri=remote_uri,
-            tracking_branch=tracking_branch,
+            tracking_config=TrackingConfig(
+                type=TrackingType.BRANCH, name=tracking_branch_name
+            ),
             cloned_path=repo_path,
             last_scanned_at=last_scanned_at,
             num_commits=num_commits,

kodit/domain/protocols.py

@@ -2,10 +2,9 @@
 
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Protocol
-
-from pydantic import AnyUrl
+from typing import Any, Protocol, TypeVar
 
+from kodit.domain.enrichments.enrichment import EnrichmentAssociation, EnrichmentV2
 from kodit.domain.entities import (
     Task,
     TaskStatus,
@@ -13,6 +12,7 @@ from kodit.domain.entities import (
 from kodit.domain.entities.git import (
     GitBranch,
     GitCommit,
+    GitFile,
     GitRepo,
     GitTag,
     SnippetV2,
@@ -21,41 +21,55 @@ from kodit.domain.value_objects import (
     FusionRequest,
     FusionResult,
     MultiSearchRequest,
-    TaskOperation,
 )
+from kodit.infrastructure.sqlalchemy.query import Query
 
+T = TypeVar("T")
 
-class TaskRepository(Protocol):
-    """Repository interface for Task entities."""
 
-    async def add(
-        self,
-        task: Task,
-    ) -> None:
-        """Add a task."""
+class Repository[T](Protocol):
+    """Abstract base classes for repositories."""
+
+    async def get(self, entity_id: Any) -> T:
+        """Get entity by primary key."""
         ...
 
-    async def get(self, task_id: str) -> Task | None:
-        """Get a task by ID."""
+    async def find(self, query: Query) -> list[T]:
+        """Find all entities matching query."""
         ...
 
-    async def next(self) -> Task | None:
-        """Take a task for processing."""
+    async def save(self, entity: T) -> T:
+        """Save entity (create new or update existing)."""
+        ...
+
+    async def save_bulk(self, entities: list[T]) -> list[T]:
+        """Save multiple entities in bulk (create new or update existing)."""
+        ...
+
+    async def exists(self, entity_id: Any) -> bool:
+        """Check if entity exists by primary key."""
         ...
 
-    async def remove(self, task: Task) -> None:
-        """Remove a task."""
+    async def delete(self, entity: T) -> None:
+        """Remove entity."""
         ...
 
-    async def update(self, task: Task) -> None:
-        """Update a task."""
+    async def delete_by_query(self, query: Query) -> None:
+        """Remove entities by query."""
         ...
 
-    async def list(self, task_operation: TaskOperation | None = None) -> list[Task]:
-        """List tasks with optional status filter."""
+    async def count(self, query: Query) -> int:
+        """Count the number of entities matching query."""
         ...
 
 
+class TaskRepository(Repository[Task], Protocol):
+    """Repository interface for Task entities."""
+
+    async def next(self) -> Task | None:
+        """Take a task for processing."""
+
+
 class ReportingModule(Protocol):
     """Reporting module."""
 
@@ -64,57 +78,33 @@ class ReportingModule(Protocol):
         ...
 
 
-class TaskStatusRepository(Protocol):
+class TaskStatusRepository(Repository[TaskStatus]):
     """Repository interface for persisting progress state only."""
 
-    async def save(self, status: TaskStatus) -> None:
-        """Save a progress state."""
-        ...
-
+    @abstractmethod
     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 delete(self, status: TaskStatus) -> None:
+    @abstractmethod
+    async def delete(self, entity: TaskStatus) -> None:
         """Delete a progress state."""
-        ...
 
 
-class GitCommitRepository(ABC):
+class GitCommitRepository(Repository[GitCommit]):
     """Repository for Git commits."""
 
-    @abstractmethod
-    async def get_by_sha(self, commit_sha: str) -> GitCommit:
-        """Get a commit by its SHA."""
-
-    @abstractmethod
-    async def get_by_repo_id(self, repo_id: int) -> list[GitCommit]:
-        """Get all commits for a repository."""
-
-    @abstractmethod
-    async def save(self, commit: GitCommit, repo_id: int) -> GitCommit:
-        """Save a commit to a repository."""
-
-    @abstractmethod
-    async def save_bulk(self, commits: list[GitCommit], repo_id: int) -> None:
-        """Bulk save commits to a repository."""
-
-    @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 GitFileRepository(Repository[GitFile]):
+    """Repository for Git files."""
 
     @abstractmethod
-    async def count_by_repo_id(self, repo_id: int) -> int:
-        """Count the number of commits for a repository."""
+    async def delete_by_commit_sha(self, commit_sha: str) -> None:
+        """Delete all files for a commit."""
 
 
-class GitBranchRepository(ABC):
+class GitBranchRepository(Repository[GitBranch]):
     """Repository for Git branches."""
 
     @abstractmethod
@@ -125,28 +115,12 @@ class GitBranchRepository(ABC):
     async def get_by_repo_id(self, repo_id: int) -> list[GitBranch]:
         """Get all branches for a repository."""
 
-    @abstractmethod
-    async def save(self, branch: GitBranch, repo_id: int) -> GitBranch:
-        """Save a branch to a repository."""
-
-    @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):
+class GitTagRepository(Repository[GitTag]):
     """Repository for Git tags."""
 
     @abstractmethod
@@ -157,64 +131,13 @@ class GitTagRepository(ABC):
     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 GitRepoRepository(Repository[GitRepo]):
+    """Repository pattern for GitRepo aggregate."""
 
 
 class GitAdapter(ABC):
@@ -323,3 +246,11 @@ class FusionService(ABC):
         self, rankings: list[list[FusionRequest]], k: float = 60
     ) -> list[FusionResult]:
         """Perform reciprocal rank fusion on search results."""
+
+
+class EnrichmentV2Repository(Repository[EnrichmentV2]):
+    """Repository for enrichment operations."""
+
+
+class EnrichmentAssociationRepository(Repository[EnrichmentAssociation]):
+    """Repository for enrichment association operations."""

kodit/domain/services/embedding_service.py

@@ -1,7 +1,7 @@
 """Domain services for embedding operations."""
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator, Sequence
+from collections.abc import AsyncGenerator
 
 from kodit.domain.value_objects import (
     EmbeddingRequest,
@@ -34,7 +34,7 @@ class VectorSearchRepository(ABC):
         """Index documents for vector search."""
 
     @abstractmethod
-    async def search(self, request: SearchRequest) -> Sequence[SearchResult]:
+    async def search(self, request: SearchRequest) -> list[SearchResult]:
         """Search documents using vector similarity."""
 
     @abstractmethod
@@ -101,19 +101,8 @@ class EmbeddingDomainService:
         ):
             yield result
 
-    async def search(self, request: SearchRequest) -> Sequence[SearchResult]:
-        """Search documents using domain business rules.
-
-        Args:
-            request: The search request
-
-        Returns:
-            Sequence of search results
-
-        Raises:
-            ValueError: If the request is invalid
-
-        """
+    async def search(self, request: SearchRequest) -> list[SearchResult]:
+        """Search documents using domain business rules."""
         # Domain logic: validate request
         if not request.query or not request.query.strip():
             raise ValueError("Search query cannot be empty")
@@ -127,7 +116,16 @@ class EmbeddingDomainService:
             query=normalized_query, top_k=request.top_k, snippet_ids=request.snippet_ids
         )
 
-        return await self.vector_search_repository.search(normalized_request)
+        results = await self.vector_search_repository.search(normalized_request)
+
+        # Deduplicate results while preserving order and scores
+        seen_ids: set[str] = set()
+        unique_results: list[SearchResult] = []
+        for result in results:
+            if result.snippet_id not in seen_ids:
+                seen_ids.add(result.snippet_id)
+                unique_results.append(result)
+        return unique_results
 
     async def has_embedding(
         self, snippet_id: int, embedding_type: EmbeddingType