kodit 0.3.9__py3-none-any.whl → 0.3.11__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.9'
-__version_tuple__ = version_tuple = (0, 3, 9)
+__version__ = version = '0.3.11'
+__version_tuple__ = version_tuple = (0, 3, 11)

kodit/app.py

@@ -4,10 +4,14 @@ 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.sync_scheduler import SyncSchedulerService
 from kodit.config import AppContext
+from kodit.infrastructure.api.v1.routers import indexes_router, search_router
+from kodit.infrastructure.api.v1.schemas.context import AppLifespanState
 from kodit.infrastructure.indexing.auto_indexing_service import AutoIndexingService
 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/application/services/code_indexing_application_service.py

@@ -382,3 +382,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/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_service.py

@@ -1,6 +1,7 @@
 """Pure domain service for Index aggregate operations."""
 
 from abc import ABC, abstractmethod
+from collections import defaultdict
 from pathlib import Path
 
 import structlog
@@ -104,30 +105,39 @@ class IndexDomainService:
 
         # Create a set of languages to extract snippets for
         extensions = {file.extension() for file in files}
-        languages = []
+        lang_files_map: dict[str, list[domain_entities.File]] = defaultdict(list)
         for ext in extensions:
             try:
-                languages.append(LanguageMapping.get_language_for_extension(ext))
+                lang = LanguageMapping.get_language_for_extension(ext)
+                lang_files_map[lang].extend(
+                    file for file in files if file.extension() == ext
+                )
             except ValueError as e:
-                self.log.info("Skipping", error=str(e))
+                self.log.debug("Skipping", error=str(e))
                 continue
 
+        self.log.info(
+            "Languages to process",
+            languages=lang_files_map.keys(),
+        )
+
         reporter = Reporter(self.log, progress_callback)
         await reporter.start(
             "extract_snippets",
-            len(files) * len(languages),
+            len(lang_files_map.keys()),
             "Extracting code snippets...",
         )
+
         # Calculate snippets for each language
         slicer = Slicer()
-        for i, language in enumerate(languages):
+        for i, (lang, lang_files) in enumerate(lang_files_map.items()):
             await reporter.step(
                 "extract_snippets",
-                len(files) * (i + 1),
-                len(files) * len(languages),
-                "Extracting code snippets...",
+                i,
+                len(lang_files_map.keys()),
+                f"Extracting code snippets for {lang}...",
             )
-            s = slicer.extract_snippets(files, language=language)
+            s = slicer.extract_snippets(lang_files, language=lang)
             index.snippets.extend(s)
 
         await reporter.done("extract_snippets")
@@ -280,3 +290,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

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

