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

kodit/domain/value_objects.py

@@ -1,6 +1,5 @@
 """Pure domain value objects and DTOs."""
 
-import json
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum, IntEnum, StrEnum
@@ -18,12 +17,27 @@ class SourceType(IntEnum):
     GIT = 2
 
 
-class SnippetContentType(IntEnum):
+class SnippetContentType(StrEnum):
     """Type of snippet content."""
 
-    UNKNOWN = 0
-    ORIGINAL = 1
-    SUMMARY = 2
+    UNKNOWN = "unknown"
+    ORIGINAL = "original"
+    SUMMARY = "summary"
+
+
+class EnrichmentType(StrEnum):
+    """Type of enrichment."""
+
+    UNKNOWN = "unknown"
+    SUMMARIZATION = "summarization"
+
+
+@dataclass(frozen=True)
+class Enrichment:
+    """Enrichment domain value object."""
+
+    type: EnrichmentType
+    content: str
 
 
 class SnippetContent(BaseModel):
@@ -31,7 +45,6 @@ class SnippetContent(BaseModel):
 
     type: SnippetContentType
     value: str
-    language: str
 
 
 class SnippetSearchResult(BaseModel):
@@ -138,7 +151,7 @@ class SearchType(Enum):
 class Document:
     """Generic document model for indexing."""
 
-    snippet_id: int
+    snippet_id: str
     text: str
 
 
@@ -146,7 +159,7 @@ class Document:
 class DocumentSearchResult:
     """Generic document search result model."""
 
-    snippet_id: int
+    snippet_id: str
     score: float
 
 
@@ -154,7 +167,7 @@ class DocumentSearchResult:
 class SearchResult:
     """Generic search result model."""
 
-    snippet_id: int
+    snippet_id: str
     score: float
 
 
@@ -171,21 +184,21 @@ class SearchRequest:
 
     query: str
     top_k: int = 10
-    snippet_ids: list[int] | None = None
+    snippet_ids: list[str] | None = None
 
 
 @dataclass
 class DeleteRequest:
     """Generic deletion request."""
 
-    snippet_ids: list[int]
+    snippet_ids: list[str]
 
 
 @dataclass
 class IndexResult:
     """Generic indexing result."""
 
-    snippet_id: int
+    snippet_id: str
 
 
 @dataclass(frozen=True)
@@ -271,98 +284,11 @@ class MultiSearchRequest:
     filters: SnippetSearchFilters | None = None
 
 
-@dataclass
-class MultiSearchResult:
-    """Enhanced search result with comprehensive snippet metadata."""
-
-    id: int
-    content: str
-    original_scores: list[float]
-    source_uri: str
-    relative_path: str
-    language: str
-    authors: list[str]
-    created_at: datetime
-    summary: str
-
-    def __str__(self) -> str:
-        """Return enhanced formatted string representation."""
-        lines = [
-            "---",
-            f"id: {self.id}",
-            f"source: {self.source_uri}",
-            f"path: {self.relative_path}",
-            f"lang: {self.language}",
-            f"created: {self.created_at.isoformat()}",
-            f"authors: {', '.join(self.authors)}",
-            f"scores: {self.original_scores}",
-            "---",
-            f"{self.summary}\n",
-            f"```{self.language}",
-            f"{self.content}",
-            "```\n",
-        ]
-        return "\n".join(lines)
-
-    def to_json(self) -> str:
-        """Return LLM-optimized JSON representation following the compact schema."""
-        json_obj = {
-            "id": self.id,
-            "source": self.source_uri,
-            "path": self.relative_path,
-            "lang": self.language.lower(),
-            "created": self.created_at.isoformat() if self.created_at else "",
-            "author": ", ".join(self.authors),
-            "score": self.original_scores,
-            "code": self.content,
-            "summary": self.summary,
-        }
-
-        return json.dumps(json_obj, separators=(",", ":"))
-
-    @classmethod
-    def to_jsonlines(cls, results: list["MultiSearchResult"]) -> str:
-        """Convert multiple MultiSearchResult objects to JSON Lines format.
-
-        Args:
-            results: List of MultiSearchResult objects
-            include_summary: Whether to include summary fields
-
-        Returns:
-            JSON Lines string (one JSON object per line)
-
-        """
-        return "\n".join(result.to_json() for result in results)
-
-    @classmethod
-    def to_string(cls, results: list["MultiSearchResult"]) -> str:
-        """Convert multiple MultiSearchResult objects to a string."""
-        return "\n\n".join(str(result) for result in results)
-
-    @staticmethod
-    def calculate_relative_path(file_path: str, source_path: str) -> str:
-        """Calculate relative path from source root."""
-        try:
-            return str(Path(file_path).relative_to(Path(source_path)))
-        except ValueError:
-            # If file_path is not relative to source_path, return the file name
-            return Path(file_path).name
-
-    @staticmethod
-    def detect_language_from_extension(extension: str) -> str:
-        """Detect programming language from file extension."""
-        try:
-            return LanguageMapping.get_language_for_extension(extension).title()
-        except ValueError:
-            # Unknown extension, return a default
-            return "Unknown"
-
-
 @dataclass
 class FusionRequest:
     """Domain model for fusion request."""
 
