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

kodit/domain/services/git_service.py

@@ -0,0 +1,300 @@
+"""Service for git operations."""
+
+import asyncio
+import hashlib
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import git
+import structlog
+from git import InvalidGitRepositoryError, Repo
+from pydantic import AnyUrl
+
+from kodit.application.factories.reporting_factory import create_noop_operation
+from kodit.application.services.reporting import ProgressTracker
+from kodit.domain.entities import WorkingCopy
+from kodit.domain.entities.git import (
+    GitBranch,
+    GitCommit,
+    GitFile,
+    GitRepo,
+    GitTag,
+)
+from kodit.domain.factories.git_repo_factory import GitRepoFactory
+
+if TYPE_CHECKING:
+    from git.objects import Commit
+
+
+class GitService:
+    """Service for git operations."""
+
+    def __init__(self, clone_dir: Path) -> None:
+        """Initialize the git service."""
+        self.clone_dir = clone_dir
+        self.log = structlog.get_logger(__name__)
+
+    def get_clone_path(self, uri: str) -> Path:
+        """Get the clone path for a Git working copy."""
+        sanitized_uri = WorkingCopy.sanitize_git_url(uri)
+        dir_hash = hashlib.sha256(str(sanitized_uri).encode("utf-8")).hexdigest()[:16]
+        dir_name = f"repo-{dir_hash}"
+        return self.clone_dir / dir_name
+
+    async def clone_and_extract_repo_info(
+        self, uri: str, step: ProgressTracker | None = None
+    ) -> GitRepo:
+        """Clone repository and extract complete git repository information."""
+        step = step or create_noop_operation()
+        # Verify the clone path doesn't already exist
+        clone_path = self.get_clone_path(uri)
+        if clone_path.exists():
+            raise ValueError(f"Clone path already exists: {clone_path}")
+        sanitized_uri = WorkingCopy.sanitize_git_url(uri)
+        clone_path.mkdir(parents=True, exist_ok=True)
+
+        step_record = []
+        await step.set_total(12)
+
+        def _clone_progress_callback(
+            a: int, _: str | float | None, __: str | float | None, _d: str
+        ) -> None:
+            if a not in step_record:
+                step_record.append(a)
+
+            # Git reports a really weird format. This is a quick hack to get some
+            # progress.
+            # Normally this would fail because the loop is already running,
+            # but in this case, this callback is called by some git sub-thread.
+            asyncio.run(
+                step.set_current(
+                    len(step_record), f"Cloning repository ({step_record[-1]})"
+                )
+            )
+
+        try:
+            self.log.info(
+                "Cloning repository", uri=sanitized_uri, clone_path=str(clone_path)
+            )
+            # Use the original URI for cloning (with credentials if present)
+            options = ["--depth=1", "--single-branch"]
+            git.Repo.clone_from(
+                uri,
+                clone_path,
+                progress=_clone_progress_callback,
+                multi_options=options,
+            )
+        except git.GitCommandError as e:
+            if "already exists and is not an empty directory" not in str(e):
+                msg = f"Failed to clone repository: {e}"
+                raise ValueError(msg) from e
+            self.log.info("Repository already exists, reusing...", uri=sanitized_uri)
+
+        # Extract git repository information from cloned path
+        # Convert original URI to AnyUrl for GitRepo
+        from pydantic import AnyUrl
+
+        original_uri = AnyUrl(uri)
+        return self.get_repo_info_from_path(clone_path, original_uri, sanitized_uri)
+
+    def get_repo_info_from_path(
+        self, repo_path: Path, remote_uri: AnyUrl, sanitized_remote_uri: AnyUrl
+    ) -> GitRepo:
+        """Extract complete git repository information from a local path."""
+        try:
+            repo = Repo(repo_path)
+        except InvalidGitRepositoryError as e:
+            raise ValueError(f"Path is not a git repository: {repo_path}") from e
+
+        # Get all branches with their commit histories
+        branches = self._get_all_branches(repo)
+
+        # Count commits for num_commits field (managed by GitCommitRepository)
+        all_commits = self._get_all_commits(repo)
+        num_commits = len(all_commits)
+
+        # Get all tags
+        all_tags = self._get_all_tags(repo)
+
+        # Get current branch as tracking branch
+        try:
+            current_branch = repo.active_branch
+            tracking_branch = next(
+                (b for b in branches if b.name == current_branch.name),
+                branches[0] if branches else None,
+            )
+        except (AttributeError, TypeError):
+            # Handle detached HEAD state or other branch access issues
+            tracking_branch = branches[0] if branches else None
+
+        if tracking_branch is None:
+            raise ValueError("No branches found in repository")
+
+        return GitRepoFactory.create_from_path_scan(
+            remote_uri=remote_uri,
+            sanitized_remote_uri=sanitized_remote_uri,
+            repo_path=repo_path,
+            tracking_branch=tracking_branch,
+            last_scanned_at=datetime.now(UTC),
+            num_commits=num_commits,
+            num_branches=len(branches),
+            num_tags=len(all_tags),
+        )
+
+    def get_commit_history(
+        self, repo_path: Path, branch_name: str, limit: int = 100
+    ) -> list[GitCommit]:
+        """Get commit history for a specific branch."""
+        try:
+            repo = Repo(repo_path)
+
+            # Get the branch reference
+            branch_ref = None
+            for branch in repo.branches:
+                if branch.name == branch_name:
+                    branch_ref = branch
+                    break
+
+            if branch_ref is None:
+                return []
+
+            # Get commit history for the branch
+            commits = []
+            for commit in repo.iter_commits(branch_ref, max_count=limit):
+                try:
+                    git_commit = self._convert_commit(repo, commit)
+                    commits.append(git_commit)
+                except Exception:  # noqa: BLE001, S112
+                    # Skip commits we can't process
+                    continue
+
+        except (InvalidGitRepositoryError, Exception):
+            return []
+        else:
+            return commits
+
+    def _get_all_branches(self, repo: Repo) -> list[GitBranch]:
+        """Get all branches with their commit histories."""
+        branches = []
+
+        for branch in repo.branches:
+            try:
+                # Get head commit for this branch
+                head_commit = self._convert_commit(repo, branch.commit)
+                branches.append(GitBranch(name=branch.name, head_commit=head_commit))
+            except Exception:  # noqa: BLE001, S112
+                # Skip branches that can't be accessed
+                continue
+
+        return branches
+
+    def _get_all_commits(self, repo: Repo) -> list[GitCommit]:
+        """Get all unique commits across all branches."""
+        commit_cache = {}  # Use SHA as key to avoid duplicates
+
+        # Get all commits from all branches
+        for branch in repo.branches:
+            try:
+                # Traverse the entire commit history for this branch
+                for commit in repo.iter_commits(branch):
+                    if commit.hexsha not in commit_cache:
+                        domain_commit = self._convert_commit(repo, commit)
+                        commit_cache[commit.hexsha] = domain_commit
+            except Exception:  # noqa: BLE001, S112
+                # Skip branches that can't be accessed
+                continue
+
+        return list(commit_cache.values())
+
+    def _get_all_tags(self, repo: Repo) -> list[GitTag]:
+        """Get all tags in the repository."""
+        all_commits = self._get_all_commits(repo)
+        all_commits_map = {commit.commit_sha: commit for commit in all_commits}
+        tags = []
+        try:
+            for tag_ref in repo.tags:
+                try:
+                    # Get the commit that the tag points to
+                    target_commit = tag_ref.commit
+
+                    tag = GitTag(
+                        created_at=datetime.now(UTC),
+                        name=tag_ref.name,
+                        target_commit=all_commits_map[target_commit.hexsha],
+                    )
+                    tags.append(tag)
+                except Exception:  # noqa: BLE001, S112
+                    # Skip tags that can't be processed
+                    continue
+        except Exception:  # noqa: BLE001
+            # If we can't get tags, return empty list
+            return []
+
+        return tags
+
+    def _convert_commit(self, repo: Repo, commit: "Commit") -> GitCommit:
+        """Convert a GitPython commit object to domain GitCommit."""
+        # Convert timestamp to datetime
+        commit_date = datetime.fromtimestamp(commit.committed_date, tz=UTC)
+
+        # Get parent commit SHA (first parent if merge commit)
+        parent_sha = commit.parents[0].hexsha if commit.parents else ""
+
+        # Get files changed in this commit
+        files = self._get_commit_files(repo, commit)
+
+        # Format author string from name and email
+        author_name = str(commit.author.name) if commit.author.name else ""
+        author_email = str(commit.author.email) if commit.author.email else ""
+        if author_name and author_email:
+            author = f"{author_name} <{author_email}>"
+        else:
+            author = author_name or "Unknown"
+
+        return GitCommit(
+            commit_sha=commit.hexsha,
+            date=commit_date,
+            message=str(commit.message).strip(),
+            parent_commit_sha=parent_sha,
+            files=files,
+            author=author,
+        )
+
+    def _get_commit_files(self, repo: Repo, commit: "Commit") -> list[GitFile]:
+        """Get files changed in a specific commit."""
+        try:
+            files = []
+
+            # Get files changed in this commit
+            if commit.parents:
+                # Compare with first parent to get changed files
+                changed_files = commit.parents[0].diff(commit)
+            else:
+                # Initial commit - get all files
+                changed_files = commit.diff(None)
+
+            for diff_item in changed_files:
+                # Handle both a_path and b_path (for renames/moves)
+                file_path = diff_item.b_path or diff_item.a_path
+                if file_path and diff_item.b_blob:
+                    try:
+                        blob = diff_item.b_blob
+                        file_entity = GitFile(
+                            created_at=datetime.now(UTC),
+                            blob_sha=blob.hexsha,
+                            path=str(Path(repo.working_dir) / file_path),
+                            mime_type="application/octet-stream",  # Default
+                            size=blob.size,
+                            extension=GitFile.extension_from_path(file_path),
+                        )
+                        files.append(file_entity)
+                    except Exception:  # noqa: BLE001, S112
+                        # Skip files we can't process
+                        continue
+
+        except Exception:  # noqa: BLE001
+            # If we can't get files for this commit, return empty list
+            return []
+        else:
+            return files

