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

kodit/infrastructure/api/client/index_client.py

@@ -1,57 +0,0 @@
-"""Index operations API client for Kodit server."""
-
-from kodit.infrastructure.api.v1.schemas.index import (
-    IndexCreateAttributes,
-    IndexCreateData,
-    IndexCreateRequest,
-    IndexData,
-    IndexListResponse,
-    IndexResponse,
-)
-
-from .base import BaseAPIClient
-from .exceptions import KoditAPIError
-from .generated_endpoints import APIEndpoints
-
-
-class IndexClient(BaseAPIClient):
-    """API client for index operations."""
-
-    async def list_indexes(self) -> list[IndexData]:
-        """List all indexes."""
-        response = await self._request("GET", APIEndpoints.API_V1_INDEXES)
-        data = IndexListResponse.model_validate_json(response.text)
-        return data.data
-
-    async def create_index(self, uri: str) -> IndexData:
-        """Create a new index."""
-        request = IndexCreateRequest(
-            data=IndexCreateData(
-                type="index", attributes=IndexCreateAttributes(uri=uri)
-            )
-        )
-        response = await self._request(
-            "POST", APIEndpoints.API_V1_INDEXES, json=request.model_dump()
-        )
-        result = IndexResponse.model_validate_json(response.text)
-        return result.data
-
-    async def get_index(self, index_id: str) -> IndexData | None:
-        """Get index by ID."""
-        try:
-            response = await self._request(
-                "GET", APIEndpoints.API_V1_INDEXES_INDEX_ID.format(index_id=index_id)
-            )
-            result = IndexResponse.model_validate_json(response.text)
-        except KoditAPIError as e:
-            if "404" in str(e):
-                return None
-            raise
-        else:
-            return result.data
-
-    async def delete_index(self, index_id: str) -> None:
-        """Delete an index."""
-        await self._request(
-            "DELETE", APIEndpoints.API_V1_INDEXES_INDEX_ID.format(index_id=index_id)
-        )

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

@@ -1,119 +0,0 @@
-"""Index management router for the REST API."""
-
-from fastapi import APIRouter, Depends, HTTPException
-
-from kodit.domain.entities import Task
-from kodit.domain.value_objects import QueuePriority
-from kodit.infrastructure.api.middleware.auth import api_key_auth
-from kodit.infrastructure.api.v1.dependencies import (
-    IndexingAppServiceDep,
-    IndexQueryServiceDep,
-    QueueServiceDep,
-)
-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,
-    app_service: IndexingAppServiceDep,
-    queue_service: QueueServiceDep,
-) -> 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)
-
-    # Add the indexing task to the queue
-    await queue_service.enqueue_task(
-        Task.create_index_update_task(index.id, QueuePriority.USER_INITIATED)
-    )
-
-    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/schemas/index.py

@@ -1,101 +0,0 @@
-"""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/bm25/bm25_factory.py

@@ -1,28 +0,0 @@
-"""Factory for creating BM25 repositories."""
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from kodit.config import AppContext
-from kodit.domain.services.bm25_service import BM25Repository
-from kodit.infrastructure.bm25.local_bm25_repository import LocalBM25Repository
-from kodit.infrastructure.bm25.vectorchord_bm25_repository import (
-    VectorChordBM25Repository,
-)
-
-
-def bm25_repository_factory(
-    app_context: AppContext, session: AsyncSession
-) -> BM25Repository:
-    """Create a BM25 repository based on configuration.
-
-    Args:
-        app_context: Application configuration context
-        session: SQLAlchemy async session
-
-    Returns:
-        BM25Repository instance
-
-    """
-    if app_context.default_search.provider == "vectorchord":
-        return VectorChordBM25Repository(session=session)
-    return LocalBM25Repository(data_dir=app_context.get_data_dir())

kodit/infrastructure/cloning/__init__.py

@@ -1 +0,0 @@
-"""Cloning infrastructure."""

kodit/infrastructure/cloning/metadata.py

@@ -1,98 +0,0 @@
-"""Metadata extraction for cloned sources."""
-
-import mimetypes
-from datetime import UTC, datetime
-from hashlib import sha256
-from pathlib import Path
-
-import aiofiles
-import git
-from pydantic import AnyUrl
-
-from kodit.domain.entities import Author, File
-from kodit.domain.value_objects import FileProcessingStatus, SourceType
-
-
-class FileMetadataExtractor:
-    """File metadata extractor."""
-
-    def __init__(self, source_type: SourceType) -> None:
-        """Initialize the extractor."""
-        self.source_type = source_type
-
-    async def extract(self, file_path: Path) -> File:
-        """Extract metadata from a file."""
-        if self.source_type == SourceType.GIT:
-            created_at, updated_at = await self._get_git_timestamps(file_path)
-        else:
-            created_at, updated_at = await self._get_file_system_timestamps(file_path)
-
-        # Read file content and calculate metadata
-        async with aiofiles.open(file_path, "rb") as f:
-            content = await f.read()
-            mime_type = mimetypes.guess_type(file_path)
-            sha = sha256(content).hexdigest()
-            if self.source_type == SourceType.GIT:
-                authors = await self._extract_git_authors(file_path)
-            else:
-                authors = []
-
-            return File(
-                created_at=created_at,
-                updated_at=updated_at,
-                uri=AnyUrl(file_path.resolve().absolute().as_uri()),
-                mime_type=mime_type[0]
-                if mime_type and mime_type[0]
-                else "application/octet-stream",
-                sha256=sha,
-                authors=authors,
-                file_processing_status=FileProcessingStatus.ADDED,
-            )
-
-    async def _get_git_timestamps(self, file_path: Path) -> tuple[datetime, datetime]:
-        """Get timestamps from Git history."""
-        git_repo = git.Repo(file_path.parent, search_parent_directories=True)
-        commits = list(git_repo.iter_commits(paths=str(file_path), all=True))
-
-        if commits:
-            last_modified_at = commits[0].committed_datetime
-            first_modified_at = commits[-1].committed_datetime
-            return first_modified_at, last_modified_at
-        # Fallback to current time if no commits found
-        now = datetime.now(UTC)
-        return now, now
-
-    async def _get_file_system_timestamps(
-        self,
-        file_path: Path,
-    ) -> tuple[datetime, datetime]:
-        """Get timestamps from file system."""
-        stat = file_path.stat()
-        file_created_at = datetime.fromtimestamp(stat.st_ctime, UTC)
-        file_modified_at = datetime.fromtimestamp(stat.st_mtime, UTC)
-        return file_created_at, file_modified_at
-
-    async def _extract_git_authors(self, file_path: Path) -> list[Author]:
-        """Extract authors from a Git file."""
-        git_repo = git.Repo(file_path.parent, search_parent_directories=True)
-
-        try:
-            # Get the file's blame
-            blames = git_repo.blame("HEAD", str(file_path))
-
-            # Extract the blame's authors
-            actors = [
-                commit.author
-                for blame in blames or []
-                for commit in blame
-                if isinstance(commit, git.Commit)
-            ]
-
-            # Get or create the authors in the database
-            return [
-                Author(name=actor.name or "", email=actor.email or "")
-                for actor in actors
-            ]
-        except git.GitCommandError:
-            # Handle cases where file might not be tracked
-            return []