kodit 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

kodit/infrastructure/cloning/git/working_copy.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import git
 import structlog
 
-from kodit.infrastructure.git.git_utils import sanitize_git_url
+from kodit.domain.entities import WorkingCopy
 
 
 class GitWorkingCopyProvider:
@@ -17,15 +17,17 @@ class GitWorkingCopyProvider:
         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 prepare(self, uri: str) -> Path:
         """Prepare a Git working copy."""
-        # Sanitize the URI for directory name to prevent credential leaks
-        sanitized_uri = sanitize_git_url(uri)
-
-        # Use a repeatable, short sha256 hash of the sanitized URI for the directory
-        dir_hash = hashlib.sha256(sanitized_uri.encode("utf-8")).hexdigest()[:16]
-        dir_name = f"repo-{dir_hash}"
-        clone_path = self.clone_dir / dir_name
+        sanitized_uri = WorkingCopy.sanitize_git_url(uri)
+        clone_path = self.get_clone_path(uri)
         clone_path.mkdir(parents=True, exist_ok=True)
 
         try:
@@ -41,3 +43,10 @@ class GitWorkingCopyProvider:
             self.log.info("Repository already exists, reusing...", uri=sanitized_uri)
 
         return clone_path
+
+    async def sync(self, uri: str) -> Path:
+        """Refresh a Git working copy."""
+        clone_path = self.get_clone_path(uri)
+        repo = git.Repo(clone_path)
+        repo.remotes.origin.pull()
+        return clone_path

kodit/infrastructure/cloning/metadata.py

@@ -4,59 +4,55 @@ import mimetypes
 from datetime import UTC, datetime
 from hashlib import sha256
 from pathlib import Path
-from typing import Any
 
 import aiofiles
 import git
-import structlog
+from pydantic import AnyUrl
 
-from kodit.domain.entities import Author, File, Source
+from kodit.domain.entities import Author, File
+from kodit.domain.value_objects import FileProcessingStatus, SourceType
 
 
-class BaseFileMetadataExtractor:
-    """Base class for file metadata extraction with common functionality."""
+class FileMetadataExtractor:
+    """File metadata extractor."""
 
-    async def extract(self, path: Path, source: Source) -> File:
+    def __init__(self, source_type: SourceType) -> None:
+        """Initialize the extractor."""
+        self.source_type = source_type
+
+    async def extract(self, file_path: Path) -> File:
         """Extract metadata from a file."""
-        # Get timestamps - to be implemented by subclasses
-        created_at, updated_at = await self._get_timestamps(path, source)
+        if self.source_type == SourceType.GIT:
+            created_at, updated_at = await self._get_git_timestamps(file_path)
+        else:
+            created_at, updated_at = await self._get_file_system_timestamps(file_path)
 
         # Read file content and calculate metadata
-        async with aiofiles.open(path, "rb") as f:
+        async with aiofiles.open(file_path, "rb") as f:
             content = await f.read()
-            mime_type = mimetypes.guess_type(path)
+            mime_type = mimetypes.guess_type(file_path)
             sha = sha256(content).hexdigest()
+            if self.source_type == SourceType.GIT:
+                authors = await self._extract_git_authors(file_path)
+            else:
+                authors = []
 
             return File(
                 created_at=created_at,
                 updated_at=updated_at,
-                source_id=source.id,
-                cloned_path=str(path),
+                uri=AnyUrl(file_path.resolve().absolute().as_uri()),
                 mime_type=mime_type[0]
                 if mime_type and mime_type[0]
                 else "application/octet-stream",
-                uri=path.as_uri(),
                 sha256=sha,
-                size_bytes=len(content),
-                extension=path.suffix.removeprefix(".").lower(),
+                authors=authors,
+                file_processing_status=FileProcessingStatus.ADDED,
             )
 
-    async def _get_timestamps(
-        self, path: Path, source: Source
-    ) -> tuple[datetime, datetime]:
-        """Get creation and modification timestamps. To be implemented by subclasses."""
-        raise NotImplementedError
-
-
-class GitFileMetadataExtractor(BaseFileMetadataExtractor):
-    """Git-specific implementation for extracting file metadata."""
-
-    async def _get_timestamps(
-        self, path: Path, source: Source
-    ) -> tuple[datetime, datetime]:
+    async def _get_git_timestamps(self, file_path: Path) -> tuple[datetime, datetime]:
         """Get timestamps from Git history."""
-        git_repo = git.Repo(source.cloned_path)
-        commits = list(git_repo.iter_commits(paths=str(path), all=True))
+        git_repo = git.Repo(file_path.parent, search_parent_directories=True)
+        commits = list(git_repo.iter_commits(paths=str(file_path), all=True))
 
         if commits:
             last_modified_at = commits[0].committed_datetime
@@ -66,38 +62,23 @@ class GitFileMetadataExtractor(BaseFileMetadataExtractor):
         now = datetime.now(UTC)
         return now, now
 