kodit/domain/services/task_status_query_service.py

@@ -0,0 +1,19 @@
+"""Domain service for querying task status."""
+
+from kodit.domain.entities import TaskStatus
+from kodit.domain.protocols import TaskStatusRepository
+from kodit.domain.value_objects import TrackableType
+
+
+class TaskStatusQueryService:
+    """Query service for task status information."""
+
+    def __init__(self, repository: TaskStatusRepository) -> None:
+        """Initialize the task status query service."""
+        self._repository = repository
+
+    async def get_index_status(self, repo_id: int) -> list[TaskStatus]:
+        """Get the status of tasks for a specific index."""
+        return await self._repository.load_with_hierarchy(
+            trackable_type=TrackableType.KODIT_REPOSITORY.value, trackable_id=repo_id
+        )

kodit/domain/value_objects.py

@@ -1,7 +1,6 @@
 """Pure domain value objects and DTOs."""
 
-import json
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum, IntEnum, StrEnum
 from pathlib import Path
@@ -18,12 +17,27 @@ class SourceType(IntEnum):
     GIT = 2
 
 
-class SnippetContentType(IntEnum):
+class SnippetContentType(StrEnum):
     """Type of snippet content."""
 
-    UNKNOWN = 0
-    ORIGINAL = 1
-    SUMMARY = 2
+    UNKNOWN = "unknown"
+    ORIGINAL = "original"
+    SUMMARY = "summary"
+
+
+class EnrichmentType(StrEnum):
+    """Type of enrichment."""
+
+    UNKNOWN = "unknown"
+    SUMMARIZATION = "summarization"
+
+
+@dataclass(frozen=True)
+class Enrichment:
+    """Enrichment domain value object."""
+
+    type: EnrichmentType
+    content: str
 
 
 class SnippetContent(BaseModel):
