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

kodit/domain/{entities.py → entities/__init__.py}

@@ -1,7 +1,5 @@
 """Pure domain entities using Pydantic."""
 
-import shutil
-from dataclasses import dataclass
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any, Protocol
@@ -10,17 +8,10 @@ from urllib.parse import urlparse, urlunparse
 from pydantic import AnyUrl, BaseModel
 
 from kodit.domain.value_objects import (
-    FileProcessingStatus,
-    QueuePriority,
     ReportingState,
-    SnippetContent,
-    SnippetContentType,
-    SourceType,
     TaskOperation,
-    TaskType,
     TrackableType,
 )
-from kodit.utils.path_utils import path_from_uri
 
 
 class IgnorePatternProvider(Protocol):
@@ -39,37 +30,9 @@ class Author(BaseModel):
     email: str
 
 
-class File(BaseModel):
-    """File domain entity."""
-
-    id: int | None = None  # Is populated by repository
-    created_at: datetime | None = None  # Is populated by repository
-    updated_at: datetime | None = None  # Is populated by repository
-    uri: AnyUrl
-    sha256: str
-    authors: list[Author]
-    mime_type: str
-    file_processing_status: FileProcessingStatus
-
-    def as_path(self) -> Path:
-        """Return the file as a path."""
-        return path_from_uri(str(self.uri))
-
-    def extension(self) -> str:
-        """Return the file extension."""
-        return Path(self.as_path()).suffix.lstrip(".")
-
-
 class WorkingCopy(BaseModel):
     """Working copy value object representing cloned source location."""
 
-    created_at: datetime | None = None  # Is populated by repository
-    updated_at: datetime | None = None  # Is populated by repository
-    remote_uri: AnyUrl
-    cloned_path: Path
-    source_type: SourceType
-    files: list[File]
-
     @classmethod
     def sanitize_local_path(cls, path: str) -> AnyUrl:
         """Sanitize a local path."""
@@ -100,26 +63,54 @@ class WorkingCopy(BaseModel):
             "ssh://git@github.com/user/repo.git"
 
         """
-        # Handle SSH URLs (they don't have credentials in the URL format)
+        # Handle different URL types
+        if not url:
+            raise ValueError("URL is required")
+
         if url.startswith("git@"):
-            # Convert git@host:path to ssh://git@host/path format for AnyUrl
-            # This maintains the same semantic meaning while making it a valid URL
-            if ":" in url and not url.startswith("ssh://"):
-                host_path = url[4:]  # Remove "git@"
-                if ":" in host_path:
-                    host, path = host_path.split(":", 1)
-                    ssh_url = f"ssh://git@{host}/{path}"
-                    return AnyUrl(ssh_url)
-            return AnyUrl(url)
+            return cls._handle_ssh_url(url)
         if url.startswith("ssh://"):
             return AnyUrl(url)
-
-        # Handle file URLs
         if url.startswith("file://"):
             return AnyUrl(url)
 
+        # Try local path conversion
+        local_url = cls._try_local_path_conversion(url)
+        if local_url:
+            return local_url
+
+        # Handle HTTPS URLs with credentials
+        return cls._sanitize_https_url(url)
+
+    @classmethod
+    def _handle_ssh_url(cls, url: str) -> AnyUrl:
+        """Handle SSH URL conversion."""
+        if ":" in url and not url.startswith("ssh://"):
+            host_path = url[4:]  # Remove "git@"
+            if ":" in host_path:
+                host, path = host_path.split(":", 1)
+                return AnyUrl(f"ssh://git@{host}/{path}")
+        return AnyUrl(url)
+
+    @classmethod
+    def _try_local_path_conversion(cls, url: str) -> AnyUrl | None:
+        """Try to convert local paths to file:// URLs."""
+        from pathlib import Path
+
+        try:
+            path = Path(url)
+            if path.exists() or url.startswith(("/", "./", "../")) or url == ".":
+                absolute_path = path.resolve()
+                return AnyUrl(f"file://{absolute_path}")
+        except OSError:
+            # Path operations failed, not a local path
+            pass
+        return None
+
+    @classmethod
+    def _sanitize_https_url(cls, url: str) -> AnyUrl:
+        """Remove credentials from HTTPS URLs."""
         try:
-            # Parse the URL
             parsed = urlparse(url)
 
             # If there are no credentials, return the URL as-is
@@ -127,7 +118,6 @@ class WorkingCopy(BaseModel):
                 return AnyUrl(url)
 
             # Reconstruct the URL without credentials
-            # scheme, netloc (without username/password), path, params, query, fragment
             sanitized_netloc = parsed.hostname
             if parsed.port:
                 sanitized_netloc = f"{parsed.hostname}:{parsed.port}"
@@ -144,65 +134,9 @@ class WorkingCopy(BaseModel):
                     )
                 )
             )
-
         except Exception as e:
             raise ValueError(f"Invalid URL: {url}") from e
 
