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

kodit/application/services/sync_scheduler.py

@@ -12,7 +12,7 @@ from kodit.domain.entities import Task
 from kodit.domain.services.index_query_service import IndexQueryService
 from kodit.domain.value_objects import QueuePriority
 from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
-from kodit.infrastructure.sqlalchemy.index_repository import SqlAlchemyIndexRepository
+from kodit.infrastructure.sqlalchemy.index_repository import create_index_repository
 
 
 class SyncSchedulerService:
@@ -67,27 +67,28 @@ class SyncSchedulerService:
         """Perform a sync operation on all indexes."""
         self.log.info("Starting sync operation")
 
-        async with self.session_factory() as session:
-            # Create services
-            queue_service = QueueService(session=session)
-            index_query_service = IndexQueryService(
-                index_repository=SqlAlchemyIndexRepository(session=session),
-                fusion_service=ReciprocalRankFusionService(),
-            )
+        # Create services
+        queue_service = QueueService(session_factory=self.session_factory)
+        index_query_service = IndexQueryService(
+            index_repository=create_index_repository(
+                session_factory=self.session_factory
+            ),
+            fusion_service=ReciprocalRankFusionService(),
+        )
 
-            # Get all existing indexes
-            all_indexes = await index_query_service.list_indexes()
+        # Get all existing indexes
+        all_indexes = await index_query_service.list_indexes()
 
-            if not all_indexes:
-                self.log.info("No indexes found to sync")
-                return
+        if not all_indexes:
+            self.log.info("No indexes found to sync")
+            return
 
-            self.log.info("Adding sync tasks to queue", count=len(all_indexes))
+        self.log.info("Adding sync tasks to queue", count=len(all_indexes))
 
-            # Sync each index
-            for index in all_indexes:
-                await queue_service.enqueue_task(
-                    Task.create_index_update_task(index.id, QueuePriority.BACKGROUND)
-                )
+        # Sync each index
+        for index in all_indexes:
+            await queue_service.enqueue_task(
+                Task.create_index_update_task(index.id, QueuePriority.BACKGROUND)
+            )
 
-            self.log.info("Sync operation completed")
+        self.log.info("Sync operation completed")

kodit/cli.py

