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

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

@@ -0,0 +1,282 @@
+"""Repository management router for the REST API."""
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from kodit.infrastructure.api.middleware.auth import api_key_auth
+from kodit.infrastructure.api.v1.dependencies import (
+    CommitIndexingAppServiceDep,
+    GitBranchRepositoryDep,
+    GitCommitRepositoryDep,
+    GitRepositoryDep,
+    GitTagRepositoryDep,
+    TaskStatusQueryServiceDep,
+)
+from kodit.infrastructure.api.v1.schemas.repository import (
+    RepositoryBranchData,
+    RepositoryCommitData,
+    RepositoryCreateRequest,
+    RepositoryData,
+    RepositoryDetailsResponse,
+    RepositoryListResponse,
+    RepositoryResponse,
+)
+from kodit.infrastructure.api.v1.schemas.tag import (
+    TagAttributes,
+    TagData,
+    TagListResponse,
+    TagResponse,
+)
+from kodit.infrastructure.api.v1.schemas.task_status import (
+    TaskStatusAttributes,
+    TaskStatusData,
+    TaskStatusListResponse,
+)
+
+router = APIRouter(
+    prefix="/api/v1/repositories",
+    tags=["repositories"],
+    dependencies=[Depends(api_key_auth)],
+    responses={
+        401: {"description": "Unauthorized"},
+        422: {"description": "Invalid request"},
+    },
+)
+
+
+def _raise_not_found_error(detail: str) -> None:
+    """Raise repository not found error."""
+    raise HTTPException(status_code=404, detail=detail)
+
+
+@router.get("", summary="List repositories")
+async def list_repositories(
+    git_repository: GitRepositoryDep,
+) -> RepositoryListResponse:
+    """List all cloned repositories."""
+    repos = await git_repository.get_all()
+    return RepositoryListResponse(
+        data=[RepositoryData.from_git_repo(repo) for repo in repos]
+    )
+
+
+@router.post("", status_code=201, summary="Create repository")
+async def create_repository(
+    request: RepositoryCreateRequest,
+    service: CommitIndexingAppServiceDep,
+) -> RepositoryResponse:
+    """Clone a new repository and perform initial mapping."""
+    try:
+        remote_uri = request.data.attributes.remote_uri
+
+        repo = await service.create_git_repository(remote_uri)
+
+        return RepositoryResponse(data=RepositoryData.from_git_repo(repo))
+    except ValueError as e:
+        if "already exists" in str(e):
+            raise HTTPException(status_code=409, detail=str(e)) from e
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    except Exception as e:
+        msg = f"Failed to clone repository: {e}"
+        raise HTTPException(status_code=500, detail=msg) from e
+
+
+@router.get(
+    "/{repo_id}",
+    summary="Get repository",
+    responses={404: {"description": "Repository not found"}},
+)
+async def get_repository(
+    repo_id: str,
+    git_repository: GitRepositoryDep,
+    git_commit_repository: GitCommitRepositoryDep,
+    git_branch_repository: GitBranchRepositoryDep,
+) -> RepositoryDetailsResponse:
+    """Get repository details including branches and recent commits."""
+    repo = await git_repository.get_by_id(int(repo_id))
+    if not repo:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    # Get all commits for this repository from the commit repository
+    repo_commits = await git_commit_repository.get_by_repo_id(int(repo_id))
+    commits_by_sha = {commit.commit_sha: commit for commit in repo_commits}
+
+    # Get recent commits from the tracking branch's head commit
+    recent_commits = []
+    if repo.tracking_branch and repo.tracking_branch.head_commit:
+        # For simplicity, just show the head commit and traverse back if needed
+        current_commit = repo.tracking_branch.head_commit
+        recent_commits = [current_commit]
+
+        # Traverse parent commits for more recent commits (up to 10)
+        current_sha = current_commit.parent_commit_sha
+        while current_sha and len(recent_commits) < 10:
+            parent_commit = commits_by_sha.get(current_sha)
+            if parent_commit:
+                recent_commits.append(parent_commit)
+                current_sha = parent_commit.parent_commit_sha
+            else:
+                break
+
+    # Get commit count for the repository using the commit repository
+    commit_count = await git_commit_repository.count_by_repo_id(int(repo_id))
+
+    # Get branches for the repository using the branch repository
+    repo_branches = await git_branch_repository.get_by_repo_id(int(repo_id))
+
+    # Get commit counts for all branches using the commit repository
+    branch_data = []
+    for branch in repo_branches:
+        # For simplicity, use the total commit count for all branches
+        # In a more advanced implementation, we would traverse each branch's history
+        branch_commit_count = commit_count
+
+        branch_data.append(
+            RepositoryBranchData(
+                name=branch.name,
+                is_default=branch.name == repo.tracking_branch.name
+                if repo.tracking_branch
+                else False,
+                commit_count=branch_commit_count,
+            )
+        )
+
+    return RepositoryDetailsResponse(
+        data=RepositoryData.from_git_repo(repo),
+        branches=branch_data,
+        recent_commits=[
+            RepositoryCommitData(
+                sha=commit.commit_sha,
+                message=commit.message,
+                author=commit.author,
+                timestamp=commit.date,
+            )
+            for commit in recent_commits
+        ],
+    )
+
+
+@router.get(
+    "/{repo_id}/status",
+    responses={404: {"description": "Index not found"}},
+)
+async def get_index_status(
+    repo_id: int,
+    status_service: TaskStatusQueryServiceDep,
+) -> TaskStatusListResponse:
+    """Get the status of tasks for an index."""
+    # Get all task statuses for this index
+    progress_trackers = await status_service.get_index_status(repo_id)
+
+    # Convert progress trackers to API response format
+    task_statuses = []
+    for _i, status in enumerate(progress_trackers):
+        task_statuses.append(
+            TaskStatusData(
+                id=status.id,
+                attributes=TaskStatusAttributes(
+                    step=status.operation,
+                    state=status.state,
+                    progress=status.completion_percent,
+                    total=status.total,
+                    current=status.current,
+                    created_at=status.created_at,
+                    updated_at=status.updated_at,
+                    error=status.error or "",
+                    message=status.message,
+                ),
+            )
+        )
+
+    return TaskStatusListResponse(data=task_statuses)
+
+
+@router.get(
+    "/{repo_id}/tags",
+    summary="List repository tags",
+    responses={404: {"description": "Repository not found"}},
+)
+async def list_repository_tags(
+    repo_id: str,
+    git_repository: GitRepositoryDep,
+    git_tag_repository: GitTagRepositoryDep,
+) -> TagListResponse:
+    """List all tags for a repository."""
+    repo = await git_repository.get_by_id(int(repo_id))
+    if not repo:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    # Tags are now stored in a dedicated repository
+    tags = await git_tag_repository.get_by_repo_id(int(repo_id))
+
+    return TagListResponse(
+        data=[
+            TagData(
+                type="tag",
+                id=tag.id,
+                attributes=TagAttributes(
+                    name=tag.name,
+                    target_commit_sha=tag.target_commit.commit_sha,
+                    is_version_tag=tag.is_version_tag,
+                ),
+            )
+            for tag in tags
+        ]
+    )
+
+
+@router.get(
+    "/{repo_id}/tags/{tag_id}",
+    summary="Get repository tag",
+    responses={404: {"description": "Repository or tag not found"}},
+)
+async def get_repository_tag(
+    repo_id: str,
+    tag_id: str,
+    git_repository: GitRepositoryDep,
+    git_tag_repository: GitTagRepositoryDep,
+) -> TagResponse:
+    """Get a specific tag for a repository."""
+    repo = await git_repository.get_by_id(int(repo_id))
+    if not repo:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    # Get all tags and find the specific one by ID
+    tags = await git_tag_repository.get_by_repo_id(int(repo_id))
+    tag = next((t for t in tags if t.id == tag_id), None)
+    if not tag:
+        raise HTTPException(status_code=404, detail="Tag not found")
+
+    return TagResponse(
+        data=TagData(
+            type="tag",
+            id=tag.id,
+            attributes=TagAttributes(
+                name=tag.name,
+                target_commit_sha=tag.target_commit.commit_sha,
+                is_version_tag=tag.is_version_tag,
+            ),
+        )
+    )
+
+
+@router.delete(
+    "/{repo_id}",
+    status_code=204,
+    summary="Delete repository",
+    responses={404: {"description": "Repository not found"}},
+)
+async def delete_repository(
+    repo_id: str,
+    service: CommitIndexingAppServiceDep,
+) -> None:
+    """Delete a repository and all its associated data."""
+    try:
+        repo_id_int = int(repo_id)
+        deleted = await service.delete_git_repository(repo_id_int)
+        if not deleted:
+            _raise_not_found_error("Repository not found")
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid repository ID") from None
+    except Exception as e:
+        msg = f"Failed to delete repository: {e}"
+        raise HTTPException(status_code=500, detail=msg) from e

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