-    id: int
+    id: str
     score: float
 
 
@@ -370,7 +296,7 @@ class FusionRequest:
 class FusionResult:
     """Domain model for fusion result."""
 
-    id: int
+    id: str
     score: float
     original_scores: list[float]
 
@@ -408,7 +334,7 @@ class ProgressState:
 class EmbeddingRequest:
     """Domain model for embedding request."""
 
-    snippet_id: int
+    snippet_id: str
     text: str
 
 
@@ -416,33 +342,10 @@ class EmbeddingRequest:
 class EmbeddingResponse:
     """Domain model for embedding response."""
 
-    snippet_id: int
+    snippet_id: str
     embedding: list[float]
 
 
-@dataclass
-class EnrichmentRequest:
-    """Domain model for enrichment request."""
-
-    snippet_id: int
-    text: str
-
-
-@dataclass
-class EnrichmentResponse:
-    """Domain model for enrichment response."""
-
-    snippet_id: int
-    text: str
-
-
-@dataclass
-class EnrichmentIndexRequest:
-    """Domain model for enrichment index request."""
-
-    requests: list[EnrichmentRequest]
-
-
 @dataclass
 class IndexView:
     """Domain model for index information."""
@@ -651,22 +554,14 @@ class FunctionDefinition:
     end_byte: int
 
 
-class TaskType(Enum):
-    """Task type."""
-
-    INDEX_UPDATE = 1
-
-
 class QueuePriority(IntEnum):
     """Queue priority."""
 
     BACKGROUND = 10
+    NORMAL = 20
     USER_INITIATED = 50
 
 
-# Reporting value objects
-
-
 class ReportingState(StrEnum):
     """Reporting state."""
 
@@ -690,6 +585,8 @@ class TrackableType(StrEnum):
     """Trackable type."""
 
     INDEX = "indexes"
+    KODIT_REPOSITORY = "kodit.repository"
+    KODIT_COMMIT = "kodit.commit"
 
 
 class TaskOperation(StrEnum):
@@ -707,3 +604,58 @@ class TaskOperation(StrEnum):
     CREATE_TEXT_EMBEDDINGS = "kodit.index.run.create_text_embeddings"
     UPDATE_INDEX_TIMESTAMP = "kodit.index.run.update_index_timestamp"
     CLEAR_FILE_PROCESSING_STATUSES = "kodit.index.run.clear_file_processing_statuses"