-
-class FolderFileMetadataExtractor(BaseFileMetadataExtractor):
-    """Folder-specific implementation for extracting file metadata."""
-
-    async def _get_timestamps(
+    async def _get_file_system_timestamps(
         self,
-        path: Path,
-        source: Source,  # noqa: ARG002
+        file_path: Path,
     ) -> tuple[datetime, datetime]:
         """Get timestamps from file system."""
-        stat = path.stat()
+        stat = file_path.stat()
         file_created_at = datetime.fromtimestamp(stat.st_ctime, UTC)
         file_modified_at = datetime.fromtimestamp(stat.st_mtime, UTC)
         return file_created_at, file_modified_at
 
-
-class GitAuthorExtractor:
-    """Author extractor for Git repositories."""
-
-    def __init__(self, repository: Any) -> None:
-        """Initialize the extractor."""
-        self.repository = repository
-        self.log = structlog.get_logger(__name__)
-
-    async def extract(self, path: Path, source: Source) -> list[Author]:
+    async def _extract_git_authors(self, file_path: Path) -> list[Author]:
         """Extract authors from a Git file."""
-        authors: list[Author] = []
-        git_repo = git.Repo(source.cloned_path)
+        git_repo = git.Repo(file_path.parent, search_parent_directories=True)
 
         try:
             # Get the file's blame
-            blames = git_repo.blame("HEAD", str(path))
+            blames = git_repo.blame("HEAD", str(file_path))
 
             # Extract the blame's authors
             actors = [
@@ -108,21 +89,10 @@ class GitAuthorExtractor:
             ]
 
             # Get or create the authors in the database
-            for actor in actors:
-                if actor.email:
-                    author = Author.from_actor(actor)
-                    author = await self.repository.upsert_author(author)
-                    authors.append(author)
+            return [
+                Author(name=actor.name or "", email=actor.email or "")
+                for actor in actors
+            ]
         except git.GitCommandError:
             # Handle cases where file might not be tracked
-            pass
-
-        return authors
-
-
-class NoOpAuthorExtractor:
-    """No-op author extractor for sources that don't have author information."""
-
-    async def extract(self, path: Path, source: Source) -> list[Author]:  # noqa: ARG002
-        """Return empty list of authors."""
-        return []
+            return []

kodit/infrastructure/embedding/embedding_factory.py

@@ -3,7 +3,6 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.config import AppContext, Endpoint
-from kodit.domain.entities import EmbeddingType
 from kodit.domain.services.embedding_service import EmbeddingDomainService
 from kodit.infrastructure.embedding.embedding_providers.local_embedding_provider import (  # noqa: E501
     CODE,
@@ -22,6 +21,7 @@ from kodit.infrastructure.embedding.vectorchord_vector_search_repository import
 from kodit.infrastructure.sqlalchemy.embedding_repository import (
     SqlAlchemyEmbeddingRepository,
 )
+from kodit.infrastructure.sqlalchemy.entities import EmbeddingType
 from kodit.log import log_event
 
 

kodit/infrastructure/embedding/local_vector_search_repository.py

@@ -4,7 +4,6 @@ from collections.abc import AsyncGenerator
 
 import structlog
 
-from kodit.domain.entities import Embedding, EmbeddingType
 from kodit.domain.services.embedding_service import (
     EmbeddingProvider,
     VectorSearchRepository,
@@ -19,6 +18,7 @@ from kodit.domain.value_objects import (
 from kodit.infrastructure.sqlalchemy.embedding_repository import (
     SqlAlchemyEmbeddingRepository,
 )
+from kodit.infrastructure.sqlalchemy.entities import Embedding, EmbeddingType
 
 
 class LocalVectorSearchRepository(VectorSearchRepository):

kodit/infrastructure/embedding/vectorchord_vector_search_repository.py

@@ -7,7 +7,6 @@ import structlog
 from sqlalchemy import Result, TextClause, text
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.domain.entities import EmbeddingType
 from kodit.domain.services.embedding_service import (
     EmbeddingProvider,
     VectorSearchRepository,
@@ -19,6 +18,7 @@ from kodit.domain.value_objects import (
     SearchRequest,
     SearchResult,
 )
+from kodit.infrastructure.sqlalchemy.entities import EmbeddingType
 
 # SQL Queries
 CREATE_VCHORD_EXTENSION = """

kodit/infrastructure/enrichment/null_enrichment_provider.py

@@ -1,5 +1,6 @@
 """Null enrichment provider for testing."""
 
+import re
 from collections.abc import AsyncGenerator
 
 from kodit.domain.services.enrichment_service import EnrichmentProvider
@@ -12,14 +13,7 @@ class NullEnrichmentProvider(EnrichmentProvider):
     async def enrich(
         self, requests: list[EnrichmentRequest]
     ) -> AsyncGenerator[EnrichmentResponse, None]:
-        """Return empty responses for all requests.
-
-        Args:
-            requests: List of enrichment requests.
-
-        Yields:
-            Empty enrichment responses.
-
-        """
+        """Only keep alphabetic characters."""
         for request in requests:
-            yield EnrichmentResponse(snippet_id=request.snippet_id, text="")
+            response = re.sub(r"[^a-zA-Z]", " ", request.text)
+            yield EnrichmentResponse(snippet_id=request.snippet_id, text=response)

kodit/infrastructure/git/git_utils.py

@@ -1,11 +1,11 @@
 """Git utilities for infrastructure operations."""
 
 import tempfile
-from urllib.parse import urlparse, urlunparse
 
 import git
 
 
+# FUTURE: move to clone dir
 def is_valid_clone_target(target: str) -> bool:
     """Return True if the target is clonable.
 
@@ -23,65 +23,3 @@ def is_valid_clone_target(target: str) -> bool:
             return False
         else:
             return True
-
-
-def sanitize_git_url(url: str) -> str:
-    """Remove credentials from a git URL while preserving the rest of the URL structure.
-
-    This function handles various git URL formats:
-    - HTTPS URLs with username:password@host
-    - HTTPS URLs with username@host (no password)
-    - SSH URLs (left unchanged)
-    - File URLs (left unchanged)
-
-    Args:
-        url: The git URL that may contain credentials.
-
-    Returns:
-        The sanitized URL with credentials removed.
-
-    Examples:
-        >>> sanitize_git_url("https://phil:token@dev.azure.com/org/project/_git/repo")
-        "https://dev.azure.com/org/project/_git/repo"
-        >>> sanitize_git_url("https://username@github.com/user/repo.git")
-        "https://github.com/user/repo.git"
-        >>> sanitize_git_url("git@github.com:user/repo.git")
-        "git@github.com:user/repo.git"
-
-    """
-    # Handle SSH URLs (they don't have credentials in the URL format)
-    if url.startswith(("git@", "ssh://")):
-        return url
-
-    # Handle file URLs
-    if url.startswith("file://"):
-        return url
-
-    try:
-        # Parse the URL
-        parsed = urlparse(url)
-
-        # If there are no credentials, return the URL as-is
-        if not parsed.username:
-            return url
-
-        # Reconstruct the URL without credentials
-        # Keep scheme, netloc (without username/password), path, params, query, fragment
-        sanitized_netloc = parsed.hostname
-        if parsed.port:
-            sanitized_netloc = f"{parsed.hostname}:{parsed.port}"
-
-        return urlunparse(
-            (
-                parsed.scheme,
-                sanitized_netloc,
-                parsed.path,
-                parsed.params,
-                parsed.query,
-                parsed.fragment,
-            )
-        )
-
-    except Exception:  # noqa: BLE001
-        # If URL parsing fails, return the original URL
-        return url

kodit/infrastructure/ignore/ignore_pattern_provider.py

@@ -5,11 +5,10 @@ from pathlib import Path
 import git
 import pathspec
 
-from kodit.domain.services.ignore_service import IgnorePatternProvider
 from kodit.infrastructure.git.git_utils import is_valid_clone_target
 
 
-class GitIgnorePatternProvider(IgnorePatternProvider):
+class GitIgnorePatternProvider:
     """Ignore pattern provider for git repositories."""
 
     def __init__(self, base_dir: Path) -> None:

kodit/infrastructure/indexing/auto_indexing_service.py

@@ -11,7 +11,6 @@ from kodit.application.factories.code_indexing_factory import (
     create_code_indexing_application_service,
 )
 from kodit.config import AppContext
-from kodit.domain.services.source_service import SourceService
 
 
 class AutoIndexingService:
@@ -44,29 +43,20 @@ class AutoIndexingService:
     async def _index_sources(self, sources: list[str]) -> None:
         """Index all configured sources in the background."""
         async with self.session_factory() as session:
-            source_service = SourceService(
-                clone_dir=self.app_context.get_clone_dir(),
-                session_factory=lambda: session,
-            )
-
             service = create_code_indexing_application_service(
                 app_context=self.app_context,
                 session=session,
-                source_service=source_service,
             )
 
             for source in sources:
                 try:
                     self.log.info("Auto-indexing source", source=source)
 
-                    # Create source
-                    s = await source_service.create(source)
-
                     # Create index
-                    index = await service.create_index(s.id)
+                    index = await service.create_index_from_uri(source)
 
                     # Run indexing (without progress callback for background mode)
-                    await service.run_index(index.id, progress_callback=None)
+                    await service.run_index(index, progress_callback=None)
 
                     self.log.info("Successfully auto-indexed source", source=source)
 

kodit/infrastructure/indexing/fusion_service.py

@@ -2,7 +2,7 @@
 
 from collections import defaultdict
 
-from kodit.domain.services.indexing_service import FusionService
+from kodit.domain.services.index_query_service import FusionService
 from kodit.domain.value_objects import FusionRequest, FusionResult
 
 

kodit/infrastructure/mappers/__init__.py

@@ -0,0 +1 @@
+"""Mapping layer for converting between domain and infrastructure models."""