@@ -0,0 +1,101 @@
+"""JSON:API schemas for index operations."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class IndexAttributes(BaseModel):
+    """Index attributes for JSON:API responses."""
+
+    created_at: datetime
+    updated_at: datetime
+    uri: str
+
+
+class SnippetData(BaseModel):
+    """Snippet data for JSON:API relationships."""
+
+    type: str = "snippet"
+    id: str
+
+
+class IndexData(BaseModel):
+    """Index data for JSON:API responses."""
+
+    type: str = "index"
+    id: str
+    attributes: IndexAttributes
+
+
+class IndexResponse(BaseModel):
+    """JSON:API response for single index."""
+
+    data: IndexData
+
+
+class IndexListResponse(BaseModel):
+    """JSON:API response for index list."""
+
+    data: list[IndexData]
+
+
+class IndexCreateAttributes(BaseModel):
+    """Attributes for creating an index."""
+
+    uri: str = Field(..., description="URI of the source to index")
+
+
+class IndexCreateData(BaseModel):
+    """Data for creating an index."""
+
+    type: str = "index"
+    attributes: IndexCreateAttributes
+
+
+class IndexCreateRequest(BaseModel):
+    """JSON:API request for creating an index."""
+
+    data: IndexCreateData
+
+
+class AuthorData(BaseModel):
+    """Author data for JSON:API relationships."""
+
+    type: str = "author"
+    id: str
+
+
+class AuthorsRelationship(BaseModel):
+    """Authors relationship for JSON:API."""
+
+    data: list[AuthorData]
+
+
+class FileRelationships(BaseModel):
+    """File relationships for JSON:API."""
+
+    authors: AuthorsRelationship
+
+
+class FileAttributes(BaseModel):
+    """File attributes for JSON:API included resources."""
+
+    uri: str
+    sha256: str
+    mime_type: str
+    created_at: datetime
+    updated_at: datetime
+
+
+class AuthorAttributes(BaseModel):
+    """Author attributes for JSON:API included resources."""
+
+    name: str
+    email: str
+
+
+class IndexDetailResponse(BaseModel):
+    """JSON:API response for index details with included resources."""
+
+    data: IndexData

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

@@ -0,0 +1,219 @@
+"""JSON:API schemas for search operations."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class SearchFilters(BaseModel):
+    """Search filters for JSON:API requests."""
+
+    languages: list[str] | None = Field(
+        None, description="Programming languages to filter by"
+    )
+    authors: list[str] | None = Field(None, description="Authors to filter by")
+    start_date: datetime | None = Field(
+        None, description="Filter snippets created after this date"
+    )
+    end_date: datetime | None = Field(
+        None, description="Filter snippets created before this date"
+    )
+    sources: list[str] | None = Field(
+        None, description="Source repositories to filter by"
+    )
+    file_patterns: list[str] | None = Field(
+        None, description="File path patterns to filter by"
+    )
+
+
+class SearchAttributes(BaseModel):
+    """Search attributes for JSON:API requests."""
+
+    keywords: list[str] | None = Field(None, description="Search keywords")
+    code: str | None = Field(None, description="Code search query")
+    text: str | None = Field(None, description="Text search query")
+    limit: int | None = Field(10, description="Maximum number of results to return")
+    filters: SearchFilters | None = Field(None, description="Search filters")
+
+
+class SearchData(BaseModel):
+    """Search data for JSON:API requests."""
+
+    type: str = "search"
+    attributes: SearchAttributes
+
+
+class SearchRequest(BaseModel):
+    """JSON:API request for searching snippets."""
+
+    data: SearchData
+
+    @property
+    def limit(self) -> int | None:
+        """Get the limit from the search request."""
+        return self.data.attributes.limit
+
+    @property
+    def languages(self) -> list[str] | None:
+        """Get the languages from the search request."""
+        return (
+            self.data.attributes.filters.languages
+            if self.data.attributes.filters
+            else None
+        )
+
+    @property
+    def authors(self) -> list[str] | None:
+        """Get the authors from the search request."""
+        return (
+            self.data.attributes.filters.authors
+            if self.data.attributes.filters
+            else None
+        )
+
+    @property
+    def start_date(self) -> datetime | None:
+        """Get the start date from the search request."""
+        return (
+            self.data.attributes.filters.start_date
+            if self.data.attributes.filters
+            else None
+        )
+
+    @property
+    def end_date(self) -> datetime | None:
+        """Get the end date from the search request."""
+        return (
+            self.data.attributes.filters.end_date
+            if self.data.attributes.filters
+            else None
+        )
+
+    @property
+    def sources(self) -> list[str] | None:
+        """Get the sources from the search request."""
+        return (
+            self.data.attributes.filters.sources
+            if self.data.attributes.filters
+            else None
+        )
+
+    @property
+    def file_patterns(self) -> list[str] | None:
+        """Get the file patterns from the search request."""
+        return (
+            self.data.attributes.filters.file_patterns
+            if self.data.attributes.filters
+            else None
+        )
+
+
+class SnippetAttributes(BaseModel):
+    """Snippet attributes for JSON:API responses."""
+
+    content: str
+    created_at: datetime
+    updated_at: datetime
+    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
+    attributes: SnippetAttributes
+
+
+class SearchResponse(BaseModel):
+    """JSON:API response for search results."""
+
+    data: list[SnippetData]
+
+
+class FileAttributes(BaseModel):
+    """File attributes for JSON:API included resources."""
+
+    uri: str
+    sha256: str
+    mime_type: str
+    created_at: datetime
+    updated_at: datetime
+
+
+class AuthorData(BaseModel):
+    """Author data for JSON:API relationships."""
+
+    type: str = "author"
+    id: int
+
+
+class AuthorsRelationship(BaseModel):
+    """Authors relationship for JSON:API."""
+
+    data: list[AuthorData]
+
+
+class FileRelationships(BaseModel):
+    """File relationships for JSON:API."""
+
+    authors: AuthorsRelationship
+
+
+class FileDataWithRelationships(BaseModel):
+    """File data with relationships for JSON:API included resources."""
+
+    type: str = "file"
+    id: int
+    attributes: FileAttributes
+    relationships: FileRelationships
+
+
+class AuthorAttributes(BaseModel):
+    """Author attributes for JSON:API included resources."""
+
+    name: str
+    email: str
+
+
+class AuthorDataWithAttributes(BaseModel):
+    """Author data with attributes for JSON:API included resources."""
+
+    type: str = "author"
+    id: int
+    attributes: AuthorAttributes
+
+
+class SearchResponseWithIncluded(BaseModel):
+    """JSON:API response for search results with included resources."""
+
+    data: list[SnippetData]
+    included: list[FileDataWithRelationships | AuthorDataWithAttributes] | None = None
+
+
+class SnippetDetailAttributes(BaseModel):
+    """Snippet detail attributes for JSON:API responses."""
+
+    created_at: datetime
+    updated_at: datetime
+    original_content: dict
+    summary_content: dict
+
+
+class SnippetDetailData(BaseModel):
+    """Snippet detail data for JSON:API responses."""
+
+    type: str = "snippet"
+    id: str
+    attributes: SnippetDetailAttributes
+
+
+class SnippetDetailResponse(BaseModel):
+    """JSON:API response for snippet details."""
+
+    data: SnippetDetailData