-    def modified_or_deleted_files(self) -> list[File]:
-        """Return the modified or deleted files."""
-        return [
-            file
-            for file in self.files
-            if file.file_processing_status
-            in (FileProcessingStatus.MODIFIED, FileProcessingStatus.DELETED)
-        ]
-
-    def list_filesystem_paths(
-        self, ignore_provider: IgnorePatternProvider
-    ) -> list[Path]:
-        """List the filesystem paths of the files in the working copy."""
-        if not self.cloned_path.exists():
-            raise ValueError(f"Cloned path does not exist: {self.cloned_path}")
-
-        return [
-            f
-            for f in self.cloned_path.rglob("*")
-            if f.is_file() and not ignore_provider.should_ignore(f)
-        ]
-
-    def dirty_files(self) -> list[File]:
-        """Return the dirty files."""
-        return [
-            file
-            for file in self.files
-            if file.file_processing_status
-            in (FileProcessingStatus.MODIFIED, FileProcessingStatus.ADDED)
-        ]
-
-    def changed_files(self) -> list[File]:
-        """Return the changed files."""
-        return [
-            file
-            for file in self.files
-            if file.file_processing_status != FileProcessingStatus.CLEAN
-        ]
-
-    def clear_file_processing_statuses(self) -> None:
-        """Clear the file processing statuses."""
-        # First remove any files that are marked for deletion
-        self.files = [
-            file
-            for file in self.files
-            if file.file_processing_status != FileProcessingStatus.DELETED
-        ]
-        # Then clear the statuses for the remaining files
-        for file in self.files:
-            file.file_processing_status = FileProcessingStatus.CLEAN
-
-    def delete(self) -> None:
-        """Delete the working copy."""
-        shutil.rmtree(self.cloned_path)
-
 
 class Source(BaseModel):
     """Source domain entity."""
@@ -213,74 +147,6 @@ class Source(BaseModel):
     working_copy: WorkingCopy
 
 
-class Snippet(BaseModel):
-    """Snippet domain entity."""
-
-    id: int | None = None  # Is populated by repository
-    created_at: datetime | None = None  # Is populated by repository
-    updated_at: datetime | None = None  # Is populated by repository
-    derives_from: list[File]
-    original_content: SnippetContent | None = None
-    summary_content: SnippetContent | None = None
-
-    def original_text(self) -> str:
-        """Return the original content of the snippet."""
-        if self.original_content is None:
-            return ""
-        return self.original_content.value
-
-    def summary_text(self) -> str:
-        """Return the summary content of the snippet."""
-        if self.summary_content is None:
-            return ""
-        return self.summary_content.value
-
-    def add_original_content(self, content: str, language: str) -> None:
-        """Add an original content to the snippet."""
-        self.original_content = SnippetContent(
-            type=SnippetContentType.ORIGINAL,
-            value=content,
-            language=language,
-        )
-
-    def add_summary(self, summary: str) -> None:
-        """Add a summary to the snippet."""
-        self.summary_content = SnippetContent(
-            type=SnippetContentType.SUMMARY,
-            value=summary,
-            language="markdown",
-        )
-
-
-class Index(BaseModel):
-    """Index domain entity."""
-
-    id: int
-    created_at: datetime
-    updated_at: datetime
-    source: Source
-    snippets: list[Snippet]
-
-    def delete_snippets_for_files(self, files: list[File]) -> None:
-        """Delete the snippets that derive from a list of files."""
-        self.snippets = [
-            snippet
-            for snippet in self.snippets
-            if not any(file in snippet.derives_from for file in files)
-        ]
-
-
-# FUTURE: Remove this type, use the domain to get the required information.
-@dataclass(frozen=True)
-class SnippetWithContext:
-    """Domain model for snippet with associated context information."""
-
-    source: Source
-    file: File
-    authors: list[Author]
-    snippet: Snippet
-
-
 class Task(BaseModel):
     """Represents an item in the queue waiting to be processed.
 
@@ -289,7 +155,7 @@ class Task(BaseModel):
     """
 
     id: str  # Is a unique key to deduplicate items in the queue
-    type: TaskType  # Task type
+    type: TaskOperation  # Task operation
     priority: int  # Priority (higher number = higher priority)
     payload: dict[str, Any]  # Task-specific data
 
@@ -297,33 +163,22 @@ class Task(BaseModel):
     updated_at: datetime | None = None  # Is populated by repository
 
     @staticmethod
-    def create(task_type: TaskType, priority: int, payload: dict[str, Any]) -> "Task":
+    def create(
+        operation: TaskOperation, priority: int, payload: dict[str, Any]
+    ) -> "Task":
         """Create a task."""
         return Task(
-            id=Task._create_id(task_type, payload),
-            type=task_type,
+            id=Task.create_id(operation, payload),
+            type=operation,
             priority=priority,
             payload=payload,
         )
 
     @staticmethod
-    def _create_id(task_type: TaskType, payload: dict[str, Any]) -> str:
+    def create_id(operation: TaskOperation, payload: dict[str, Any]) -> str:
         """Create a unique id for a task."""
-        if task_type == TaskType.INDEX_UPDATE:
-            return str(payload["index_id"])
-
-        raise ValueError(f"Unknown task type: {task_type}")
-
-    @staticmethod
-    def create_index_update_task(
-        index_id: int, priority: QueuePriority = QueuePriority.USER_INITIATED
-    ) -> "Task":
-        """Create an index update task."""
-        return Task.create(
-            task_type=TaskType.INDEX_UPDATE,
-            priority=priority.value,
-            payload={"index_id": index_id},
-        )
+        first_id = next(iter(payload.values()), None)
+        return f"{operation}:{first_id}"
 
 
 class TaskStatus(BaseModel):

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,
+        )