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

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

@@ -0,0 +1,352 @@
+"""Commit management router for the REST API."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from kodit.infrastructure.api.middleware.auth import api_key_auth
+from kodit.infrastructure.api.v1.dependencies import (
+    GitCommitRepositoryDep,
+    ServerFactoryDep,
+)
+from kodit.infrastructure.api.v1.schemas.commit import (
+    CommitAttributes,
+    CommitData,
+    CommitListResponse,
+    CommitResponse,
+    EmbeddingAttributes,
+    EmbeddingData,
+    EmbeddingListResponse,
+    FileAttributes,
+    FileData,
+    FileListResponse,
+    FileResponse,
+)
+from kodit.infrastructure.api.v1.schemas.enrichment import (
+    EnrichmentAttributes,
+    EnrichmentData,
+    EnrichmentListResponse,
+)
+from kodit.infrastructure.api.v1.schemas.snippet import (
+    EnrichmentSchema,
+    GitFileSchema,
+    SnippetAttributes,
+    SnippetContentSchema,
+    SnippetData,
+    SnippetListResponse,
+)
+
+router = APIRouter(
+    prefix="/api/v1/repositories",
+    tags=["commits"],
+    dependencies=[Depends(api_key_auth)],
+    responses={
+        401: {"description": "Unauthorized"},
+        422: {"description": "Invalid request"},
+    },
+)
+
+
+@router.get("/{repo_id}/commits", summary="List repository commits")
+async def list_repository_commits(
+    repo_id: str, git_commit_repository: GitCommitRepositoryDep
+) -> CommitListResponse:
+    """List all commits for a repository."""
+    try:
+        # Get all commits for the repository directly from commit repository
+        commits = await git_commit_repository.get_by_repo_id(int(repo_id))
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail="Repository not found") from e
+
+    return CommitListResponse(
+        data=[
+            CommitData(
+                type="commit",
+                id=commit.commit_sha,
+                attributes=CommitAttributes(
+                    commit_sha=commit.commit_sha,
+                    date=commit.date,
+                    message=commit.message,
+                    parent_commit_sha=commit.parent_commit_sha or "",
+                    author=commit.author,
+                ),
+            )
+            for commit in commits
+        ]
+    )
+
+
+@router.get(
+    "/{repo_id}/commits/{commit_sha}",
+    summary="Get repository commit",
+    responses={404: {"description": "Repository or commit not found"}},
+)
+async def get_repository_commit(
+    repo_id: str,  # noqa: ARG001
+    commit_sha: str,
+    git_commit_repository: GitCommitRepositoryDep,
+) -> CommitResponse:
+    """Get a specific commit for a repository."""
+    try:
+        # Get the specific commit directly from commit repository
+        commit = await git_commit_repository.get_by_sha(commit_sha)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail="Commit not found") from e
+
+    return CommitResponse(
+        data=CommitData(
+            type="commit",
+            id=commit.commit_sha,
+            attributes=CommitAttributes(
+                commit_sha=commit.commit_sha,
+                date=commit.date,
+                message=commit.message,
+                parent_commit_sha=commit.parent_commit_sha or "",
+                author=commit.author,
+            ),
+        )
+    )
+
+
+@router.get("/{repo_id}/commits/{commit_sha}/files", summary="List commit files")
+async def list_commit_files(
+    repo_id: str,  # noqa: ARG001
+    commit_sha: str,
+    git_commit_repository: GitCommitRepositoryDep,
+) -> FileListResponse:
+    """List all files in a specific commit."""
+    try:
+        # Get the specific commit directly from commit repository
+        commit = await git_commit_repository.get_by_sha(commit_sha)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail="Commit not found") from e
+
+    return FileListResponse(
+        data=[
+            FileData(
+                type="file",
+                id=file.blob_sha,
+                attributes=FileAttributes(
+                    blob_sha=file.blob_sha,
+                    path=file.path,
+                    mime_type=file.mime_type,
+                    size=file.size,
+                    extension=file.extension,
+                ),
+            )
+            for file in commit.files
+        ]
+    )
+
+
+@router.get(
+    "/{repo_id}/commits/{commit_sha}/files/{blob_sha}",
+    summary="Get commit file",
+    responses={404: {"description": "Repository, commit or file not found"}},
+)
+async def get_commit_file(
+    repo_id: str,  # noqa: ARG001
+    commit_sha: str,
+    blob_sha: str,
+    git_commit_repository: GitCommitRepositoryDep,
+) -> FileResponse:
+    """Get a specific file from a commit."""
+    try:
+        # Get the specific commit directly from commit repository
+        commit = await git_commit_repository.get_by_sha(commit_sha)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail="Commit not found") from e
+
+    # Find the specific file
+    file = next((f for f in commit.files if f.blob_sha == blob_sha), None)
+    if not file:
+        raise HTTPException(status_code=404, detail="File not found")
+
+    return FileResponse(
+        data=FileData(
+            type="file",
+            id=file.blob_sha,
+            attributes=FileAttributes(
+                blob_sha=file.blob_sha,
+                path=file.path,
+                mime_type=file.mime_type,
+                size=file.size,
+                extension=file.extension,
+            ),
+        )
+    )
+
+
+@router.get(
+    "/{repo_id}/commits/{commit_sha}/snippets",
+    summary="List commit snippets",
+    responses={404: {"description": "Repository or commit not found"}},
+)
+async def list_commit_snippets(
+    repo_id: str,
+    commit_sha: str,
+    server_factory: ServerFactoryDep,
+) -> SnippetListResponse:
+    """List all snippets in a specific commit."""
+    _ = repo_id  # Required by FastAPI route path but not used in function
+    snippet_repository = server_factory.snippet_v2_repository()
+    snippets = await snippet_repository.get_snippets_for_commit(commit_sha)
+
+    return SnippetListResponse(
+        data=[
+            SnippetData(
+                type="snippet",
+                id=snippet.sha,
+                attributes=SnippetAttributes(
+                    created_at=snippet.created_at,
+                    updated_at=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 snippet.derives_from
+                    ],
+                    content=SnippetContentSchema(
+                        value=snippet.content,
+                        language=snippet.extension,
+                    ),
+                    enrichments=[
+                        EnrichmentSchema(
+                            type=enrichment.type.value,
+                            content=enrichment.content,
+                        )
+                        for enrichment in snippet.enrichments
+                    ],
+                ),
+            )
+            for snippet in snippets
+        ]
+    )
+
+
+# TODO(Phil): This doesn't return vectorchord embeddings properly because it's
+# implemented in a different repo
+@router.get(
+    "/{repo_id}/commits/{commit_sha}/embeddings",
+    summary="List commit embeddings",
+    responses={404: {"description": "Repository or commit not found"}},
+)
+async def list_commit_embeddings(
+    repo_id: str,
+    commit_sha: str,
+    server_factory: ServerFactoryDep,
+    full: Annotated[  # noqa: FBT002
+        bool,
+        Query(
+            description="If true, return full vectors. If false, return first 5 values."
+        ),
+    ] = False,
+) -> EmbeddingListResponse:
+    """List all embeddings for snippets in a specific commit."""
+    _ = repo_id  # Required by FastAPI route path but not used in function
+    snippet_repository = server_factory.snippet_v2_repository()
+    snippets = await snippet_repository.get_snippets_for_commit(commit_sha)
+
+    if not snippets:
+        return EmbeddingListResponse(data=[])
+
+    # Get snippet SHAs
+    snippet_shas = [snippet.sha for snippet in snippets]
+
+    # Get embeddings for all snippets in the commit
+    embedding_repository = server_factory.embedding_repository()
+    embeddings = await embedding_repository.get_embeddings_by_snippet_ids(snippet_shas)
+
+    return EmbeddingListResponse(
+        data=[
+            EmbeddingData(
+                type="embedding",
+                id=f"{embedding.snippet_id}_{embedding.type.value}",
+                attributes=EmbeddingAttributes(
+                    snippet_sha=embedding.snippet_id,
+                    embedding_type=embedding.type.name.lower(),
+                    embedding=embedding.embedding if full else embedding.embedding[:5],
+                ),
+            )
+            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/queue.py

@@ -2,7 +2,7 @@
 
 from fastapi import APIRouter, Depends, HTTPException
 
-from kodit.domain.value_objects import TaskType
+from kodit.domain.value_objects import TaskOperation
 from kodit.infrastructure.api.middleware.auth import api_key_auth
 from kodit.infrastructure.api.v1.dependencies import QueueServiceDep
 from kodit.infrastructure.api.v1.schemas.queue import (
@@ -26,7 +26,7 @@ router = APIRouter(
 @router.get("")
 async def list_queue_tasks(
     queue_service: QueueServiceDep,
-    task_type: TaskType | None = None,
+    task_type: TaskOperation | None = None,
 ) -> TaskListResponse:
     """List all tasks in the queue.
 

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