@@ -31,7 +45,6 @@ class SnippetContent(BaseModel):
 
     type: SnippetContentType
     value: str
-    language: str
 
 
 class SnippetSearchResult(BaseModel):
@@ -138,7 +151,7 @@ class SearchType(Enum):
 class Document:
     """Generic document model for indexing."""
 
-    snippet_id: int
+    snippet_id: str
     text: str
 
 
@@ -146,7 +159,7 @@ class Document:
 class DocumentSearchResult:
     """Generic document search result model."""
 
-    snippet_id: int
+    snippet_id: str
     score: float
 
 
@@ -154,7 +167,7 @@ class DocumentSearchResult:
 class SearchResult:
     """Generic search result model."""
 
-    snippet_id: int
+    snippet_id: str
     score: float
 
 
@@ -171,21 +184,21 @@ class SearchRequest:
 
     query: str
     top_k: int = 10
-    snippet_ids: list[int] | None = None
+    snippet_ids: list[str] | None = None
 
 
 @dataclass
 class DeleteRequest:
     """Generic deletion request."""
 
-    snippet_ids: list[int]
+    snippet_ids: list[str]
 
 
 @dataclass
 class IndexResult:
     """Generic indexing result."""
 
-    snippet_id: int
+    snippet_id: str
 
 
 @dataclass(frozen=True)
@@ -271,98 +284,11 @@ class MultiSearchRequest:
     filters: SnippetSearchFilters | None = None
 
 
