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

kodit/infrastructure/api/client/__init__.py

@@ -2,13 +2,11 @@
 
 from .base import BaseAPIClient
 from .exceptions import AuthenticationError, KoditAPIError
-from .index_client import IndexClient
 from .search_client import SearchClient
 
 __all__ = [
     "AuthenticationError",
     "BaseAPIClient",
-    "IndexClient",
     "KoditAPIError",
     "SearchClient",
 ]

kodit/infrastructure/api/v1/__init__.py

@@ -1,5 +1 @@
 """API v1 modules."""
-
-from .routers import indexes_router, queue_router, search_router
-
-__all__ = ["indexes_router", "queue_router", "search_router"]

kodit/infrastructure/api/v1/dependencies.py

@@ -1,22 +1,30 @@
 """FastAPI dependencies for the REST API."""
 
-from collections.abc import AsyncGenerator, Callable
+from collections.abc import Callable
 from typing import Annotated, cast
 
 from fastapi import Depends, Request
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.application.factories.code_indexing_factory import (
-    create_server_code_indexing_application_service,
+from kodit.application.factories.server_factory import ServerFactory
+from kodit.application.services.code_search_application_service import (
+    CodeSearchApplicationService,
 )
-from kodit.application.services.code_indexing_application_service import (
-    CodeIndexingApplicationService,
+from kodit.application.services.commit_indexing_application_service import (
+    CommitIndexingApplicationService,
 )
 from kodit.application.services.queue_service import QueueService
 from kodit.config import AppContext
-from kodit.domain.services.index_query_service import IndexQueryService
-from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
-from kodit.infrastructure.sqlalchemy.index_repository import create_index_repository
+from kodit.domain.protocols import (
+    GitBranchRepository,
+    GitCommitRepository,
+    GitRepoRepository,
+    GitTagRepository,
+)
+from kodit.domain.services.task_status_query_service import TaskStatusQueryService
+from kodit.infrastructure.sqlalchemy.task_status_repository import (
+    create_task_status_repository,
+)
 
 
 def get_app_context(request: Request) -> AppContext:
@@ -30,24 +38,22 @@ def get_app_context(request: Request) -> AppContext:
 AppContextDep = Annotated[AppContext, Depends(get_app_context)]
 
 
-async def get_db_session(
-    app_context: AppContextDep,
-) -> AsyncGenerator[AsyncSession, None]:
-    """Get database session dependency."""
-    db = await app_context.get_db()
-    async with db.session_factory() as session:
-        yield session
+def get_server_factory(request: Request) -> ServerFactory:
+    """Get the server factory dependency."""
+    server_factory = cast("ServerFactory", request.state.server_factory)
+    if server_factory is None:
+        raise RuntimeError("Server factory not initialized")
+    return server_factory
 
 
-DBSessionDep = Annotated[AsyncSession, Depends(get_db_session)]
+ServerFactoryDep = Annotated[ServerFactory, Depends(get_server_factory)]
 
 
 async def get_db_session_factory(
-    app_context: AppContextDep,
-) -> AsyncGenerator[Callable[[], AsyncSession], None]:
+    server_factory: ServerFactoryDep,
+) -> Callable[[], AsyncSession]:
     """Get database session dependency."""
-    db = await app_context.get_db()
-    yield db.session_factory
+    return server_factory.session_factory
 
 
 DBSessionFactoryDep = Annotated[
@@ -55,42 +61,97 @@ DBSessionFactoryDep = Annotated[
 ]
 
 
-async def get_index_query_service(
+async def get_queue_service(
     session_factory: DBSessionFactoryDep,
-) -> IndexQueryService:
-    """Get index query service dependency."""
-    return IndexQueryService(
-        index_repository=create_index_repository(session_factory=session_factory),
-        fusion_service=ReciprocalRankFusionService(),
+) -> QueueService:
+    """Get queue service dependency."""
+    return QueueService(
+        session_factory=session_factory,
     )
 
 
-IndexQueryServiceDep = Annotated[IndexQueryService, Depends(get_index_query_service)]
+QueueServiceDep = Annotated[QueueService, Depends(get_queue_service)]
 
 
-async def get_indexing_app_service(
-    app_context: AppContextDep,
-    session: DBSessionDep,
+async def get_task_status_query_service(
     session_factory: DBSessionFactoryDep,
-) -> CodeIndexingApplicationService:
-    """Get indexing application service dependency."""
-    return create_server_code_indexing_application_service(
-        app_context, session, session_factory
+) -> TaskStatusQueryService:
+    """Get task status query service dependency."""
+    return TaskStatusQueryService(
+        repository=create_task_status_repository(session_factory=session_factory)
     )
 
 
-IndexingAppServiceDep = Annotated[
-    CodeIndexingApplicationService, Depends(get_indexing_app_service)
+TaskStatusQueryServiceDep = Annotated[
+    TaskStatusQueryService, Depends(get_task_status_query_service)
 ]
 
 
-async def get_queue_service(
-    session_factory: DBSessionFactoryDep,
-) -> QueueService:
-    """Get queue service dependency."""
-    return QueueService(
-        session_factory=session_factory,
-    )
+async def get_git_repository(
+    server_factory: ServerFactoryDep,
+) -> GitRepoRepository:
+    """Get git repository dependency."""
+    return server_factory.repo_repository()
 
 
-QueueServiceDep = Annotated[QueueService, Depends(get_queue_service)]
+GitRepositoryDep = Annotated[GitRepoRepository, Depends(get_git_repository)]
+
+
+async def get_git_commit_repository(
+    server_factory: ServerFactoryDep,
+) -> GitCommitRepository:
+    """Get git commit repository dependency."""
+    return server_factory.git_commit_repository()
+
+
+GitCommitRepositoryDep = Annotated[
+    GitCommitRepository, Depends(get_git_commit_repository)
+]
+
+
+async def get_git_branch_repository(
+    server_factory: ServerFactoryDep,
+) -> GitBranchRepository:
+    """Get git branch repository dependency."""
+    return server_factory.git_branch_repository()
+
+
+GitBranchRepositoryDep = Annotated[
+    GitBranchRepository, Depends(get_git_branch_repository)
+]
+
+
+async def get_git_tag_repository(
+    server_factory: ServerFactoryDep,
+) -> GitTagRepository:
+    """Get git tag repository dependency."""
+    return server_factory.git_tag_repository()
+
+
+GitTagRepositoryDep = Annotated[
+    GitTagRepository, Depends(get_git_tag_repository)
+]
+
+
+async def get_commit_indexing_app_service(
+    server_factory: ServerFactoryDep,
+) -> CommitIndexingApplicationService:
+    """Get commit indexing application service dependency."""
+    return server_factory.commit_indexing_application_service()
+
+
+CommitIndexingAppServiceDep = Annotated[
+    CommitIndexingApplicationService, Depends(get_commit_indexing_app_service)
+]
+
+
+async def get_code_search_app_service(
+    server_factory: ServerFactoryDep,
+) -> CodeSearchApplicationService:
+    """Get code search application service dependency."""
+    return server_factory.code_search_application_service()
+
+
+CodeSearchAppServiceDep = Annotated[
+    CodeSearchApplicationService, Depends(get_code_search_app_service)
+]

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

@@ -1,7 +1 @@
 """API v1 routers."""
-
-from .indexes import router as indexes_router
-from .queue import router as queue_router
-from .search import router as search_router
-
-__all__ = ["indexes_router", "queue_router", "search_router"]

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

@@ -0,0 +1,271 @@
+"""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.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
+        ]
+    )

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.