kodit/infrastructure/slicing/slicer.py

@@ -10,10 +10,12 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, ClassVar
 
+import structlog
 from tree_sitter import Node, Parser, Tree
 from tree_sitter_language_pack import get_language
 
 from kodit.domain.entities import File, Snippet
+from kodit.domain.value_objects import LanguageMapping
 
 
 @dataclass
@@ -145,8 +147,9 @@ class Slicer:
 
     def __init__(self) -> None:
         """Initialize an empty slicer."""
+        self.log = structlog.get_logger(__name__)
 
-    def extract_snippets(
+    def extract_snippets(  # noqa: C901
         self, files: list[File], language: str = "python"
     ) -> list[Snippet]:
         """Extract code snippets from a list of files.
@@ -170,6 +173,7 @@ class Slicer:
 
         # Get language configuration
         if language not in LanguageConfig.CONFIGS:
+            self.log.debug("Skipping", language=language)
             return []
 
         config = LanguageConfig.CONFIGS[language]
@@ -185,16 +189,20 @@ class Slicer:
         # Create mapping from Paths to File objects and extract paths
         path_to_file_map: dict[Path, File] = {}
         file_paths: list[Path] = []
-
         for file in files:
             file_path = file.as_path()
-            path_to_file_map[file_path] = file
-            file_paths.append(file_path)
+
+            # Validate file matches language
+            if not self._file_matches_language(file_path.suffix, language):
+                raise ValueError(f"File {file_path} does not match language {language}")
 
             # Validate file exists
             if not file_path.exists():
                 raise FileNotFoundError(f"File not found: {file_path}")
 
+            path_to_file_map[file_path] = file
+            file_paths.append(file_path)
+
         # Initialize state
         state = AnalyzerState(parser=parser)
         state.files = file_paths
@@ -209,7 +217,7 @@ class Slicer:
                 state.asts[file_path] = tree
             except OSError:
                 # Skip files that can't be parsed
-                pass
+                continue
 
         # Build indexes
         self._build_definition_and_import_indexes(state, config, language)
@@ -233,6 +241,19 @@ class Slicer:
 
         return snippets
 
+    def _file_matches_language(self, file_extension: str, language: str) -> bool:
+        """Check if a file extension matches the current language."""
+        if language not in LanguageConfig.CONFIGS:
+            return False
+
+        try:
+            return (
+                language == LanguageMapping.get_language_for_extension(file_extension)
+            )
+        except ValueError:
+            # Extension not supported, so it doesn't match any language
+            return False
+
     def _get_tree_sitter_language_name(self, language: str) -> str:
         """Map user language names to tree-sitter language names."""
         mapping = {
@@ -299,19 +320,23 @@ class Slicer:
 
     def _walk_tree(self, node: Node) -> Generator[Node, None, None]:
         """Walk the AST tree, yielding all nodes."""
-        cursor = node.walk()
-
-        def _walk_recursive() -> Generator[Node, None, None]:
-            current_node = cursor.node
-            if current_node is not None:
-                yield current_node
-            if cursor.goto_first_child():
-                yield from _walk_recursive()
-                while cursor.goto_next_sibling():
-                    yield from _walk_recursive()
-                cursor.goto_parent()
-
-        yield from _walk_recursive()
+        # Use a simple queue-based approach to avoid recursion issues
+        queue = [node]
+        visited: set[int] = set()  # Track by node id (memory address)
+
+        while queue:
+            current = queue.pop(0)
+
+            # Use node id (memory address) as unique identifier to avoid infinite loops
+            node_id = id(current)
+            if node_id in visited:
+                continue
+            visited.add(node_id)
+
+            yield current
+
+            # Add children to queue
+            queue.extend(current.children)
 
     def _is_function_definition(self, node: Node, config: dict[str, Any]) -> bool:
         """Check if node is a function definition."""

kodit/infrastructure/sqlalchemy/index_repository.py

@@ -577,3 +577,32 @@ class SqlAlchemyIndexRepository(IndexRepository):
                     domain_snippet, index.id
                 )
                 self._session.add(db_snippet)
+
+    async def delete(self, index: domain_entities.Index) -> None:
+        """Delete everything related to an index."""
+        # Delete all snippets and embeddings
+        await self.delete_snippets(index.id)
+
+        # Delete all author file mappings
+        stmt = delete(db_entities.AuthorFileMapping).where(
+            db_entities.AuthorFileMapping.file_id.in_(
+                [file.id for file in index.source.working_copy.files]
+            )
+        )
+        await self._session.execute(stmt)
+
+        # Delete all files
+        stmt = delete(db_entities.File).where(
+            db_entities.File.source_id == index.source.id
+        )
+        await self._session.execute(stmt)
+
+        # Delete the source
+        stmt = delete(db_entities.Source).where(
+            db_entities.Source.id == index.source.id
+        )
+        await self._session.execute(stmt)
+
+        # Delete the index
+        stmt = delete(db_entities.Index).where(db_entities.Index.id == index.id)
+        await self._session.execute(stmt)

kodit/utils/dump_openapi.py

@@ -0,0 +1,33 @@
+"""Dump the OpenAPI json schema to a file."""
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+from openapi_markdown.generator import to_markdown  # type: ignore[import-untyped]
+from uvicorn.importer import import_from_string
+
+parser = argparse.ArgumentParser(prog="dump-openapi.py")
+parser.add_argument(
+    "app", help='App import string. Eg. "kodit.app:app"', default="kodit.app:app"
+)
+parser.add_argument("--out-dir", help="Output directory", default="docs/reference/api")
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    app = import_from_string(args.app)
+    openapi = app.openapi()
+    version = openapi.get("openapi", "unknown version")
+
+    output_json_file = Path(args.out_dir) / "openapi.json"
+
+    with output_json_file.open("w") as f:
+        json.dump(openapi, f, indent=2)
+
+    output_md_file = Path(args.out_dir) / "index.md"
+    templates_dir = Path(args.out_dir) / "templates"
+    options: dict[str, Any] = {}
+
+    to_markdown(str(output_json_file), str(output_md_file), str(templates_dir), options)

{kodit-0.3.9.dist-info → kodit-0.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.9
+Version: 0.3.11
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/

{kodit-0.3.9.dist-info → kodit-0.3.11.dist-info}/RECORD

@@ -1,9 +1,9 @@
 kodit/.gitignore,sha256=ztkjgRwL9Uud1OEi36hGQeDGk3OLK1NfDEO8YqGYy8o,11
 kodit/__init__.py,sha256=aEKHYninUq1yh6jaNfvJBYg-6fenpN132nJt1UU6Jxs,59
-kodit/_version.py,sha256=2CFg1ZfWyy1OjlshL7TqqlWTw1jORYgWRqP2Fc0c4K0,511
-kodit/app.py,sha256=3_smkoioIQEYtRLIGHDtgGkmkP6Movd5CygQEMOStP8,3043
+kodit/_version.py,sha256=NHYomSf4Gkc1-16-B8_7rqOM-xY3AHv8-2MTb6vZqjE,513
+kodit/app.py,sha256=-GY3jdRNKdTLXNoGsEtyJOGdRtxJ_t0HR_Kv24xeOdE,3862
 kodit/cli.py,sha256=ZOS_VzCHGjJRZzZpaVR00QXSPIwRXPYu-pTrbEtlyR0,19328
-kodit/config.py,sha256=Il_eeyg7s83QF5lmiFB6qX6pmpiqCWncHtPgPcdA4xA,8063
+kodit/config.py,sha256=qk242V-ys2cLRq3vy6SrTi8_HFaDNL-f5i63HIpyh2s,8756
 kodit/database.py,sha256=kI9yBm4uunsgV4-QeVoCBL0wLzU4kYmYv5qZilGnbPE,1740
 kodit/log.py,sha256=r0o7IpNvV-dNW-cTNWu1ouJF71vD9wHYzvqDPzeDYfw,8768
 kodit/mcp.py,sha256=aEcPc8dQiZaR0AswCZZNxcm_rhhUZNsEBimYti0ibSI,7221
@@ -13,21 +13,33 @@ kodit/application/__init__.py,sha256=mH50wTpgP9dhbKztFsL8Dda9Hi18TSnMVxXtpp4aGOA
 kodit/application/factories/__init__.py,sha256=bU5CvEnaBePZ7JbkCOp1MGTNP752bnU2uEqmfy5FdRk,37
 kodit/application/factories/code_indexing_factory.py,sha256=R9f0wsj4-3NJFS5SEt_-OIGR_s_01gJXaL3PkZd8MlU,5911
 kodit/application/services/__init__.py,sha256=p5UQNw-H5sxQvs5Etfte93B3cJ1kKW6DNxK34uFvU1E,38
-kodit/application/services/code_indexing_application_service.py,sha256=SuIuyBoSPOSjj5VaXIbxcYqaTEeMuUCu7w1tO8orrOY,14656
+kodit/application/services/code_indexing_application_service.py,sha256=1OA2nzsKCgD952bi9n7IygyzEymL3j7nX0yGkZaMOW0,14975
 kodit/application/services/sync_scheduler.py,sha256=7ZWM0ACiOrTcsW300m52fTqfWMLFmgRRZ6YUPrgUaUk,4621
 kodit/domain/__init__.py,sha256=TCpg4Xx-oF4mKV91lo4iXqMEfBT1OoRSYnbG-zVWolA,66
-kodit/domain/entities.py,sha256=Mcku1Wmk3Xl3YJhY65_RoiLeffOLKOHI0uCAXWJrmvQ,8698
+kodit/domain/entities.py,sha256=EY43R0LOTmsaVsZGS3TWz0Bx5kF3Gm-Knqe6kLZaf9Y,8822
 kodit/domain/errors.py,sha256=yIsgCjM_yOFIg8l7l-t7jM8pgeAX4cfPq0owf7iz3DA,106
 kodit/domain/interfaces.py,sha256=Jkd0Ob4qSvhZHI9jRPFQ1n5Cv0SvU-y3Z-HCw2ikc4I,742
-kodit/domain/protocols.py,sha256=L94FwChhCoj39xicaVrK2UFhFbPzi5JEXW_KmgODsLA,1859
+kodit/domain/protocols.py,sha256=6oeXIHKWMZzpPaZx9mDQ2eOtzj_IeUFu0Dqh2XP9Jmk,1953
 kodit/domain/value_objects.py,sha256=MBZ0WdqQghDmL0Coz_QjPMoVMCiL8pjtpJ5FgaIynoc,17342
 kodit/domain/services/__init__.py,sha256=Q1GhCK_PqKHYwYE4tkwDz5BIyXkJngLBBOHhzvX8nzo,42
 kodit/domain/services/bm25_service.py,sha256=nsfTan3XtDwXuuAu1LUv-6Jukm6qFKVqqCVymjyepZQ,3625
 kodit/domain/services/embedding_service.py,sha256=7drYRC2kjg0WJmo06a2E9N0vDnwInUlBB96twjz2BT8,4526
 kodit/domain/services/enrichment_service.py,sha256=XsXg3nV-KN4rqtC7Zro_ZiZ6RSq-1eA1MG6IDzFGyBA,1316
 kodit/domain/services/index_query_service.py,sha256=02UWfyB_HoHUskunGuHeq5XwQLSWxGSK4OhvxcqIfY0,2022
-kodit/domain/services/index_service.py,sha256=ezVGbWdII25adri4_yyvsAF2eJOt4xmoHRDuS_-c6Ro,10810
+kodit/domain/services/index_service.py,sha256=zWKnCW5L8dMJ7mG2I8knXi-vEWweF9pmY-BhbAV6i4o,11340
 kodit/infrastructure/__init__.py,sha256=HzEYIjoXnkz_i_MHO2e0sIVYweUcRnl2RpyBiTbMObU,28
+kodit/infrastructure/api/__init__.py,sha256=U0TSMPpHrlj1zbAtleuZjU3nXGwudyMe-veNBgvODwM,34
+kodit/infrastructure/api/middleware/__init__.py,sha256=6m7eE5k5buboJbuzyX5E9-Tf99yNwFaeJF0f_6HwLyM,30
+kodit/infrastructure/api/middleware/auth.py,sha256=QSnMcMLWvfumqN1iG4ePj2vEZb2Dlsgr-WHptkEkkhE,1064
+kodit/infrastructure/api/v1/__init__.py,sha256=XYv4_9Z6fo69oMvC2mEbtD6DaMqHth29KHUOelmQFwM,121
+kodit/infrastructure/api/v1/dependencies.py,sha256=cmcItOFz2cR1b2elELQGyixULck4UXx450oI0zqEQCY,2164
+kodit/infrastructure/api/v1/routers/__init__.py,sha256=L8hT_SkDzmCXIiWrFQWCkZXQ3UDy_ZMxPr8AIhjSWK0,160
+kodit/infrastructure/api/v1/routers/indexes.py,sha256=EEY6Zru0e6SpA6GscqmeXuGwyIEu4Zw3r38dMEBgIgs,3287
+kodit/infrastructure/api/v1/routers/search.py,sha256=da9YTR6VTzU85_6X3aaZemdTHGCEvcPNeKuMFBgmT_A,2452
+kodit/infrastructure/api/v1/schemas/__init__.py,sha256=_5BVqv4EUi_vvWlAQOE_VfRulUDAF21ZQ7z27y7YOdw,498
+kodit/infrastructure/api/v1/schemas/context.py,sha256=NlsIn9j1R3se7JkGZivS_CUN4gGP5NYaAtkRe3QH6dk,214
+kodit/infrastructure/api/v1/schemas/index.py,sha256=NtL09YtO50h-ddpAFxNf-dyxu_Xi5v3yOpKW0W4xsAM,1950
+kodit/infrastructure/api/v1/schemas/search.py,sha256=CWzg5SIMUJ_4yM-ZfgSLWCanMxov6AyGgQQcOMkRlGw,5618
 kodit/infrastructure/bm25/__init__.py,sha256=DmGbrEO34FOJy4e685BbyxLA7gPW1eqs2gAxsp6JOuM,34
 kodit/infrastructure/bm25/bm25_factory.py,sha256=I4eo7qRslnyXIRkBf-StZ5ga2Evrr5J5YFocTChFD3g,884
 kodit/infrastructure/bm25/local_bm25_repository.py,sha256=rDx8orGhg38n0zSpybEt5QLOWHY2Yt5IxIf9UtlhXXU,4629
@@ -61,11 +73,11 @@ kodit/infrastructure/mappers/__init__.py,sha256=QPHOjNreXmBPPovZ6elnYFS0vD-IsmrG
 kodit/infrastructure/mappers/index_mapper.py,sha256=ZSfu8kjTaa8_UY0nTqr4b02NS3VrjqZYkduCN71AL2g,12743
 kodit/infrastructure/slicing/__init__.py,sha256=x7cjvHA9Ay2weUYE_dpdAaPaStp20M-4U2b5MLgT5KM,37
 kodit/infrastructure/slicing/language_detection_service.py,sha256=JGJXrq9bLyfnisWJXeP7y1jbZMmKAISdPBlRBCosUcE,684
-kodit/infrastructure/slicing/slicer.py,sha256=HGpxbMJWoDXhLLC7RJzWLAuE93zpoVW1MXzntJhueVo,34626
+kodit/infrastructure/slicing/slicer.py,sha256=GOqJykd00waOTO1WJHyE5KUgJ2RLx2rOQ7M7T_u5LLg,35600
 kodit/infrastructure/sqlalchemy/__init__.py,sha256=UXPMSF_hgWaqr86cawRVqM8XdVNumQyyK5B8B97GnlA,33
 kodit/infrastructure/sqlalchemy/embedding_repository.py,sha256=dC2Wzj_zQiWExwfScE1LAGiiyxPyg0YepwyLOgDwcs4,7905
 kodit/infrastructure/sqlalchemy/entities.py,sha256=Dmh0z-dMI0wfMAPpf62kxU4md6NUH9P5Nx1QSTITOfg,5961
-kodit/infrastructure/sqlalchemy/index_repository.py,sha256=fMnR3OxZN37dtp1M2Menf0xy31GjK1iv_0zn7EvRKYs,22575
+kodit/infrastructure/sqlalchemy/index_repository.py,sha256=UlDH6Qluuat1T0GaATko29fwQPAaUh2WLWiGurBW42w,23598
 kodit/infrastructure/ui/__init__.py,sha256=CzbLOBwIZ6B6iAHEd1L8cIBydCj-n_kobxJAhz2I9_Y,32
 kodit/infrastructure/ui/progress.py,sha256=LmEAQKWWSspqb0fOwruyxBfzBG7gmHd6z1iBco1d7_4,4823
 kodit/infrastructure/ui/spinner.py,sha256=GcP115qtR0VEnGfMEtsGoAUpRzVGUSfiUXfoJJERngA,2357
@@ -81,9 +93,10 @@ kodit/migrations/versions/9e53ea8bb3b0_add_authors.py,sha256=a32Zm8KUQyiiLkjKNPY
 kodit/migrations/versions/__init__.py,sha256=9-lHzptItTzq_fomdIRBegQNm4Znx6pVjwD4MiqRIdo,36
 kodit/migrations/versions/c3f5137d30f5_index_all_the_things.py,sha256=r7ukmJ_axXLAWewYx-F1fEmZ4JbtFd37i7cSb0tq3y0,1722
 kodit/utils/__init__.py,sha256=DPEB1i8evnLF4Ns3huuAYg-0pKBFKUFuiDzOKG9r-sw,33
+kodit/utils/dump_openapi.py,sha256=_1wIrJLA-RlvgZ_8tMzDF0Kdee6UaPp_9DQjfHoM-xc,1062
 kodit/utils/path_utils.py,sha256=thK6YGGNvQThdBaCYCCeCvS1L8x-lwl3AoGht2jnjGw,1645
-kodit-0.3.9.dist-info/METADATA,sha256=3YOAFUcvQJJSNSOfZvhfp-VcAmQbwUjbZRwmz1qXekI,6973
-kodit-0.3.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kodit-0.3.9.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
-kodit-0.3.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kodit-0.3.9.dist-info/RECORD,,
+kodit-0.3.11.dist-info/METADATA,sha256=B06xZGWPvpr5EXz_4GjzeYKeOk6J7lFQg6o2zkgLGgc,6974
+kodit-0.3.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kodit-0.3.11.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
+kodit-0.3.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kodit-0.3.11.dist-info/RECORD,,