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

kodit/cli.py

@@ -183,56 +183,52 @@ async def _index_local(
 
     # Get database session
     db = await app_context.get_db()
-    async with db.session_factory() as session:
-        service = create_cli_code_indexing_application_service(
-            app_context=app_context,
-            session=session,
-            session_factory=db.session_factory,
-        )
-        index_query_service = IndexQueryService(
-            index_repository=create_index_repository(
-                session_factory=db.session_factory
-            ),
-            fusion_service=ReciprocalRankFusionService(),
-        )
-
-        if auto_index:
-            sources = await _handle_auto_index(app_context, sources)
-            if not sources:
-                return
-
-        if sync:
-            await _handle_sync(service, index_query_service, sources)
-            return
+    service = create_cli_code_indexing_application_service(
+        app_context=app_context,
+        session_factory=db.session_factory,
+    )
+    index_query_service = IndexQueryService(
+        index_repository=create_index_repository(session_factory=db.session_factory),
+        fusion_service=ReciprocalRankFusionService(),
+    )
 
+    if auto_index:
+        sources = await _handle_auto_index(app_context, sources)
         if not sources:
-            await _handle_list_indexes(index_query_service)
             return
 
-        # Handle source indexing
-        for source in sources:
-            if Path(source).is_file():
-                msg = "File indexing is not implemented yet"
-                raise click.UsageError(msg)
-
-            # Index source with progress
-            log_event("kodit.cli.index.create")
-
-            # Create a lazy progress callback that only shows progress when needed
-            index = await service.create_index_from_uri(source)
-
-            # Create a new progress callback for the indexing operations
-            try:
-                await service.run_index(index)
-            except EmptySourceError as e:
-                log.exception("Empty source error", error=e)
-                msg = f"""{e}. This could mean:
+    if sync:
+        await _handle_sync(service, index_query_service, sources)
+        return
+
+    if not sources:
+        await _handle_list_indexes(index_query_service)
+        return
+
+    # Handle source indexing
+    for source in sources:
+        if Path(source).is_file():
+            msg = "File indexing is not implemented yet"
+            raise click.UsageError(msg)
+
+        # Index source with progress
+        log_event("kodit.cli.index.create")
+
+        # Create a lazy progress callback that only shows progress when needed
+        index = await service.create_index_from_uri(source)
+
+        # Create a new progress callback for the indexing operations
+        try:
+            await service.run_index(index)
+        except EmptySourceError as e:
+            log.exception("Empty source error", error=e)
+            msg = f"""{e}. This could mean:
 • The repository contains no supported file types
 • All files are excluded by ignore patterns
 • The files contain no extractable code snippets
 Please check the repository contents and try again.
 """
-                click.echo(msg)
+            click.echo(msg)
 
 
 async def _index_remote(
@@ -319,35 +315,33 @@ async def _search_local(  # noqa: PLR0913
 
     # Get database session
     db = await app_context.get_db()
-    async with db.session_factory() as session:
-        service = create_cli_code_indexing_application_service(
-            app_context=app_context,
-            session=session,
-            session_factory=db.session_factory,
-        )
+    service = create_cli_code_indexing_application_service(
+        app_context=app_context,
+        session_factory=db.session_factory,
+    )
 
-        filters = _parse_filters(
-            language, author, created_after, created_before, source_repo
-        )
+    filters = _parse_filters(
+        language, author, created_after, created_before, source_repo
+    )
 
-        snippets = await service.search(
-            MultiSearchRequest(
-                keywords=keywords,
-                code_query=code_query,
-                text_query=text_query,
-                top_k=top_k,
-                filters=filters,
-            )
+    snippets = await service.search(
+        MultiSearchRequest(
+            keywords=keywords,
+            code_query=code_query,
+            text_query=text_query,
+            top_k=top_k,
+            filters=filters,
         )
+    )
 
-        if len(snippets) == 0:
-            click.echo("No snippets found")
-            return
+    if len(snippets) == 0:
+        click.echo("No snippets found")
+        return
 
-        if output_format == "text":
-            click.echo(MultiSearchResult.to_string(snippets))
-        elif output_format == "json":
-            click.echo(MultiSearchResult.to_jsonlines(snippets))
+    if output_format == "text":
+        click.echo(MultiSearchResult.to_string(snippets))
+    elif output_format == "json":
+        click.echo(MultiSearchResult.to_jsonlines(snippets))
 
 
 async def _search_remote(  # noqa: PLR0913
@@ -785,19 +779,15 @@ async def snippets(
         # Local mode
         log_event("kodit.cli.show.snippets")
         db = await app_context.get_db()
-        async with db.session_factory() as session:
-            service = create_cli_code_indexing_application_service(
-                app_context=app_context,
-                session=session,
-                session_factory=db.session_factory,
-            )
-            snippets = await service.list_snippets(
-                file_path=by_path, source_uri=by_source
-            )
-            if output_format == "text":
-                click.echo(MultiSearchResult.to_string(snippets))
-            elif output_format == "json":
-                click.echo(MultiSearchResult.to_jsonlines(snippets))
+        service = create_cli_code_indexing_application_service(
+            app_context=app_context,
+            session_factory=db.session_factory,
+        )
+        snippets = await service.list_snippets(file_path=by_path, source_uri=by_source)
+        if output_format == "text":
+            click.echo(MultiSearchResult.to_string(snippets))
+        elif output_format == "json":
+            click.echo(MultiSearchResult.to_jsonlines(snippets))
     else:
         # Remote mode - not supported
         click.echo("⚠️  Warning: 'show snippets' is not implemented in remote mode")

kodit/config.py

@@ -305,7 +305,7 @@ class AppContext(BaseSettings):
 with_app_context = click.make_pass_decorator(AppContext)
 
 
-def wrap_async(f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
+def wrap_async[T](f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
     """Decorate async Click commands.
 
     This decorator wraps an async function to run it with asyncio.run().
@@ -326,7 +326,7 @@ def wrap_async(f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
     return wrapper
 
 
-def with_session(f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
+def with_session[T](f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
     """Provide a database session to CLI commands."""
 
     @wraps(f)

kodit/domain/entities.py

@@ -2,7 +2,7 @@
 
 import shutil
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any, Protocol
 from urllib.parse import urlparse, urlunparse
@@ -12,10 +12,13 @@ from pydantic import AnyUrl, BaseModel
 from kodit.domain.value_objects import (
     FileProcessingStatus,
     QueuePriority,
+    ReportingState,
     SnippetContent,
     SnippetContentType,
     SourceType,
+    TaskOperation,
     TaskType,
+    TrackableType,
 )
 from kodit.utils.path_utils import path_from_uri
 
@@ -321,3 +324,98 @@ class Task(BaseModel):
             priority=priority.value,
             payload={"index_id": index_id},
         )
+
+
+class TaskStatus(BaseModel):
+    """Task status domain entity."""
+
+    id: str
+    state: ReportingState
+    operation: TaskOperation
+    message: str = ""
+
+    created_at: datetime = datetime.now(UTC)
+    updated_at: datetime = datetime.now(UTC)
+    total: int = 0
+    current: int = 0
+
+    error: str | None = None
+    parent: "TaskStatus | None" = None
+    trackable_id: int | None = None
+    trackable_type: TrackableType | None = None
+
+    @staticmethod
+    def create(
+        operation: TaskOperation,
+        parent: "TaskStatus | None" = None,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> "TaskStatus":
+        """Create a task status."""
+        return TaskStatus(
+            id=TaskStatus._create_id(operation, trackable_type, trackable_id),
+            operation=operation,
+            parent=parent,
+            trackable_type=trackable_type,
+            trackable_id=trackable_id,
+            state=ReportingState.STARTED,
+        )
+
+    @staticmethod
+    def _create_id(
+        step: TaskOperation,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> str:
+        """Create a unique id for a task."""
+        result = []
+        # Nice to be prefixed by tracking information if it exists
+        if trackable_type:
+            result.append(str(trackable_type))
+        if trackable_id:
+            result.append(str(trackable_id))
+        result.append(str(step))
+        return "-".join(result)
+
+    @property
+    def completion_percent(self) -> float:
+        """Calculate the percentage of completion."""
+        if self.total == 0:
+            return 0.0
+        return min(100.0, max(0.0, (self.current / self.total) * 100.0))
+
+    def skip(self, message: str) -> None:
+        """Skip the task."""
+        self.state = ReportingState.SKIPPED
+        self.message = message
+
+    def fail(self, error: str) -> None:
+        """Fail the task."""
+        self.state = ReportingState.FAILED
+        self.error = error
+
+    def set_total(self, total: int) -> None:
+        """Set the total for the step."""
+        self.total = total
+
+    def set_current(self, current: int, message: str | None = None) -> None:
+        """Progress the step."""
+        self.state = ReportingState.IN_PROGRESS
+        self.current = current
+        if message:
+            self.message = message
+
+    def set_tracking_info(
+        self, trackable_id: int, trackable_type: TrackableType
+    ) -> None:
+        """Set the tracking info."""
+        self.trackable_id = trackable_id
+        self.trackable_type = trackable_type
+
+    def complete(self) -> None:
+        """Complete the task."""
+        if ReportingState.is_terminal(self.state):
+            return  # Already in terminal state
+
+        self.state = ReportingState.COMPLETED
+        self.current = self.total  # Ensure progress shows 100%

kodit/domain/protocols.py

@@ -5,8 +5,15 @@ from typing import Protocol
 
 from pydantic import AnyUrl
 
-from kodit.domain.entities import Index, Snippet, SnippetWithContext, Task, WorkingCopy
-from kodit.domain.value_objects import MultiSearchRequest, Progress, TaskType
+from kodit.domain.entities import (
+    Index,
+    Snippet,
+    SnippetWithContext,
+    Task,
+    TaskStatus,
+    WorkingCopy,
+)
+from kodit.domain.value_objects import MultiSearchRequest, TaskType
 
 
 class TaskRepository(Protocol):
@@ -95,6 +102,24 @@ class IndexRepository(Protocol):
 class ReportingModule(Protocol):
     """Reporting module."""
 
-    def on_change(self, step: Progress) -> None:
+    async def on_change(self, progress: TaskStatus) -> None:
         """On step changed."""
         ...
+
+
+class TaskStatusRepository(Protocol):
+    """Repository interface for persisting progress state only."""
+
+    async def save(self, status: TaskStatus) -> None:
+        """Save a progress state."""
+        ...
+
+    async def load_with_hierarchy(
+        self, trackable_type: str, trackable_id: int
+    ) -> list[TaskStatus]:
+        """Load progress states with IDs and parent IDs from database."""
+        ...
+
+    async def delete(self, status: TaskStatus) -> None:
+        """Delete a progress state."""
+        ...

kodit/domain/services/index_service.py

@@ -126,9 +126,9 @@ class IndexDomainService:
 
         # Calculate snippets for each language
         slicer = Slicer()
-        step.set_total(len(lang_files_map.keys()))
+        await step.set_total(len(lang_files_map.keys()))
         for i, (lang, lang_files) in enumerate(lang_files_map.items()):
-            step.set_current(i)
+            await step.set_current(i, f"Extracting snippets for {lang}")
             s = slicer.extract_snippets(lang_files, language=lang)
             index.snippets.extend(s)
 
@@ -142,10 +142,10 @@ class IndexDomainService:
         """Enrich snippets with AI-generated summaries."""
         reporting_step = reporting_step or create_noop_operation()
         if not snippets or len(snippets) == 0:
-            reporting_step.skip("No snippets to enrich")
+            await reporting_step.skip("No snippets to enrich")
             return snippets
 
-        reporting_step.set_total(len(snippets))
+        await reporting_step.set_total(len(snippets))
         snippet_map = {snippet.id: snippet for snippet in snippets if snippet.id}
 
         enrichment_request = EnrichmentIndexRequest(
@@ -162,7 +162,9 @@ class IndexDomainService:
             snippet_map[result.snippet_id].add_summary(result.text)
 
             processed += 1
-            reporting_step.set_current(processed)
+            await reporting_step.set_current(
+                processed, f"Enriching snippets for {processed} snippets"
+            )
 
         return list(snippet_map.values())
 
@@ -222,12 +224,12 @@ class IndexDomainService:
 
         # Setup reporter
         processed = 0
-        step.set_total(num_files_to_process)
+        await step.set_total(num_files_to_process)
 
         # First check to see if any files have been deleted
         for file_path in deleted_file_paths:
             processed += 1
-            step.set_current(processed)
+            await step.set_current(processed, f"Deleting file {file_path}")
             previous_files_map[
                 file_path
             ].file_processing_status = domain_entities.FileProcessingStatus.DELETED
@@ -235,7 +237,7 @@ class IndexDomainService:
         # Then check to see if there are any new files
         for file_path in new_file_paths:
             processed += 1
-            step.set_current(processed)
+            await step.set_current(processed, f"Adding new file {file_path}")
             try:
                 working_copy.files.append(
                     await metadata_extractor.extract(file_path=file_path)
@@ -247,7 +249,7 @@ class IndexDomainService:
         # Finally check if there are any modified files
         for file_path in modified_file_paths:
             processed += 1
-            step.set_current(processed)
+            await step.set_current(processed, f"Modifying file {file_path}")
             try:
                 previous_file = previous_files_map[file_path]
                 new_file = await metadata_extractor.extract(file_path=file_path)

kodit/domain/services/task_status_query_service.py

@@ -0,0 +1,19 @@
+"""Domain service for querying task status."""
+
+from kodit.domain.entities import TaskStatus
+from kodit.domain.protocols import TaskStatusRepository
+from kodit.domain.value_objects import TrackableType
+
+
+class TaskStatusQueryService:
+    """Query service for task status information."""
+
+    def __init__(self, repository: TaskStatusRepository) -> None:
+        """Initialize the task status query service."""
+        self._repository = repository
+
+    async def get_index_status(self, index_id: int) -> list[TaskStatus]:
+        """Get the status of tasks for a specific index."""
+        return await self._repository.load_with_hierarchy(
+            trackable_type=TrackableType.INDEX.value, trackable_id=index_id
+        )

kodit/domain/value_objects.py

@@ -1,7 +1,7 @@
 """Pure domain value objects and DTOs."""
 
 import json
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum, IntEnum, StrEnum
 from pathlib import Path
@@ -676,37 +676,34 @@ class ReportingState(StrEnum):
     FAILED = "failed"
     SKIPPED = "skipped"
 
+    @staticmethod
+    def is_terminal(state: "ReportingState") -> bool:
+        """Check if a state is completed."""
+        return state in [
+            ReportingState.COMPLETED,
+            ReportingState.FAILED,
+            ReportingState.SKIPPED,
+        ]
 
-@dataclass(frozen=True)
-class Progress:
-    """Immutable representation of a step's state."""
-
-    name: str
-    state: ReportingState
-    message: str = ""
-    error: BaseException | None = None
-    total: int = 0
-    current: int = 0
 
-    @property
-    def completion_percent(self) -> float:
-        """Calculate the percentage of completion."""
-        if self.total == 0:
-            return 0.0
-        return min(100.0, max(0.0, (self.current / self.total) * 100.0))
+class TrackableType(StrEnum):
+    """Trackable type."""
 
-    def with_error(self, error: BaseException) -> "Progress":
-        """Return a new snapshot with updated error."""
-        return replace(self, error=error)
+    INDEX = "indexes"
 
-    def with_total(self, total: int) -> "Progress":
-        """Return a new snapshot with updated total."""
-        return replace(self, total=total)
 
-    def with_progress(self, current: int) -> "Progress":
-        """Return a new snapshot with updated progress."""
-        return replace(self, current=current)
+class TaskOperation(StrEnum):
+    """Task operation."""
 
-    def with_state(self, state: ReportingState, message: str = "") -> "Progress":
-        """Return a new snapshot with updated state."""
-        return replace(self, state=state, message=message)
+    ROOT = "kodit.root"
+    CREATE_INDEX = "kodit.index.create"
+    RUN_INDEX = "kodit.index.run"
+    REFRESH_WORKING_COPY = "kodit.index.run.refresh_working_copy"
+    DELETE_OLD_SNIPPETS = "kodit.index.run.delete_old_snippets"
+    EXTRACT_SNIPPETS = "kodit.index.run.extract_snippets"
+    CREATE_BM25_INDEX = "kodit.index.run.create_bm25_index"
+    CREATE_CODE_EMBEDDINGS = "kodit.index.run.create_code_embeddings"
+    ENRICH_SNIPPETS = "kodit.index.run.enrich_snippets"
+    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"

kodit/infrastructure/api/v1/dependencies.py

@@ -15,8 +15,12 @@ from kodit.application.services.code_indexing_application_service import (
 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.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,
+)
 
 
 def get_app_context(request: Request) -> AppContext:
@@ -70,13 +74,10 @@ IndexQueryServiceDep = Annotated[IndexQueryService, Depends(get_index_query_serv
 
 async def get_indexing_app_service(
     app_context: AppContextDep,
-    session: DBSessionDep,
     session_factory: DBSessionFactoryDep,
 ) -> CodeIndexingApplicationService:
     """Get indexing application service dependency."""
-    return create_server_code_indexing_application_service(
-        app_context, session, session_factory
-    )
+    return create_server_code_indexing_application_service(app_context, session_factory)
 
 
 IndexingAppServiceDep = Annotated[
@@ -94,3 +95,17 @@ async def get_queue_service(
 
 
 QueueServiceDep = Annotated[QueueService, Depends(get_queue_service)]
+
+
+async def get_task_status_query_service(
+    session_factory: DBSessionFactoryDep,
+) -> TaskStatusQueryService:
+    """Get task status query service dependency."""
+    return TaskStatusQueryService(
+        repository=create_task_status_repository(session_factory=session_factory)
+    )
+
+
+TaskStatusQueryServiceDep = Annotated[
+    TaskStatusQueryService, Depends(get_task_status_query_service)
+]

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

@@ -9,6 +9,7 @@ from kodit.infrastructure.api.v1.dependencies import (
     IndexingAppServiceDep,
     IndexQueryServiceDep,
     QueueServiceDep,
+    TaskStatusQueryServiceDep,
 )
 from kodit.infrastructure.api.v1.schemas.index import (
     IndexAttributes,
@@ -18,6 +19,11 @@ from kodit.infrastructure.api.v1.schemas.index import (
     IndexListResponse,
     IndexResponse,
 )
+from kodit.infrastructure.api.v1.schemas.task_status import (
+    TaskStatusAttributes,
+    TaskStatusData,
+    TaskStatusListResponse,
+)
 
 router = APIRouter(
     prefix="/api/v1/indexes",
@@ -103,6 +109,45 @@ async def get_index(
     )
 
 
+@router.get(
+    "/{index_id}/status",
+    responses={404: {"description": "Index not found"}},
+)
+async def get_index_status(
+    index_id: int,
+    query_service: IndexQueryServiceDep,
+    status_service: TaskStatusQueryServiceDep,
+) -> TaskStatusListResponse:
+    """Get the status of tasks for an index."""
+    # Verify the index exists
+    index = await query_service.get_index_by_id(index_id)
+    if not index:
+        raise HTTPException(status_code=404, detail="Index not found")
+
+    # Get all task statuses for this index
+    progress_trackers = await status_service.get_index_status(index_id)
+
+    # Convert progress trackers to API response format
+    task_statuses = []
+    for _i, status in enumerate(progress_trackers):
+        task_statuses.append(
+            TaskStatusData(
+                id=status.id,
+                attributes=TaskStatusAttributes(
+                    step=status.operation,
+                    state=status.state,
+                    progress=status.completion_percent,
+                    total=status.total,
+                    current=status.current,
+                    created_at=status.created_at,
+                    updated_at=status.updated_at,
+                ),
+            )
+        )
+
+    return TaskStatusListResponse(data=task_statuses)
+
+
 @router.delete(
     "/{index_id}", status_code=204, responses={404: {"description": "Index not found"}}
 )

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

@@ -0,0 +1,39 @@
+"""JSON:API schemas for task status operations."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class TaskStatusAttributes(BaseModel):
+    """Task status attributes for JSON:API responses."""
+
+    step: str = Field(..., description="Name of the task/operation")
+    state: str = Field(..., description="Current state of the task")
+    progress: float = Field(
+        default=0.0, ge=0.0, le=100.0, description="Progress percentage (0-100)"
+    )
+    total: int = Field(default=0, description="Total number of items to process")
+    current: int = Field(default=0, description="Current number of items processed")
+    created_at: datetime | None = Field(default=None, description="Task start time")
+    updated_at: datetime | None = Field(default=None, description="Last update time")
+
+
+class TaskStatusData(BaseModel):
+    """Task status data for JSON:API responses."""
+
+    type: str = "task_status"
+    id: str
+    attributes: TaskStatusAttributes
+
+
+class TaskStatusResponse(BaseModel):
+    """JSON:API response for single task status."""
+
+    data: TaskStatusData
+
+
+class TaskStatusListResponse(BaseModel):
+    """JSON:API response for task status list."""
+
+    data: list[TaskStatusData]