+
+    # New commit-based workflow
+    KODIT_REPOSITORY = "kodit.repository"
+    CREATE_REPOSITORY = "kodit.repository.create"
+    DELETE_REPOSITORY = "kodit.repository.delete"
+    CLONE_REPOSITORY = "kodit.repository.clone"
+    SCAN_REPOSITORY = "kodit.repository.scan"
+    KODIT_COMMIT = "kodit.commit"
+    EXTRACT_SNIPPETS_FOR_COMMIT = "kodit.commit.extract_snippets"
+    CREATE_BM25_INDEX_FOR_COMMIT = "kodit.commit.create_bm25_index"
+    CREATE_CODE_EMBEDDINGS_FOR_COMMIT = "kodit.commit.create_code_embeddings"
+    CREATE_SUMMARY_ENRICHMENT_FOR_COMMIT = "kodit.commit.create_summary_enrichment"
+    CREATE_SUMMARY_EMBEDDINGS_FOR_COMMIT = "kodit.commit.create_summary_embeddings"
+    CREATE_ARCHITECTURE_ENRICHMENT_FOR_COMMIT = (
+        "kodit.commit.create_architecture_enrichment"
+    )
+    CREATE_PUBLIC_API_DOCS_FOR_COMMIT = "kodit.commit.create_public_api_docs"
+
+    def is_repository_operation(self) -> bool:
+        """Check if the task operation is a repository operation."""
+        return self.startswith("kodit.repository.")
+
+    def is_commit_operation(self) -> bool:
+        """Check if the task operation is a commit operation."""
+        return self.startswith("kodit.commit.")
+
+
+class PrescribedOperations:
+    """Prescribed common operations."""
+
+    CREATE_NEW_REPOSITORY: ClassVar[list[TaskOperation]] = [
+        TaskOperation.CLONE_REPOSITORY,
+        TaskOperation.SCAN_REPOSITORY,
+    ]
+    INDEX_COMMIT: ClassVar[list[TaskOperation]] = [
+        TaskOperation.EXTRACT_SNIPPETS_FOR_COMMIT,
+        TaskOperation.CREATE_BM25_INDEX_FOR_COMMIT,
+        TaskOperation.CREATE_CODE_EMBEDDINGS_FOR_COMMIT,
+        TaskOperation.CREATE_SUMMARY_ENRICHMENT_FOR_COMMIT,
+        TaskOperation.CREATE_SUMMARY_EMBEDDINGS_FOR_COMMIT,
+        TaskOperation.CREATE_ARCHITECTURE_ENRICHMENT_FOR_COMMIT,
+        TaskOperation.CREATE_PUBLIC_API_DOCS_FOR_COMMIT,
+    ]
+    SYNC_REPOSITORY: ClassVar[list[TaskOperation]] = [
+        TaskOperation.SCAN_REPOSITORY,
+    ]
+
+
+class IndexStatus(StrEnum):
+    """Status of commit indexing."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"

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,23 +1,27 @@
 """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.domain.protocols import (
+    GitBranchRepository,
+    GitCommitRepository,
+    GitRepoRepository,
+    GitTagRepository,
+)
 from kodit.domain.services.task_status_query_service import TaskStatusQueryService
-from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
-from kodit.infrastructure.sqlalchemy.index_repository import create_index_repository
 from kodit.infrastructure.sqlalchemy.task_status_repository import (
     create_task_status_repository,
 )
@@ -34,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[
@@ -59,32 +61,6 @@ DBSessionFactoryDep = Annotated[
 ]
 
 
-async def get_index_query_service(
-    session_factory: DBSessionFactoryDep,
-) -> IndexQueryService:
-    """Get index query service dependency."""
-    return IndexQueryService(
-        index_repository=create_index_repository(session_factory=session_factory),
-        fusion_service=ReciprocalRankFusionService(),
-    )
-
-
-IndexQueryServiceDep = Annotated[IndexQueryService, Depends(get_index_query_service)]
-
-
-async def get_indexing_app_service(
-    app_context: AppContextDep,
-    session_factory: DBSessionFactoryDep,
-) -> CodeIndexingApplicationService:
-    """Get indexing application service dependency."""
-    return create_server_code_indexing_application_service(app_context, session_factory)
-
-
-IndexingAppServiceDep = Annotated[
-    CodeIndexingApplicationService, Depends(get_indexing_app_service)
-]
-
-
 async def get_queue_service(
     session_factory: DBSessionFactoryDep,
 ) -> QueueService:
@@ -109,3 +85,73 @@ async def get_task_status_query_service(
 TaskStatusQueryServiceDep = Annotated[
     TaskStatusQueryService, Depends(get_task_status_query_service)
 ]
+
+
+async def get_git_repository(
+    server_factory: ServerFactoryDep,
+) -> GitRepoRepository:
+    """Get git repository dependency."""
+    return server_factory.repo_repository()
+
+
+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"]