@@ -3,15 +3,18 @@
 from fastapi import APIRouter
 
 from kodit.domain.value_objects import MultiSearchRequest, SnippetSearchFilters
-from kodit.infrastructure.api.v1.dependencies import (
-    IndexingAppServiceDep,
-)
+from kodit.infrastructure.api.v1.dependencies import CodeSearchAppServiceDep
 from kodit.infrastructure.api.v1.schemas.search import (
     SearchRequest,
     SearchResponse,
     SnippetAttributes,
     SnippetData,
 )
+from kodit.infrastructure.api.v1.schemas.snippet import (
+    EnrichmentSchema,
+    GitFileSchema,
+    SnippetContentSchema,
+)
 
 router = APIRouter(tags=["search"])
 
@@ -19,7 +22,7 @@ router = APIRouter(tags=["search"])
 @router.post("/api/v1/search")
 async def search_snippets(
     request: SearchRequest,
-    app_service: IndexingAppServiceDep,
+    search_application_service: CodeSearchAppServiceDep,
 ) -> SearchResponse:
     """Search code snippets with filters matching MCP tool."""
     # Convert API request to domain request
@@ -50,23 +53,37 @@ async def search_snippets(
     )
 
     # Execute search using application service
-    results = await app_service.search(domain_request)
+    results = await search_application_service.search(domain_request)
 
     return SearchResponse(
         data=[
             SnippetData(
                 type="snippet",
-                id=result.id,
+                id=result.snippet.id,
                 attributes=SnippetAttributes(
-                    content=result.content,
-                    created_at=result.created_at,
-                    updated_at=result.created_at,  # Use created_at as fallback
+                    created_at=result.snippet.created_at,
+                    updated_at=result.snippet.updated_at,
+                    derives_from=[
+                        GitFileSchema(
+                            blob_sha=file.blob_sha,
+                            path=file.path,
+                            mime_type=file.mime_type,
+                            size=file.size,
+                        )
+                        for file in result.snippet.derives_from
+                    ],
+                    content=SnippetContentSchema(
+                        value=result.snippet.content,
+                        language=result.snippet.extension,
+                    ),
+                    enrichments=[
+                        EnrichmentSchema(
+                            type=enrichment.type.value,
+                            content=enrichment.content,
+                        )
+                        for enrichment in result.snippet.enrichments
+                    ],
                     original_scores=result.original_scores,
-                    source_uri=result.source_uri,
-                    relative_path=result.relative_path,
-                    language=result.language,
-                    authors=result.authors,
-                    summary=result.summary,
                 ),
             )
             for result in results

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

@@ -1,25 +1 @@
 """JSON:API schemas for the REST API."""
-
-from .index import (
-    IndexCreateRequest,
-    IndexDetailResponse,
-    IndexListResponse,
-    IndexResponse,
-)
-from .search import (
-    SearchRequest,
-    SearchResponse,
-    SearchResponseWithIncluded,
-    SnippetDetailResponse,
-)
-
-__all__ = [
-    "IndexCreateRequest",
-    "IndexDetailResponse",
-    "IndexListResponse",
-    "IndexResponse",
-    "SearchRequest",
-    "SearchResponse",
-    "SearchResponseWithIncluded",
-    "SnippetDetailResponse",
-]

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

@@ -0,0 +1,96 @@
+"""Commit JSON-API schemas."""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class GitFileData(BaseModel):
+    """Git file data."""
+
+    blob_sha: str
+    path: str
+    mime_type: str
+    size: int
+
+
+class CommitAttributes(BaseModel):
+    """Commit attributes following JSON-API spec."""
+
+    commit_sha: str
+    date: datetime
+    message: str
+    parent_commit_sha: str
+    author: str
+
+
+class CommitData(BaseModel):
+    """Commit data following JSON-API spec."""
+
+    type: str = "commit"
+    id: str
+    attributes: CommitAttributes
+
+
+class CommitResponse(BaseModel):
+    """Single commit response following JSON-API spec."""
+
+    data: CommitData
+
+
+class CommitListResponse(BaseModel):
+    """Commit list response following JSON-API spec."""
+
+    data: list[CommitData]
+
+
+class FileAttributes(BaseModel):
+    """File attributes following JSON-API spec."""
+
+    blob_sha: str
+    path: str
+    mime_type: str
+    size: int
+    extension: str
+
+
+class FileData(BaseModel):
+    """File data following JSON-API spec."""
+
+    type: str = "file"
+    id: str
+    attributes: FileAttributes
+
+
+class FileResponse(BaseModel):
+    """Single file response following JSON-API spec."""
+
+    data: FileData
+
+
+class FileListResponse(BaseModel):
+    """File list response following JSON-API spec."""
+
+    data: list[FileData]
+
+
+class EmbeddingAttributes(BaseModel):
+    """Embedding attributes following JSON-API spec."""
+
+    snippet_sha: str
+    embedding_type: str
+    embedding: list[float]
+
+
+class EmbeddingData(BaseModel):
+    """Embedding data following JSON-API spec."""
+
+    type: str = "embedding"
+    id: str
+    attributes: EmbeddingAttributes
+
+
+class EmbeddingListResponse(BaseModel):
+    """Embedding list response following JSON-API spec."""
+
+    data: list[EmbeddingData]

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

@@ -2,6 +2,7 @@
 
 from typing import TypedDict
 
+from kodit.application.factories.server_factory import ServerFactory
 from kodit.config import AppContext
 
 
@@ -9,3 +10,4 @@ class AppLifespanState(TypedDict):
     """Application lifespan state."""
 
     app_context: AppContext
+    server_factory: ServerFactory

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

@@ -0,0 +1,128 @@
+"""Repository JSON-API schemas."""
+
+from datetime import datetime
+from pathlib import Path
+
+from pydantic import AnyUrl, BaseModel
+
+from kodit.domain.entities.git import GitRepo
+
+
+class RepositoryAttributes(BaseModel):
+    """Repository attributes following JSON-API spec."""
+
+    remote_uri: AnyUrl
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+    last_scanned_at: datetime | None = None
+    cloned_path: Path | None = None
+    tracking_branch: str | None = None
+    num_commits: int = 0
+    num_branches: int = 0
+    num_tags: int = 0
+
+    @staticmethod
+    def from_git_repo(repo: GitRepo) -> "RepositoryAttributes":
+        """Create a repository attributes from a Git repository."""
+        return RepositoryAttributes(
+            remote_uri=repo.sanitized_remote_uri,
+            cloned_path=repo.cloned_path,
+            created_at=repo.created_at,
+            updated_at=repo.updated_at,
+            last_scanned_at=repo.last_scanned_at,
+            tracking_branch=repo.tracking_branch.name if repo.tracking_branch else None,
+            num_commits=repo.num_commits,
+            num_branches=repo.num_branches,
+            num_tags=repo.num_tags,
+        )
+
+
+class RepositoryData(BaseModel):
+    """Repository data following JSON-API spec."""
+
+    type: str = "repository"
+    id: str
+    attributes: RepositoryAttributes
+
+    @staticmethod
+    def from_git_repo(repo: GitRepo) -> "RepositoryData":
+        """Create a repository data from a Git repository."""
+        return RepositoryData(
+            id=str(repo.id) or "",
+            attributes=RepositoryAttributes.from_git_repo(repo),
+        )
+
+
+class RepositoryResponse(BaseModel):
+    """Single repository response following JSON-API spec."""
+
+    data: RepositoryData
+
+
+class RepositoryListResponse(BaseModel):
+    """Repository list response following JSON-API spec."""
+
+    data: list[RepositoryData]
+
+
+class RepositoryCreateAttributes(BaseModel):
+    """Repository creation attributes."""
+
+    remote_uri: AnyUrl
+
+
+class RepositoryCreateData(BaseModel):
+    """Repository creation data."""
+
+    type: str = "repository"
+    attributes: RepositoryCreateAttributes
+
+
+class RepositoryCreateRequest(BaseModel):
+    """Repository creation request."""
+
+    data: RepositoryCreateData
+
+
+class RepositoryUpdateAttributes(BaseModel):
+    """Repository update attributes."""
+
+    pull_latest: bool = False
+
+
+class RepositoryUpdateData(BaseModel):
+    """Repository update data."""
+
+    type: str = "repository"
+    attributes: RepositoryUpdateAttributes
+
+
+class RepositoryUpdateRequest(BaseModel):
+    """Repository update request."""
+
+    data: RepositoryUpdateData
+
+
+class RepositoryBranchData(BaseModel):
+    """Repository branch data."""
+
+    name: str
+    is_default: bool
+    commit_count: int
+
+
+class RepositoryCommitData(BaseModel):
+    """Repository commit data for repository details."""
+
+    sha: str
+    message: str
+    author: str
+    timestamp: datetime
+
+
+class RepositoryDetailsResponse(BaseModel):
+    """Repository details response with branches and commits."""
+
+    data: RepositoryData
+    branches: list[RepositoryBranchData]
+    recent_commits: list[RepositoryCommitData]

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

@@ -4,6 +4,12 @@ from datetime import datetime
 
 from pydantic import BaseModel, Field
 
+from kodit.infrastructure.api.v1.schemas.snippet import (
+    EnrichmentSchema,
+    GitFileSchema,
+    SnippetContentSchema,
+)
+
 
 class SearchFilters(BaseModel):
     """Search filters for JSON:API requests."""
@@ -111,22 +117,19 @@ class SearchRequest(BaseModel):
 class SnippetAttributes(BaseModel):
     """Snippet attributes for JSON:API responses."""
 
-    content: str
-    created_at: datetime
-    updated_at: datetime
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+    derives_from: list[GitFileSchema]
+    content: SnippetContentSchema
+    enrichments: list[EnrichmentSchema]
     original_scores: list[float]
-    source_uri: str
-    relative_path: str
-    language: str
-    authors: list[str]
-    summary: str
 
 
 class SnippetData(BaseModel):
     """Snippet data for JSON:API responses."""
 
     type: str = "snippet"
-    id: int
+    id: str
     attributes: SnippetAttributes