@@ -11,7 +11,7 @@ import uvicorn
 from pytable_formatter import Cell, Table  # type: ignore[import-untyped]
 
 from kodit.application.factories.code_indexing_factory import (
-    create_code_indexing_application_service,
+    create_cli_code_indexing_application_service,
 )
 from kodit.config import (
     AppContext,
@@ -27,11 +27,7 @@ from kodit.domain.value_objects import (
 )
 from kodit.infrastructure.api.client import IndexClient, SearchClient
 from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
-from kodit.infrastructure.sqlalchemy.index_repository import SqlAlchemyIndexRepository
-from kodit.infrastructure.ui.progress import (
-    create_lazy_progress_callback,
-    create_multi_stage_progress_callback,
-)
+from kodit.infrastructure.sqlalchemy.index_repository import create_index_repository
 from kodit.log import configure_logging, configure_telemetry, log_event
 from kodit.mcp import create_stdio_mcp_server
 
@@ -119,11 +115,8 @@ async def _handle_sync(
     for index in indexes_to_sync:
         click.echo(f"Syncing: {index.source.working_copy.remote_uri}")
 
-        # Create progress callback for this sync operation
-        progress_callback = create_multi_stage_progress_callback()
-
         try:
-            await service.run_index(index, progress_callback)
+            await service.run_index(index)
             click.echo(f"✓ Sync completed: {index.source.working_copy.remote_uri}")
         except Exception as e:
             log.exception("Sync failed", index_id=index.id, error=e)
@@ -190,55 +183,52 @@ async def _index_local(
 
     # Get database session
     db = await app_context.get_db()
-    async with db.session_factory() as session:
-        service = create_code_indexing_application_service(
-            app_context=app_context,
-            session=session,
-        )
-        index_query_service = IndexQueryService(
-            index_repository=SqlAlchemyIndexRepository(session=session),
-            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
-            progress_callback = create_lazy_progress_callback()
-            index = await service.create_index_from_uri(source, progress_callback)
-
-            # Create a new progress callback for the indexing operations
-            indexing_progress_callback = create_multi_stage_progress_callback()
-            try:
-                await service.run_index(index, indexing_progress_callback)
-            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(
@@ -325,34 +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_code_indexing_application_service(
-            app_context=app_context,
-            session=session,
-        )
+    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
@@ -790,18 +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_code_indexing_application_service(
-                app_context=app_context,
-                session=session,
-            )
-            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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from datetime import timedelta
 from enum import Enum
 from functools import wraps
 from pathlib import Path
@@ -41,6 +42,15 @@ T = TypeVar("T")
 EndpointType = Literal["openai", "litellm"]
 
 
+class ReportingConfig(BaseModel):
+    """Reporting configuration."""
+
+    log_time_interval: timedelta = Field(
+        default=timedelta(seconds=5),
+        description="Time interval to log progress in seconds",
+    )
+
+
 class Endpoint(BaseModel):
     """Endpoint provides configuration for an AI service."""
 
@@ -50,7 +60,10 @@ class Endpoint(BaseModel):
         description="Model to use for the endpoint in litellm format (e.g. 'openai/text-embedding-3-small')",  # noqa: E501
     )
     api_key: str | None = None
-    num_parallel_tasks: int | None = None
+    num_parallel_tasks: int = Field(
+        default=10,
+        description="Number of parallel tasks to use for the endpoint",
+    )
     socket_path: str | None = Field(
         default=None,
         description="Unix socket path for local communication (e.g., /tmp/openai.sock)",
@@ -63,6 +76,13 @@ class Endpoint(BaseModel):
         default=None,
         description="Extra provider-specific non-secret parameters for LiteLLM",
     )
+    max_tokens: int = Field(
+        default=8000,  # Reasonable default (with headroom) for most models.
+        description="Conservative token limit for the embedding model",
+    )
+
+
+DEFAULT_NUM_PARALLEL_TASKS = 10  # Semaphore limit for concurrent requests
 
 
 class Search(BaseModel):
@@ -224,6 +244,9 @@ class AppContext(BaseSettings):
     remote: RemoteConfig = Field(
         default_factory=RemoteConfig, description="Remote server configuration"
     )
+    reporting: ReportingConfig = Field(
+        default=ReportingConfig(), description="Reporting configuration"
+    )
 
     @field_validator("api_keys", mode="before")
     @classmethod
@@ -282,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().
@@ -303,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/database.py

@@ -1,5 +1,6 @@
 """Database configuration for kodit."""
 
+from collections.abc import Callable
 from pathlib import Path
 
 import structlog
@@ -28,7 +29,7 @@ class Database:
         )
 
     @property
-    def session_factory(self) -> async_sessionmaker[AsyncSession]:
+    def session_factory(self) -> Callable[[], AsyncSession]:
         """Get the session factory."""
         return self.db_session_factory
 

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,7 +5,14 @@ from typing import Protocol
 
 from pydantic import AnyUrl
 
-from kodit.domain.entities import Index, Snippet, SnippetWithContext, Task, WorkingCopy
+from kodit.domain.entities import (
+    Index,
+    Snippet,
+    SnippetWithContext,
+    Task,
+    TaskStatus,
+    WorkingCopy,
+)
 from kodit.domain.value_objects import MultiSearchRequest, TaskType
 
 
@@ -90,3 +97,29 @@ class IndexRepository(Protocol):
     async def get_snippets_by_ids(self, ids: list[int]) -> list[SnippetWithContext]:
         """Get snippets by their IDs."""
         ...
+
+
+class ReportingModule(Protocol):
+    """Reporting module."""
+
+    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/bm25_service.py

@@ -31,12 +31,7 @@ class BM25DomainService:
     """Domain service for BM25 operations."""
 
     def __init__(self, repository: BM25Repository) -> None:
-        """Initialize the BM25 domain service.
-
-        Args:
-            repository: The BM25 repository for persistence operations
-
-        """
+        """Initialize the BM25 domain service."""
         self.repository = repository
 
     async def index_documents(self, request: IndexRequest) -> None: