kodit 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.10'
-__version_tuple__ = version_tuple = (0, 3, 10)
+__version__ = version = '0.3.12'
+__version_tuple__ = version_tuple = (0, 3, 12)

kodit/app.py

@@ -4,11 +4,15 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 
 from asgi_correlation_id import CorrelationIdMiddleware
-from fastapi import FastAPI
+from fastapi import FastAPI, Response
+from fastapi.responses import RedirectResponse
 
+from kodit._version import version
+from kodit.application.services.auto_indexing_service import AutoIndexingService
 from kodit.application.services.sync_scheduler import SyncSchedulerService
 from kodit.config import AppContext
-from kodit.infrastructure.indexing.auto_indexing_service import AutoIndexingService
+from kodit.infrastructure.api.v1.routers import indexes_router, search_router
+from kodit.infrastructure.api.v1.schemas.context import AppLifespanState
 from kodit.mcp import mcp
 from kodit.middleware import ASGICancelledErrorMiddleware, logging_middleware
 
@@ -18,7 +22,7 @@ _sync_scheduler_service: SyncSchedulerService | None = None
 
 
 @asynccontextmanager
-async def app_lifespan(_: FastAPI) -> AsyncIterator[None]:
+async def app_lifespan(_: FastAPI) -> AsyncIterator[AppLifespanState]:
     """Manage application lifespan for auto-indexing and sync."""
     global _auto_indexing_service, _sync_scheduler_service  # noqa: PLW0603
 
@@ -42,7 +46,7 @@ async def app_lifespan(_: FastAPI) -> AsyncIterator[None]:
             interval_seconds=app_context.periodic_sync.interval_seconds
         )
 
-    yield
+    yield AppLifespanState(app_context=app_context)
 
     # Stop services
     if _sync_scheduler_service:
@@ -57,33 +61,49 @@ mcp_http_app = mcp.http_app(transport="http", path="/")
 
 
 @asynccontextmanager
-async def combined_lifespan(app: FastAPI) -> AsyncIterator[None]:
-    """Combine app and MCP lifespans."""
+async def combined_lifespan(app: FastAPI) -> AsyncIterator[AppLifespanState]:
+    """Combine app and MCP lifespans, yielding state from app_lifespan."""
     async with (
-        app_lifespan(app),
+        app_lifespan(app) as app_state,
         mcp_sse_app.router.lifespan_context(app),
         mcp_http_app.router.lifespan_context(app),
     ):
-        yield
+        yield app_state
 
 
-app = FastAPI(title="kodit API", lifespan=combined_lifespan)
+app = FastAPI(
+    title="kodit API",
+    lifespan=combined_lifespan,
+    responses={
+        500: {"description": "Internal server error"},
+    },
+    description="""
+This is the REST API for the Kodit server. Please refer to the
+[Kodit documentation](https://docs.helix.ml/kodit/) for more information.
+    """,
+    version=version,
+)
 
-# Add middleware
-app.middleware("http")(logging_middleware)
-app.add_middleware(CorrelationIdMiddleware)
+# Add middleware. Remember, last runs first. Order is important.
+app.middleware("http")(logging_middleware)  # Then always log
+app.add_middleware(CorrelationIdMiddleware)  # Add correlation id first.
 
 
-@app.get("/")
-async def root() -> dict[str, str]:
-    """Return a welcome message for the kodit API."""
-    return {"message": "Hello, World!"}
+@app.get("/", include_in_schema=False)
+async def root() -> RedirectResponse:
+    """Redirect to the API documentation."""
+    return RedirectResponse(url="/docs")
 
 
 @app.get("/healthz")
-async def healthz() -> dict[str, str]:
+async def healthz() -> Response:
     """Return a health check for the kodit API."""
-    return {"status": "ok"}
+    return Response(status_code=200)
+
+
+# Include API routers
+app.include_router(indexes_router)
+app.include_router(search_router)
 
 
 # Add mcp routes last, otherwise previous routes aren't added
@@ -93,4 +113,4 @@ app.mount("/mcp", mcp_http_app)
 
 # Wrap the entire app with ASGI middleware after all routes are added to suppress
 # CancelledError at the ASGI level
-app = ASGICancelledErrorMiddleware(app)  # type: ignore[assignment]
+ASGICancelledErrorMiddleware(app)

kodit/{infrastructure/indexing → application/services}/auto_indexing_service.py

@@ -11,6 +11,7 @@ from kodit.application.factories.code_indexing_factory import (
     create_code_indexing_application_service,
 )
 from kodit.config import AppContext
+from kodit.infrastructure.ui.progress import create_log_progress_callback
 
 
 class AutoIndexingService:
@@ -50,13 +51,20 @@ class AutoIndexingService:
 
             for source in sources:
                 try:
+                    # Only auto-index a source if it is new
+                    if await service.does_index_exist(source):
+                        self.log.info("Index already exists, skipping", source=source)
+                        continue
+
                     self.log.info("Auto-indexing source", source=source)
 
                     # Create index
                     index = await service.create_index_from_uri(source)
 
                     # Run indexing (without progress callback for background mode)
-                    await service.run_index(index, progress_callback=None)
+                    await service.run_index(
+                        index, progress_callback=create_log_progress_callback()
+                    )
 
                     self.log.info("Successfully auto-indexed source", source=source)
 

kodit/application/services/code_indexing_application_service.py

@@ -53,6 +53,13 @@ class CodeIndexingApplicationService:
         self.session = session
         self.log = structlog.get_logger(__name__)
 
+    async def does_index_exist(self, uri: str) -> bool:
+        """Check if an index exists for a source."""
+        # Check if index already exists
+        sanitized_uri, _ = self.index_domain_service.sanitize_uri(uri)
+        existing_index = await self.index_repository.get_by_uri(sanitized_uri)
+        return existing_index is not None
+
     async def create_index_from_uri(
         self, uri: str, progress_callback: ProgressCallback | None = None
     ) -> Index:
@@ -382,3 +389,12 @@ class CodeIndexingApplicationService:
             )
 
         await reporter.done("text_embeddings")
+
+    async def delete_index(self, index: Index) -> None:
+        """Delete an index."""
+        # Delete the index from the domain
+        await self.index_domain_service.delete_index(index)
+
+        # Delete index from the database
+        await self.index_repository.delete(index)
+        await self.session.commit()

kodit/application/services/sync_scheduler.py

@@ -14,6 +14,7 @@ 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 SqlAlchemyIndexRepository
+from kodit.infrastructure.ui.progress import create_log_progress_callback
 
 
 class SyncSchedulerService:
@@ -102,7 +103,9 @@ class SyncSchedulerService:
                         source=str(index.source.working_copy.remote_uri),
                     )
 
-                    await service.run_index(index, progress_callback=None)
+                    await service.run_index(
+                        index, progress_callback=create_log_progress_callback()
+                    )
                     success_count += 1
 
                     self.log.info(

kodit/config.py

@@ -5,13 +5,15 @@ from __future__ import annotations
 import asyncio
 from functools import wraps
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, TypeVar
+from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar
 
 import click
+import structlog
 from pydantic import BaseModel, Field, field_validator
 from pydantic_settings import (
     BaseSettings,
     EnvSettingsSource,
+    NoDecode,
     PydanticBaseSettingsSource,
     SettingsConfigDict,
 )
@@ -189,7 +191,26 @@ class AppContext(BaseSettings):
     periodic_sync: PeriodicSyncConfig = Field(
         default=PeriodicSyncConfig(), description="Periodic sync configuration"
     )
+    api_keys: Annotated[list[str], NoDecode] = Field(
+        default_factory=list,
+        description="Comma-separated list of valid API keys (e.g. 'key1,key2')",
+    )
+
+    @field_validator("api_keys", mode="before")
+    @classmethod
+    def parse_api_keys(cls, v: Any) -> list[str]:
+        """Parse API keys from CSV format."""
+        if v is None:
+            return []
+        if isinstance(v, list):
+            return v
+        if isinstance(v, str):
+            # Split by comma and strip whitespace
+            return [key.strip() for key in v.strip().split(",") if key.strip()]
+        return v
+
     _db: Database | None = None
+    _log = structlog.get_logger(__name__)
 
     def model_post_init(self, _: Any) -> None:
         """Post-initialization hook."""

kodit/domain/entities.py

@@ -1,5 +1,6 @@
 """Pure domain entities using Pydantic."""
 
+import shutil
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
@@ -193,6 +194,10 @@ class WorkingCopy(BaseModel):
         for file in self.files:
             file.file_processing_status = FileProcessingStatus.CLEAN
 
+    def delete(self) -> None:
+        """Delete the working copy."""
+        shutil.rmtree(self.cloned_path)
+
 
 class Source(BaseModel):
     """Source domain entity."""

kodit/domain/protocols.py

@@ -24,6 +24,10 @@ class IndexRepository(Protocol):
         """Get an index by ID."""
         ...
 
+    async def delete(self, index: Index) -> None:
+        """Delete an index."""
+        ...
+
     async def all(self) -> list[Index]:
         """List all indexes."""
         ...

kodit/domain/services/index_query_service.py

@@ -63,4 +63,8 @@ class IndexQueryService:
 
     async def get_snippets_by_ids(self, ids: list[int]) -> list[SnippetWithContext]:
         """Get snippets by their IDs."""
-        return await self.index_repository.get_snippets_by_ids(ids)
+        snippets = await self.index_repository.get_snippets_by_ids(ids)
+
+        # Return snippets in the same order as the ids
+        snippets.sort(key=lambda x: ids.index(x.snippet.id or 0))
+        return snippets

kodit/domain/services/index_service.py

@@ -13,6 +13,7 @@ from kodit.domain.services.enrichment_service import EnrichmentDomainService
 from kodit.domain.value_objects import (
     EnrichmentIndexRequest,
     EnrichmentRequest,
+    FileProcessingStatus,
     LanguageMapping,
 )
 from kodit.infrastructure.cloning.git.working_copy import GitWorkingCopyProvider
@@ -103,6 +104,11 @@ class IndexDomainService:
         files = index.source.working_copy.changed_files()
         index.delete_snippets_for_files(files)
 
+        # Filter out deleted files - they don't exist on disk anymore
+        files = [
+            f for f in files if f.file_processing_status != FileProcessingStatus.DELETED
+        ]
+
         # Create a set of languages to extract snippets for
         extensions = {file.extension() for file in files}
         lang_files_map: dict[str, list[domain_entities.File]] = defaultdict(list)
@@ -290,3 +296,8 @@ class IndexDomainService:
                 continue
 
         return working_copy
+
+    async def delete_index(self, index: domain_entities.Index) -> None:
+        """Delete an index."""
+        # Delete the working copy
+        index.source.working_copy.delete()

kodit/infrastructure/api/__init__.py

@@ -0,0 +1 @@
+"""API infrastructure modules."""

kodit/infrastructure/api/middleware/__init__.py

@@ -0,0 +1 @@
+"""API middleware modules."""

kodit/infrastructure/api/middleware/auth.py

@@ -0,0 +1,34 @@
+"""API key-based authentication middleware for the REST API."""
+
+from fastapi import Depends, HTTPException, Request, Security
+from fastapi.security import APIKeyHeader
+
+api_key_header_value = APIKeyHeader(
+    name="x-api-key",
+    auto_error=False,
+    description="API key for authentication (only if set in environmental variables)",
+    scheme_name="Header (X-API-KEY)",
+)
+
+
+def valid_keys(request: Request) -> list[str]:
+    """Get the valid keys from the app context."""
+    if not hasattr(request.state, "app_context"):
+        raise HTTPException(status_code=500, detail="App context not found")
+    app_context = request.state.app_context
+    return app_context.api_keys
+
+
+def api_key_auth(
+    api_key: str = Security(api_key_header_value),
+    valid_keys: list[str] = Depends(valid_keys),
+) -> None:
+    """Validate the API key."""
+    if len(valid_keys) == 0:
+        return
+    # Check if the API key is valid
+    if api_key not in valid_keys:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key",
+        )

kodit/infrastructure/api/v1/__init__.py

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

kodit/infrastructure/api/v1/dependencies.py

@@ -0,0 +1,70 @@
+"""FastAPI dependencies for the REST API."""
+
+from collections.abc import AsyncGenerator
+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_code_indexing_application_service,
+)
+from kodit.application.services.code_indexing_application_service import (
+    CodeIndexingApplicationService,
+)
+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 SqlAlchemyIndexRepository
+
+
+def get_app_context(request: Request) -> AppContext:
+    """Get the app context dependency."""
+    app_context = cast("AppContext", request.state.app_context)
+    if app_context is None:
+        raise RuntimeError("App context not initialized")
+    return app_context
+
+
+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
+
+
+DBSessionDep = Annotated[AsyncSession, Depends(get_db_session)]
+
+
+async def get_index_query_service(
+    session: DBSessionDep,
+) -> IndexQueryService:
+    """Get index query service dependency."""
+    return IndexQueryService(
+        index_repository=SqlAlchemyIndexRepository(session=session),
+        fusion_service=ReciprocalRankFusionService(),
+    )
+
+
+IndexQueryServiceDep = Annotated[IndexQueryService, Depends(get_index_query_service)]
+
+
+async def get_indexing_app_service(
+    app_context: AppContextDep,
+    session: DBSessionDep,
+) -> CodeIndexingApplicationService:
+    """Get indexing application service dependency."""
+    return create_code_indexing_application_service(
+        app_context=app_context,
+        session=session,
+    )
+
+
+IndexingAppServiceDep = Annotated[
+    CodeIndexingApplicationService, Depends(get_indexing_app_service)
+]

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

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

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

@@ -0,0 +1,114 @@
+"""Index management router for the REST API."""
+
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
+
+from kodit.infrastructure.api.middleware.auth import api_key_auth
+from kodit.infrastructure.api.v1.dependencies import (
+    IndexingAppServiceDep,
+    IndexQueryServiceDep,
+)
+from kodit.infrastructure.api.v1.schemas.index import (
+    IndexAttributes,
+    IndexCreateRequest,
+    IndexData,
+    IndexDetailResponse,
+    IndexListResponse,
+    IndexResponse,
+)
+
+router = APIRouter(
+    prefix="/api/v1/indexes",
+    tags=["indexes"],
+    dependencies=[Depends(api_key_auth)],
+    responses={
+        401: {"description": "Unauthorized"},
+        422: {"description": "Invalid request"},
+    },
+)
+
+
+@router.get("")
+async def list_indexes(
+    query_service: IndexQueryServiceDep,
+) -> IndexListResponse:
+    """List all indexes."""
+    indexes = await query_service.list_indexes()
+    return IndexListResponse(
+        data=[
+            IndexData(
+                type="index",
+                id=str(idx.id),
+                attributes=IndexAttributes(
+                    created_at=idx.created_at,
+                    updated_at=idx.updated_at,
+                    uri=str(idx.source.working_copy.remote_uri),
+                ),
+            )
+            for idx in indexes
+        ]
+    )
+
+
+@router.post("", status_code=202)
+async def create_index(
+    request: IndexCreateRequest,
+    background_tasks: BackgroundTasks,
+    app_service: IndexingAppServiceDep,
+) -> IndexResponse:
+    """Create a new index and start async indexing."""
+    # Create index using the application service
+    index = await app_service.create_index_from_uri(request.data.attributes.uri)
+
+    # Start async indexing in background
+    background_tasks.add_task(app_service.run_index, index)
+
+    return IndexResponse(
+        data=IndexData(
+            type="index",
+            id=str(index.id),
+            attributes=IndexAttributes(
+                created_at=index.created_at,
+                updated_at=index.updated_at,
+                uri=str(index.source.working_copy.remote_uri),
+            ),
+        )
+    )
+
+
+@router.get("/{index_id}", responses={404: {"description": "Index not found"}})
+async def get_index(
+    index_id: int,
+    query_service: IndexQueryServiceDep,
+) -> IndexDetailResponse:
+    """Get index details."""
+    index = await query_service.get_index_by_id(index_id)
+    if not index:
+        raise HTTPException(status_code=404, detail="Index not found")
+
+    return IndexDetailResponse(
+        data=IndexData(
+            type="index",
+            id=str(index.id),
+            attributes=IndexAttributes(
+                created_at=index.created_at,
+                updated_at=index.updated_at,
+                uri=str(index.source.working_copy.remote_uri),
+            ),
+        ),
+    )
+
+
+@router.delete(
+    "/{index_id}", status_code=204, responses={404: {"description": "Index not found"}}
+)
+async def delete_index(
+    index_id: int,
+    query_service: IndexQueryServiceDep,
+    app_service: IndexingAppServiceDep,
+) -> None:
+    """Delete an index."""
+    index = await query_service.get_index_by_id(index_id)
+    if not index:
+        raise HTTPException(status_code=404, detail="Index not found")
+
+    await app_service.delete_index(index)

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

@@ -0,0 +1,74 @@
+"""Search router for the REST API."""
+
+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.schemas.search import (
+    SearchRequest,
+    SearchResponse,
+    SnippetAttributes,
+    SnippetData,
+)
+
+router = APIRouter(tags=["search"])
+
+
+@router.post("/api/v1/search")
+async def search_snippets(
+    request: SearchRequest,
+    app_service: IndexingAppServiceDep,
+) -> SearchResponse:
+    """Search code snippets with filters matching MCP tool."""
+    # Convert API request to domain request
+    domain_request = MultiSearchRequest(
+        keywords=request.data.attributes.keywords,
+        code_query=request.data.attributes.code,
+        text_query=request.data.attributes.text,
+        top_k=request.limit or 10,
+        filters=SnippetSearchFilters(
+            language=request.languages[0] if request.languages else None,
+            author=request.authors[0] if request.authors else None,
+            created_after=request.start_date,
+            created_before=request.end_date,
+            source_repo=request.sources[0] if request.sources else None,
+            file_path=request.file_patterns[0] if request.file_patterns else None,
+        )
+        if any(
+            [
+                request.languages,
+                request.authors,
+                request.start_date,
+                request.end_date,
+                request.sources,
+                request.file_patterns,
+            ]
+        )
+        else None,
+    )
+
+    # Execute search using application service
+    results = await app_service.search(domain_request)
+
+    return SearchResponse(
+        data=[
+            SnippetData(
+                type="snippet",
+                id=result.id,
+                attributes=SnippetAttributes(
+                    content=result.content,
+                    created_at=result.created_at,
+                    updated_at=result.created_at,  # Use created_at as fallback
+                    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

@@ -0,0 +1,25 @@
+"""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/context.py

@@ -0,0 +1,11 @@
+"""Schemas for the application context."""
+
+from typing import TypedDict
+
+from kodit.config import AppContext
+
+
+class AppLifespanState(TypedDict):
+    """Application lifespan state."""
+
+    app_context: AppContext