-@dataclass
-class MultiSearchResult:
-    """Enhanced search result with comprehensive snippet metadata."""
-
-    id: int
-    content: str
-    original_scores: list[float]
-    source_uri: str
-    relative_path: str
-    language: str
-    authors: list[str]
-    created_at: datetime
-    summary: str
-
-    def __str__(self) -> str:
-        """Return enhanced formatted string representation."""
-        lines = [
-            "---",
-            f"id: {self.id}",
-            f"source: {self.source_uri}",
-            f"path: {self.relative_path}",
-            f"lang: {self.language}",
-            f"created: {self.created_at.isoformat()}",
-            f"authors: {', '.join(self.authors)}",
-            f"scores: {self.original_scores}",
-            "---",
-            f"{self.summary}\n",
-            f"```{self.language}",
-            f"{self.content}",
-            "```\n",
-        ]
-        return "\n".join(lines)
-
-    def to_json(self) -> str:
-        """Return LLM-optimized JSON representation following the compact schema."""
-        json_obj = {
-            "id": self.id,
-            "source": self.source_uri,
-            "path": self.relative_path,
-            "lang": self.language.lower(),
-            "created": self.created_at.isoformat() if self.created_at else "",
-            "author": ", ".join(self.authors),
-            "score": self.original_scores,
-            "code": self.content,
-            "summary": self.summary,
-        }
-
-        return json.dumps(json_obj, separators=(",", ":"))
-
-    @classmethod
-    def to_jsonlines(cls, results: list["MultiSearchResult"]) -> str:
-        """Convert multiple MultiSearchResult objects to JSON Lines format.
-
-        Args:
-            results: List of MultiSearchResult objects
-            include_summary: Whether to include summary fields
-
-        Returns:
-            JSON Lines string (one JSON object per line)
-
-        """
-        return "\n".join(result.to_json() for result in results)
-
-    @classmethod
-    def to_string(cls, results: list["MultiSearchResult"]) -> str:
-        """Convert multiple MultiSearchResult objects to a string."""
-        return "\n\n".join(str(result) for result in results)
-
-    @staticmethod
-    def calculate_relative_path(file_path: str, source_path: str) -> str:
-        """Calculate relative path from source root."""
-        try:
-            return str(Path(file_path).relative_to(Path(source_path)))
-        except ValueError:
-            # If file_path is not relative to source_path, return the file name
-            return Path(file_path).name
-
-    @staticmethod
-    def detect_language_from_extension(extension: str) -> str:
-        """Detect programming language from file extension."""
-        try:
-            return LanguageMapping.get_language_for_extension(extension).title()
-        except ValueError:
-            # Unknown extension, return a default
-            return "Unknown"
-
-
 @dataclass
 class FusionRequest:
     """Domain model for fusion request."""
 
-    id: int
+    id: str
     score: float
 
 
@@ -370,7 +296,7 @@ class FusionRequest:
 class FusionResult:
     """Domain model for fusion result."""
 
-    id: int
+    id: str
     score: float
     original_scores: list[float]
 
@@ -408,7 +334,7 @@ class ProgressState:
 class EmbeddingRequest:
     """Domain model for embedding request."""
 
-    snippet_id: int
+    snippet_id: str
     text: str
 
 
@@ -416,7 +342,7 @@ class EmbeddingRequest:
 class EmbeddingResponse:
     """Domain model for embedding response."""
 
-    snippet_id: int
+    snippet_id: str
     embedding: list[float]
 
 
@@ -424,7 +350,7 @@ class EmbeddingResponse:
 class EnrichmentRequest:
     """Domain model for enrichment request."""
 
-    snippet_id: int
+    snippet_id: str
     text: str
 
 
@@ -432,7 +358,7 @@ class EnrichmentRequest:
 class EnrichmentResponse:
     """Domain model for enrichment response."""
 
-    snippet_id: int
+    snippet_id: str
     text: str
 
 
@@ -651,22 +577,14 @@ class FunctionDefinition:
     end_byte: int
 
 
-class TaskType(Enum):
-    """Task type."""
-
-    INDEX_UPDATE = 1
-
-
 class QueuePriority(IntEnum):
     """Queue priority."""
 
     BACKGROUND = 10
+    NORMAL = 20
     USER_INITIATED = 50
 
 
-# Reporting value objects
-
-
 class ReportingState(StrEnum):
     """Reporting state."""
 
@@ -676,37 +594,85 @@ class ReportingState(StrEnum):
     FAILED = "failed"
     SKIPPED = "skipped"
 
+    @staticmethod
+    def is_terminal(state: "ReportingState") -> bool:
+        """Check if a state is completed."""
+        return state in [
+            ReportingState.COMPLETED,
+            ReportingState.FAILED,
+            ReportingState.SKIPPED,
+        ]
 
