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

kodit/infrastructure/api/v1/dependencies.py

@@ -13,6 +13,9 @@ from kodit.application.services.code_search_application_service import (
 from kodit.application.services.commit_indexing_application_service import (
     CommitIndexingApplicationService,
 )
+from kodit.application.services.enrichment_query_service import (
+    EnrichmentQueryService,
+)
 from kodit.application.services.queue_service import QueueService
 from kodit.config import AppContext
 from kodit.domain.protocols import (
@@ -155,3 +158,15 @@ async def get_code_search_app_service(
 CodeSearchAppServiceDep = Annotated[
     CodeSearchApplicationService, Depends(get_code_search_app_service)
 ]
+
+
+async def get_enrichment_query_service(
+    server_factory: ServerFactoryDep,
+) -> EnrichmentQueryService:
+    """Get enrichment query service dependency."""
+    return server_factory.enrichment_query_service()
+
+
+EnrichmentQueryServiceDep = Annotated[
+    EnrichmentQueryService, Depends(get_enrichment_query_service)
+]

kodit/infrastructure/api/v1/routers/commits.py

@@ -22,6 +22,11 @@ from kodit.infrastructure.api.v1.schemas.commit import (
     FileListResponse,
     FileResponse,
 )
+from kodit.infrastructure.api.v1.schemas.enrichment import (
+    EnrichmentAttributes,
+    EnrichmentData,
+    EnrichmentListResponse,
+)
 from kodit.infrastructure.api.v1.schemas.snippet import (
     EnrichmentSchema,
     GitFileSchema,
@@ -269,3 +274,79 @@ async def list_commit_embeddings(
             for embedding in embeddings
         ]
     )
+
+
+@router.get(
+    "/{repo_id}/commits/{commit_sha}/enrichments",
+    summary="List commit enrichments",
+    responses={404: {"description": "Repository or commit not found"}},
+)
+async def list_commit_enrichments(
+    repo_id: str,  # noqa: ARG001
+    commit_sha: str,
+    server_factory: ServerFactoryDep,
+) -> EnrichmentListResponse:
+    """List all enrichments for a specific commit."""
+    # TODO(Phil): Should use repo too, it's confusing to the user when they specify the
+    # wrong commit and another repo. It's like they are seeing results from the other
+    # repo.
+    enrichment_v2_repository = server_factory.enrichment_v2_repository()
+    enrichments = await enrichment_v2_repository.enrichments_for_entity_type(
+        entity_type="git_commit",
+        entity_ids=[commit_sha],
+    )
+
+    return EnrichmentListResponse(
+        data=[
+            EnrichmentData(
+                type="enrichment",
+                id=str(enrichment.id),
+                attributes=EnrichmentAttributes(
+                    type=enrichment.type,
+                    subtype=enrichment.subtype,
+                    content=enrichment.content,
+                    created_at=enrichment.created_at,
+                    updated_at=enrichment.updated_at,
+                ),
+            )
+            for enrichment in enrichments
+        ]
+    )
+
+
+@router.delete(
+    "/{repo_id}/commits/{commit_sha}/enrichments",
+    summary="Delete all commit enrichments",
+    responses={404: {"description": "Commit not found"}},
+    status_code=204,
+)
+async def delete_all_commit_enrichments(
+    repo_id: str,  # noqa: ARG001
+    commit_sha: str,
+    server_factory: ServerFactoryDep,
+) -> None:
+    """Delete all enrichments for a specific commit."""
+    enrichment_v2_repository = server_factory.enrichment_v2_repository()
+    await enrichment_v2_repository.bulk_delete_enrichments(
+        entity_type="git_commit",
+        entity_ids=[commit_sha],
+    )
+
+
+@router.delete(
+    "/{repo_id}/commits/{commit_sha}/enrichments/{enrichment_id}",
+    summary="Delete commit enrichment",
+    responses={404: {"description": "Enrichment not found"}},
+    status_code=204,
+)
+async def delete_commit_enrichment(
+    repo_id: str,  # noqa: ARG001
+    commit_sha: str,  # noqa: ARG001
+    enrichment_id: int,
+    server_factory: ServerFactoryDep,
+) -> None:
+    """Delete a specific enrichment for a commit."""
+    enrichment_v2_repository = server_factory.enrichment_v2_repository()
+    deleted = await enrichment_v2_repository.delete_enrichment(enrichment_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Enrichment not found")

kodit/infrastructure/api/v1/routers/repositories.py

@@ -2,15 +2,22 @@
 
 from fastapi import APIRouter, Depends, HTTPException
 
+from kodit.domain.tracking.trackable import Trackable, TrackableReferenceType
 from kodit.infrastructure.api.middleware.auth import api_key_auth
 from kodit.infrastructure.api.v1.dependencies import (
     CommitIndexingAppServiceDep,
+    EnrichmentQueryServiceDep,
     GitBranchRepositoryDep,
     GitCommitRepositoryDep,
     GitRepositoryDep,
     GitTagRepositoryDep,
     TaskStatusQueryServiceDep,
 )
+from kodit.infrastructure.api.v1.schemas.enrichment import (
+    EnrichmentAttributes,
+    EnrichmentData,
+    EnrichmentListResponse,
+)
 from kodit.infrastructure.api.v1.schemas.repository import (
     RepositoryBranchData,
     RepositoryCommitData,
@@ -259,6 +266,98 @@ async def get_repository_tag(
     )
 
 
+@router.get(
+    "/{repo_id}/enrichments",
+    summary="List latest repository enrichments",
+    responses={404: {"description": "Repository not found"}},
+)
+async def list_repository_enrichments(  # noqa: PLR0913
+    repo_id: str,
+    git_repository: GitRepositoryDep,
+    enrichment_query_service: EnrichmentQueryServiceDep,
+    ref_type: str = "branch",
+    ref_name: str | None = None,
+    enrichment_type: str | None = None,
+    limit: int = 10,
+) -> EnrichmentListResponse:
+    """List the most recent enrichments for a repository.
+
+    Query parameters:
+    - ref_type: Type of reference (branch, tag, or commit_sha). Defaults to "branch".
+    - ref_name: Name of the reference. For branches, defaults to the tracking branch.
+    - enrichment_type: Optional filter for specific enrichment type.
+    - limit: Maximum number of enrichments to return. Defaults to 10.
+    """
+    # Get repository
+    repo = await git_repository.get_by_id(int(repo_id))
+    if not repo:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    # Determine the reference to track
+    if ref_name is None:
+        if ref_type == "branch":
+            # Default to tracking branch
+            if not repo.tracking_branch:
+                raise HTTPException(
+                    status_code=400, detail="No tracking branch configured"
+                )
+            ref_name = repo.tracking_branch.name
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail="ref_name is required for tag and commit_sha references",
+            )
+
+    # Parse ref_type
+    try:
+        trackable_type = TrackableReferenceType(ref_type)
+    except ValueError:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid ref_type: {ref_type}. Must be branch, tag, or commit_sha",
+        ) from None
+
+    # Create trackable
+    trackable = Trackable(
+        type=trackable_type, identifier=ref_name, repo_id=int(repo_id)
+    )
+
+    # Find the latest enriched commit
+    enriched_commit = await enrichment_query_service.find_latest_enriched_commit(
+        trackable=trackable,
+        enrichment_type=enrichment_type,
+        max_commits_to_check=limit * 10,  # Check more commits to find enriched ones
+    )
+
+    # If no enriched commit found, return empty list
+    if not enriched_commit:
+        return EnrichmentListResponse(data=[])
+
+    # Get enrichments for the commit
+    enrichments = await enrichment_query_service.get_enrichments_for_commit(
+        commit_sha=enriched_commit,
+        enrichment_type=enrichment_type,
+    )
+
+    # Map enrichments to API response format
+    enrichment_data = [
+        EnrichmentData(
+            type="enrichment",
+            id=str(enrichment.id) if enrichment.id else "0",
+            attributes=EnrichmentAttributes(
+                type=enrichment.type,
+                subtype=enrichment.subtype,
+                content=enrichment.content,
+                created_at=enrichment.created_at,
+                updated_at=enrichment.updated_at,
+            ),
+        )
+        for enrichment in enrichments
+    ]
+
+    return EnrichmentListResponse(data=enrichment_data)
+
+
 @router.delete(
     "/{repo_id}",
     status_code=204,

kodit/infrastructure/api/v1/schemas/enrichment.py

@@ -0,0 +1,29 @@
+"""Enrichment JSON-API schemas."""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class EnrichmentAttributes(BaseModel):
+    """Enrichment attributes following JSON-API spec."""
+
+    type: str
+    subtype: str | None
+    content: str
+    created_at: datetime | None
+    updated_at: datetime | None
+
+
+class EnrichmentData(BaseModel):
+    """Enrichment data following JSON-API spec."""
+
+    type: str = "enrichment"
+    id: str
+    attributes: EnrichmentAttributes
+
+
+class EnrichmentListResponse(BaseModel):
+    """Enrichment list response following JSON-API spec."""
+
+    data: list[EnrichmentData]

kodit/infrastructure/cloning/git/git_python_adaptor.py

@@ -101,8 +101,11 @@ class GitPythonAdapter(GitAdapter):
 
         await asyncio.get_event_loop().run_in_executor(self.executor, _clone)
 
-    async def checkout_commit(self, local_path: Path, commit_sha: str) -> None:
-        """Checkout a specific commit in the repository."""
+    async def _checkout_commit(self, local_path: Path, commit_sha: str) -> None:
+        """Checkout a specific commit internally.
+
+        Private method - external callers should not mutate repository state directly.
+        """
 
         def _checkout() -> None:
             try:
@@ -116,6 +119,52 @@ class GitPythonAdapter(GitAdapter):
 
         await asyncio.get_event_loop().run_in_executor(self.executor, _checkout)
 
+    async def restore_to_branch(
+        self, local_path: Path, branch_name: str = "main"
+    ) -> None:
+        """Restore repository to a specific branch, recovering from detached HEAD.
+
+        Args:
+            local_path: Path to the repository
+            branch_name: Branch to restore to (default: "main")
+
+        """
+
+        def _restore() -> None:
+            try:
+                repo = Repo(local_path)
+
+                # Try to checkout the requested branch
+                try:
+                    repo.git.checkout(branch_name)
+                except Exception:  # noqa: BLE001
+                    # If requested branch doesn't exist, try common default branches
+                    for fallback in ["master", "develop"]:
+                        try:
+                            repo.git.checkout(fallback)
+                        except Exception:  # noqa: BLE001
+                            # Branch doesn't exist, try next fallback
+                            self._log.debug(f"Branch {fallback} not found, trying next")
+                        else:
+                            self._log.debug(
+                                f"Branch {branch_name} not found, "
+                                f"restored to {fallback} instead"
+                            )
+                            return
+
+                    # If all branches fail, stay in detached state
+                    self._log.warning(
+                        f"Could not restore to any branch in {local_path}, "
+                        f"repository remains in detached HEAD state"
+                    )
+                else:
+                    self._log.debug(f"Restored repository to branch {branch_name}")
+            except Exception as e:
+                self._log.error(f"Failed to restore branch in {local_path}: {e}")
+                raise
+
+        await asyncio.get_event_loop().run_in_executor(self.executor, _restore)
+
     async def pull_repository(self, local_path: Path) -> None:
         """Pull latest changes for existing repository."""
 
@@ -139,12 +188,20 @@ class GitPythonAdapter(GitAdapter):
                 repo = Repo(local_path)
 
                 # Get local branches
+                # Check if HEAD is detached
+                try:
+                    active_branch = repo.active_branch
+                except TypeError:
+                    # HEAD is detached, no active branch
+                    active_branch = None
+
                 branches = [
                     {
                         "name": branch.name,
                         "type": "local",
                         "head_commit_sha": branch.commit.hexsha,
-                        "is_active": branch == repo.active_branch,
+                        "is_active": active_branch is not None
+                        and branch == active_branch,
                     }
                     for branch in repo.branches
                 ]
@@ -291,7 +348,7 @@ class GitPythonAdapter(GitAdapter):
     async def get_commit_files(
         self, local_path: Path, commit_sha: str
     ) -> list[dict[str, Any]]:
-        """Get all files in a specific commit."""
+        """Get all files in a specific commit from the git tree."""
 
         def _get_files() -> list[dict[str, Any]]:
             try:
@@ -332,6 +389,16 @@ class GitPythonAdapter(GitAdapter):
 
         return await asyncio.get_event_loop().run_in_executor(self.executor, _get_files)
 
+    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."""
+        await self._checkout_commit(local_path, commit_sha)
+        try:
+            return await self.get_commit_files(local_path, commit_sha)
+        finally:
+            await self.restore_to_branch(local_path, "main")
+
     async def repository_exists(self, local_path: Path) -> bool:
         """Check if repository exists at local path."""
 

kodit/infrastructure/enricher/__init__.py

@@ -0,0 +1 @@
+"""Generic enricher infrastructure implementations."""

kodit/infrastructure/enricher/enricher_factory.py

@@ -0,0 +1,53 @@
+"""Enricher factory for creating generic enricher domain services."""
+
+from kodit.config import AppContext, Endpoint
+from kodit.domain.enrichments.enricher import Enricher
+from kodit.infrastructure.enricher.litellm_enricher import LiteLLMEnricher
+from kodit.infrastructure.enricher.local_enricher import LocalEnricher
+from kodit.infrastructure.enricher.null_enricher import NullEnricher
+from kodit.log import log_event
+
+
+def _get_endpoint_configuration(app_context: AppContext) -> Endpoint | None:
+    """Get the endpoint configuration for the enricher service.
+
+    Args:
+        app_context: The application context.
+
+    Returns:
+        The endpoint configuration or None.
+
+    """
+    return app_context.enrichment_endpoint or None
+
+
+def enricher_domain_service_factory(
+    app_context: AppContext,
+    *,
+    use_null_enricher: bool = False,
+) -> Enricher:
+    """Create an enricher domain service.
+
+    Args:
+        app_context: The application context.
+        use_null_enricher: Whether to use the null enricher instead.
+
+    Returns:
+        An enricher domain service instance.
+
+    """
+    enricher: Enricher
+
+    if use_null_enricher:
+        log_event("kodit.enricher", {"provider": "null"})
+        enricher = NullEnricher()
+    else:
+        endpoint = _get_endpoint_configuration(app_context)
+        if endpoint:
+            log_event("kodit.enricher", {"provider": "litellm"})
+            enricher = LiteLLMEnricher(endpoint=endpoint)
+        else:
+            log_event("kodit.enricher", {"provider": "local"})
+            enricher = LocalEnricher()
+
+    return enricher

kodit/infrastructure/{enrichment/litellm_enrichment_provider.py → enricher/litellm_enricher.py}

@@ -1,4 +1,4 @@
-"""LiteLLM enrichment provider implementation."""
+"""LiteLLM enricher implementation."""
 
 import asyncio
 from collections.abc import AsyncGenerator
@@ -10,27 +10,22 @@ import structlog
 from litellm import acompletion
 
 from kodit.config import Endpoint
-from kodit.domain.services.enrichment_service import EnrichmentProvider
-from kodit.domain.value_objects import EnrichmentRequest, EnrichmentResponse
-from kodit.infrastructure.enrichment.utils import clean_thinking_tags
+from kodit.domain.enrichments.enricher import Enricher
+from kodit.domain.enrichments.request import EnrichmentRequest
+from kodit.domain.enrichments.response import EnrichmentResponse
+from kodit.infrastructure.enricher.utils import clean_thinking_tags
 
-ENRICHMENT_SYSTEM_PROMPT = """
-You are a professional software developer. You will be given a snippet of code.
-Please provide a concise explanation of the code.
-"""
-
-# Default tuned conservatively for broad provider compatibility
 DEFAULT_NUM_PARALLEL_TASKS = 20
 
 
-class LiteLLMEnrichmentProvider(EnrichmentProvider):
-    """LiteLLM enrichment provider that supports 100+ providers."""
+class LiteLLMEnricher(Enricher):
+    """LiteLLM enricher that supports 100+ providers."""
 
     def __init__(
         self,
         endpoint: Endpoint,
     ) -> None:
-        """Initialize the LiteLLM enrichment provider.
+        """Initialize the LiteLLM enricher.
 
         Args:
             endpoint: The endpoint configuration containing all settings.
@@ -44,23 +39,20 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
         self.num_parallel_tasks = (
             endpoint.num_parallel_tasks or DEFAULT_NUM_PARALLEL_TASKS
         )
-        self.timeout = endpoint.timeout or 30.0
+        self.timeout = endpoint.timeout
         self.extra_params = endpoint.extra_params or {}
 
-        # Configure LiteLLM with custom HTTPX client for Unix socket support if needed
         self._setup_litellm_client()
 
     def _setup_litellm_client(self) -> None:
         """Set up LiteLLM with custom HTTPX client for Unix socket support."""
         if self.socket_path:
-            # Create HTTPX client with Unix socket transport
             transport = httpx.AsyncHTTPTransport(uds=self.socket_path)
             unix_client = httpx.AsyncClient(
                 transport=transport,
-                base_url="http://localhost",  # Base URL for Unix socket
+                base_url="http://localhost",
                 timeout=self.timeout,
             )
-            # Set as LiteLLM's async client session
             litellm.aclient_session = unix_client
 
     async def _call_chat_completion(self, messages: list[dict[str, str]]) -> Any:
@@ -79,20 +71,17 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
             "timeout": self.timeout,
         }
 
-        # Add API key if provided
         if self.api_key:
             kwargs["api_key"] = self.api_key
 
-        # Add base_url if provided
         if self.base_url:
             kwargs["api_base"] = self.base_url
 
-        # Add extra parameters
         kwargs.update(self.extra_params)
 
         try:
-            # Use litellm's async completion function
             response = await acompletion(**kwargs)
+            self.log.debug("enrichment request", request=kwargs, response=response)
             return (
                 response.model_dump() if hasattr(response, "model_dump") else response
             )
@@ -108,30 +97,31 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
         """Enrich a list of requests using LiteLLM.
 
         Args:
-            requests: List of enrichment requests.
+            requests: List of generic enrichment requests.
 
         Yields:
-            Enrichment responses as they are processed.
+            Generic enrichment responses as they are processed.
 
         """
         if not requests:
             self.log.warning("No requests for enrichment")
             return
 
-        # Process requests in parallel with a semaphore to limit concurrent requests
         sem = asyncio.Semaphore(self.num_parallel_tasks)
 
-        async def process_request(request: EnrichmentRequest) -> EnrichmentResponse:
+        async def process_request(
+            request: EnrichmentRequest,
+        ) -> EnrichmentResponse:
             async with sem:
                 if not request.text:
                     return EnrichmentResponse(
-                        snippet_id=request.snippet_id,
+                        id=request.id,
                         text="",
                     )
                 messages = [
                     {
                         "role": "system",
-                        "content": ENRICHMENT_SYSTEM_PROMPT,
+                        "content": request.system_prompt,
                     },
                     {"role": "user", "content": request.text},
                 ]
@@ -141,22 +131,19 @@ class LiteLLMEnrichmentProvider(EnrichmentProvider):
                     .get("message", {})
                     .get("content", "")
                 )
-                # Remove thinking tags from the response
                 cleaned_content = clean_thinking_tags(content or "")
                 return EnrichmentResponse(
-                    snippet_id=request.snippet_id,
+                    id=request.id,
                     text=cleaned_content,
                 )
 
-        # Create tasks for all requests
         tasks = [process_request(request) for request in requests]
 
-        # Process all requests and yield results as they complete
         for task in asyncio.as_completed(tasks):
             yield await task
 
     async def close(self) -> None:
-        """Close the provider and cleanup HTTPX client if using Unix sockets."""
+        """Close the enricher and cleanup HTTPX client if using Unix sockets."""
         if (
             self.socket_path
             and hasattr(litellm, "aclient_session")