-@dataclass(frozen=True)
-class Progress:
-    """Immutable representation of a step's state."""
-
-    name: str
-    state: ReportingState
-    message: str = ""
-    error: BaseException | None = None
-    total: int = 0
-    current: int = 0
-
-    @property
-    def completion_percent(self) -> float:
-        """Calculate the percentage of completion."""
-        if self.total == 0:
-            return 0.0
-        return min(100.0, max(0.0, (self.current / self.total) * 100.0))
-
-    def with_error(self, error: BaseException) -> "Progress":
-        """Return a new snapshot with updated error."""
-        return replace(self, error=error)
-
-    def with_total(self, total: int) -> "Progress":
-        """Return a new snapshot with updated total."""
-        return replace(self, total=total)
-
-    def with_progress(self, current: int) -> "Progress":
-        """Return a new snapshot with updated progress."""
-        return replace(self, current=current)
 
-    def with_state(self, state: ReportingState, message: str = "") -> "Progress":
-        """Return a new snapshot with updated state."""
-        return replace(self, state=state, message=message)
+class TrackableType(StrEnum):
+    """Trackable type."""
+
+    INDEX = "indexes"
+    KODIT_REPOSITORY = "kodit.repository"
+    KODIT_COMMIT = "kodit.commit"
+
+
+class TaskOperation(StrEnum):
+    """Task operation."""
+
+    ROOT = "kodit.root"
+    CREATE_INDEX = "kodit.index.create"
+    RUN_INDEX = "kodit.index.run"
+    REFRESH_WORKING_COPY = "kodit.index.run.refresh_working_copy"
+    DELETE_OLD_SNIPPETS = "kodit.index.run.delete_old_snippets"
+    EXTRACT_SNIPPETS = "kodit.index.run.extract_snippets"
+    CREATE_BM25_INDEX = "kodit.index.run.create_bm25_index"
+    CREATE_CODE_EMBEDDINGS = "kodit.index.run.create_code_embeddings"
+    ENRICH_SNIPPETS = "kodit.index.run.enrich_snippets"
+    CREATE_TEXT_EMBEDDINGS = "kodit.index.run.create_text_embeddings"
+    UPDATE_INDEX_TIMESTAMP = "kodit.index.run.update_index_timestamp"
+    CLEAR_FILE_PROCESSING_STATUSES = "kodit.index.run.clear_file_processing_statuses"
+
+    # New commit-based workflow
+    KODIT_REPOSITORY = "kodit.repository"
+    CREATE_REPOSITORY = "kodit.repository.create"
+    DELETE_REPOSITORY = "kodit.repository.delete"
+    CLONE_REPOSITORY = "kodit.repository.clone"
+    SCAN_REPOSITORY = "kodit.repository.scan"
+    KODIT_COMMIT = "kodit.commit"
+    EXTRACT_SNIPPETS_FOR_COMMIT = "kodit.commit.extract_snippets"
+    CREATE_BM25_INDEX_FOR_COMMIT = "kodit.commit.create_bm25_index"
+    CREATE_CODE_EMBEDDINGS_FOR_COMMIT = "kodit.commit.create_code_embeddings"
+    CREATE_SUMMARY_ENRICHMENT_FOR_COMMIT = "kodit.commit.create_summary_enrichment"
+    CREATE_SUMMARY_EMBEDDINGS_FOR_COMMIT = "kodit.commit.create_summary_embeddings"
+
+    def is_repository_operation(self) -> bool:
+        """Check if the task operation is a repository operation."""
+        return self.startswith("kodit.repository.")
+
+    def is_commit_operation(self) -> bool:
+        """Check if the task operation is a commit operation."""
+        return self.startswith("kodit.commit.")
+
+
+class PrescribedOperations:
+    """Prescribed common operations."""
+
+    CREATE_NEW_REPOSITORY: ClassVar[list[TaskOperation]] = [
+        TaskOperation.CLONE_REPOSITORY,
+        TaskOperation.SCAN_REPOSITORY,
+    ]
+    INDEX_COMMIT: ClassVar[list[TaskOperation]] = [
+        TaskOperation.EXTRACT_SNIPPETS_FOR_COMMIT,
+        TaskOperation.CREATE_BM25_INDEX_FOR_COMMIT,
+        TaskOperation.CREATE_CODE_EMBEDDINGS_FOR_COMMIT,
+        TaskOperation.CREATE_SUMMARY_ENRICHMENT_FOR_COMMIT,
+        TaskOperation.CREATE_SUMMARY_EMBEDDINGS_FOR_COMMIT,
+    ]
+    SYNC_REPOSITORY: ClassVar[list[TaskOperation]] = [
+        TaskOperation.SCAN_REPOSITORY,
+    ]
+
+
+class IndexStatus(StrEnum):
+    """Status of commit indexing."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"