kodit 0.4.1__tar.gz → 0.4.3__tar.gz

{kodit-0.4.1 → kodit-0.4.3}/.vscode/settings.json

@@ -25,4 +25,7 @@
     "python.analysis.completeFunctionParens": true,
     "python.analysis.inlayHints.functionReturnTypes": true,
     "python.analysis.typeCheckingMode": "standard",
+    "cursorpyright.analysis.autoImportCompletions": true,
+    "cursorpyright.analysis.inlayHints.functionReturnTypes": true,
+    "cursorpyright.analysis.typeCheckingMode": "standard",
 }

{kodit-0.4.1 → kodit-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.4.1
+Version: 0.4.3
 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.4.1 → kodit-0.4.3}/docs/reference/api/index.md

@@ -12,7 +12,7 @@ look at the [hosted version](https://kodit.helix.ml/docs).
 This is the REST API for the Kodit server. Please refer to the
 [Kodit documentation](https://docs.helix.ml/kodit/) for more information.
     
-Current version: 0.3.18
+Current version: 0.4.3
 
 ## Authentication
 
@@ -126,6 +126,32 @@ Delete an index.
 
 - 404: Index not found
 
+### GET /api/v1/indexes/{index_id}/status
+
+Get the status of tasks for an index.
+
+
+#### Parameters
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| index_id | integer | True |  |
+
+
+#### Responses
+
+- 200: Successful Response
+
+[TaskStatusListResponse](#taskstatuslistresponse)
+
+- 500: Internal server error
+
+- 401: Unauthorized
+
+- 422: Invalid request
+
+- 404: Index not found
+
 ### GET /api/v1/queue
 
 List all tasks in the queue.
@@ -453,6 +479,47 @@ JSON:API response for single task.
 | data |  |  |
 
 
+### TaskStatusAttributes
+
+
+Task status attributes for JSON:API responses.
+
+
+| Field | Type | Description |
+|-------|------|-------------|
+| step | string | Name of the task/operation |
+| state | string | Current state of the task |
+| progress | number | Progress percentage (0-100) |
+| total | integer | Total number of items to process |
+| current | integer | Current number of items processed |
+| created_at |  | Task start time |
+| updated_at |  | Last update time |
+
+
+### TaskStatusData
+
+
+Task status data for JSON:API responses.
+
+
+| Field | Type | Description |
+|-------|------|-------------|
+| type | string |  |
+| id | string |  |
+| attributes |  |  |
+
+
+### TaskStatusListResponse
+
+
+JSON:API response for task status list.
+
+
+| Field | Type | Description |
+|-------|------|-------------|
+| data | array |  |
+
+
 ### TaskType
 
 

{kodit-0.4.1 → kodit-0.4.3}/docs/reference/api/openapi.json

@@ -3,7 +3,7 @@
   "info": {
     "title": "kodit API",
     "description": "\nThis is the REST API for the Kodit server. Please refer to the\n[Kodit documentation](https://docs.helix.ml/kodit/) for more information.\n    ",
-    "version": "0.3.18"
+    "version": "0.4.3"
   },
   "paths": {
     "/healthz": {
@@ -197,6 +197,56 @@
         }
       }
     },
+    "/api/v1/indexes/{index_id}/status": {
+      "get": {
+        "tags": [
+          "indexes"
+        ],
+        "summary": "Get Index Status",
+        "description": "Get the status of tasks for an index.",
+        "operationId": "get_index_status_api_v1_indexes__index_id__status_get",
+        "security": [
+          {
+            "Header (X-API-KEY)": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "index_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "title": "Index Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TaskStatusListResponse"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error"
+          },
+          "401": {
+            "description": "Unauthorized"
+          },
+          "422": {
+            "description": "Invalid request"
+          },
+          "404": {
+            "description": "Index not found"
+          }
+        }
+      }
+    },
     "/api/v1/queue": {
       "get": {
         "tags": [
@@ -900,6 +950,113 @@
         "title": "TaskResponse",
         "description": "JSON:API response for single task."
       },
+      "TaskStatusAttributes": {
+        "properties": {
+          "step": {
+            "type": "string",
+            "title": "Step",
+            "description": "Name of the task/operation"
+          },
+          "state": {
+            "type": "string",
+            "title": "State",
+            "description": "Current state of the task"
+          },
+          "progress": {
+            "type": "number",
+            "maximum": 100.0,
+            "minimum": 0.0,
+            "title": "Progress",
+            "description": "Progress percentage (0-100)",
+            "default": 0.0
+          },
+          "total": {
+            "type": "integer",
+            "title": "Total",
+            "description": "Total number of items to process",
+            "default": 0
+          },
+          "current": {
+            "type": "integer",
+            "title": "Current",
+            "description": "Current number of items processed",
+            "default": 0
+          },
+          "created_at": {
+            "anyOf": [
+              {
+                "type": "string",
+                "format": "date-time"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Created At",
+            "description": "Task start time"
+          },
+          "updated_at": {
+            "anyOf": [
+              {
+                "type": "string",
+                "format": "date-time"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Updated At",
+            "description": "Last update time"
+          }
+        },
+        "type": "object",
+        "required": [
+          "step",
+          "state"
+        ],
+        "title": "TaskStatusAttributes",
+        "description": "Task status attributes for JSON:API responses."
+      },
+      "TaskStatusData": {
+        "properties": {
+          "type": {
+            "type": "string",
+            "title": "Type",
+            "default": "task_status"
+          },
+          "id": {
+            "type": "string",
+            "title": "Id"
+          },
+          "attributes": {
+            "$ref": "#/components/schemas/TaskStatusAttributes"
+          }
+        },
+        "type": "object",
+        "required": [
+          "id",
+          "attributes"
+        ],
+        "title": "TaskStatusData",
+        "description": "Task status data for JSON:API responses."
+      },
+      "TaskStatusListResponse": {
+        "properties": {
+          "data": {
+            "items": {
+              "$ref": "#/components/schemas/TaskStatusData"
+            },
+            "type": "array",
+            "title": "Data"
+          }
+        },
+        "type": "object",
+        "required": [
+          "data"
+        ],
+        "title": "TaskStatusListResponse",
+        "description": "JSON:API response for task status list."
+      },
       "TaskType": {
         "type": "integer",
         "enum": [

{kodit-0.4.1 → kodit-0.4.3}/src/kodit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.1'
-__version_tuple__ = version_tuple = (0, 4, 1)
+__version__ = version = '0.4.3'
+__version_tuple__ = version_tuple = (0, 4, 3)
 
 __commit_id__ = commit_id = None

{kodit-0.4.1 → kodit-0.4.3}/src/kodit/app.py

@@ -8,6 +8,7 @@ from fastapi import FastAPI, Response
 from fastapi.responses import RedirectResponse
 
 from kodit._version import version
+from kodit.application.factories.reporting_factory import create_server_operation
 from kodit.application.services.auto_indexing_service import AutoIndexingService
 from kodit.application.services.indexing_worker_service import IndexingWorkerService
 from kodit.application.services.sync_scheduler import SyncSchedulerService
@@ -18,6 +19,9 @@ from kodit.infrastructure.api.v1.routers import (
     search_router,
 )
 from kodit.infrastructure.api.v1.schemas.context import AppLifespanState
+from kodit.infrastructure.sqlalchemy.task_status_repository import (
+    create_task_status_repository,
+)
 from kodit.mcp import mcp
 from kodit.middleware import ASGICancelledErrorMiddleware, logging_middleware
 
@@ -34,20 +38,23 @@ async def app_lifespan(_: FastAPI) -> AsyncIterator[AppLifespanState]:
     # App context has already been configured by the CLI.
     app_context = AppContext()
     db = await app_context.get_db()
+    operation = create_server_operation(
+        create_task_status_repository(db.session_factory)
+    )
 
     # Start the queue worker service
     _indexing_worker_service = IndexingWorkerService(
         app_context=app_context,
         session_factory=db.session_factory,
     )
-    await _indexing_worker_service.start()
+    await _indexing_worker_service.start(operation)
 
     # Start auto-indexing service
     _auto_indexing_service = AutoIndexingService(
         app_context=app_context,
         session_factory=db.session_factory,
     )
-    await _auto_indexing_service.start_background_indexing()
+    await _auto_indexing_service.start_background_indexing(operation)
 
     # Start sync scheduler service
     if app_context.periodic_sync.enabled:

{kodit-0.4.1 → kodit-0.4.3}/src/kodit/application/factories/code_indexing_factory.py

@@ -1,10 +1,20 @@
 """Factory for creating the unified code indexing application service."""
 
+from collections.abc import Callable
+
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from kodit.application.factories.reporting_factory import (
+    create_cli_operation,
+    create_noop_operation,
+    create_server_operation,
+)
 from kodit.application.services.code_indexing_application_service import (
     CodeIndexingApplicationService,
 )
+from kodit.application.services.reporting import (
+    ProgressTracker,
+)
 from kodit.config import AppContext
 from kodit.domain.services.bm25_service import BM25DomainService
 from kodit.domain.services.embedding_service import EmbeddingDomainService
@@ -35,23 +45,35 @@ from kodit.infrastructure.slicing.language_detection_service import (
     FileSystemLanguageDetectionService,
 )
 from kodit.infrastructure.sqlalchemy.embedding_repository import (
-    SqlAlchemyEmbeddingRepository,
+    create_embedding_repository,
 )
 from kodit.infrastructure.sqlalchemy.entities import EmbeddingType
-from kodit.infrastructure.sqlalchemy.index_repository import SqlAlchemyIndexRepository
+from kodit.infrastructure.sqlalchemy.index_repository import (
+    create_index_repository,
+)
+from kodit.infrastructure.sqlalchemy.task_status_repository import (
+    create_task_status_repository,
+)
 
 
 def create_code_indexing_application_service(
     app_context: AppContext,
-    session: AsyncSession,
+    session_factory: Callable[[], AsyncSession],
+    operation: ProgressTracker,
 ) -> CodeIndexingApplicationService:
     """Create a unified code indexing application service with all dependencies."""
     # Create domain services
-    bm25_service = BM25DomainService(bm25_repository_factory(app_context, session))
-    code_search_service = embedding_domain_service_factory("code", app_context, session)
-    text_search_service = embedding_domain_service_factory("text", app_context, session)
+    bm25_service = BM25DomainService(
+        bm25_repository_factory(app_context, session_factory())
+    )
+    code_search_service = embedding_domain_service_factory(
+        "code", app_context, session_factory(), session_factory
+    )
+    text_search_service = embedding_domain_service_factory(
+        "text", app_context, session_factory(), session_factory
+    )
     enrichment_service = enrichment_domain_service_factory(app_context)
-    index_repository = SqlAlchemyIndexRepository(session=session)
+    index_repository = create_index_repository(session_factory=session_factory)
     # Use the unified language mapping from the domain layer
     language_map = LanguageMapping.get_extension_to_language_map()
 
@@ -77,18 +99,45 @@ def create_code_indexing_application_service(
         code_search_service=code_search_service,
         text_search_service=text_search_service,
         enrichment_service=enrichment_service,
-        session=session,
+        operation=operation,
+    )
+
+
+def create_cli_code_indexing_application_service(
+    app_context: AppContext,
+    session_factory: Callable[[], AsyncSession],
+) -> CodeIndexingApplicationService:
+    """Create a CLI code indexing application service."""
+    return create_code_indexing_application_service(
+        app_context,
+        session_factory,
+        create_cli_operation(),
+    )
+
+
+def create_server_code_indexing_application_service(
+    app_context: AppContext,
+    session_factory: Callable[[], AsyncSession],
+) -> CodeIndexingApplicationService:
+    """Create a server code indexing application service."""
+    return create_code_indexing_application_service(
+        app_context,
+        session_factory,
+        create_server_operation(create_task_status_repository(session_factory)),
     )
 
 
 def create_fast_test_code_indexing_application_service(
     app_context: AppContext,
-    session: AsyncSession,
+    session_factory: Callable[[], AsyncSession],
 ) -> CodeIndexingApplicationService:
     """Create a fast test code indexing application service."""
     # Create domain services
-    bm25_service = BM25DomainService(bm25_repository_factory(app_context, session))
-    embedding_repository = SqlAlchemyEmbeddingRepository(session=session)
+    bm25_service = BM25DomainService(
+        bm25_repository_factory(app_context, session_factory())
+    )
+    embedding_repository = create_embedding_repository(session_factory=session_factory)
+    operation = create_noop_operation()
 
     code_search_repository = LocalVectorSearchRepository(
         embedding_repository=embedding_repository,
@@ -116,7 +165,7 @@ def create_fast_test_code_indexing_application_service(
         enrichment_provider=NullEnrichmentProvider()
     )
 
-    index_repository = SqlAlchemyIndexRepository(session=session)
+    index_repository = create_index_repository(session_factory=session_factory)
     # Use the unified language mapping from the domain layer
     language_map = LanguageMapping.get_extension_to_language_map()
 
@@ -142,5 +191,5 @@ def create_fast_test_code_indexing_application_service(
         code_search_service=code_search_service,
         text_search_service=text_search_service,
         enrichment_service=enrichment_service,
-        session=session,
+        operation=operation,
     )

kodit-0.4.3/src/kodit/application/factories/reporting_factory.py

@@ -0,0 +1,32 @@
+"""Reporting factory."""
+
+from kodit.application.services.reporting import ProgressTracker, TaskOperation
+from kodit.config import ReportingConfig
+from kodit.domain.protocols import TaskStatusRepository
+from kodit.infrastructure.reporting.db_progress import DBProgressReportingModule
+from kodit.infrastructure.reporting.log_progress import LoggingReportingModule
+from kodit.infrastructure.reporting.tdqm_progress import TQDMReportingModule
+
+
+def create_noop_operation() -> ProgressTracker:
+    """Create a noop reporter."""
+    return ProgressTracker.create(TaskOperation.ROOT)
+
+
+def create_cli_operation(config: ReportingConfig | None = None) -> ProgressTracker:
+    """Create a CLI reporter."""
+    shared_config = config or ReportingConfig()
+    s = ProgressTracker.create(TaskOperation.ROOT)
+    s.subscribe(TQDMReportingModule(shared_config))
+    return s
+
+
+def create_server_operation(
+    task_status_repository: TaskStatusRepository, config: ReportingConfig | None = None
+) -> ProgressTracker:
+    """Create a server reporter."""
+    shared_config = config or ReportingConfig()
+    s = ProgressTracker.create(TaskOperation.ROOT)
+    s.subscribe(LoggingReportingModule(shared_config))
+    s.subscribe(DBProgressReportingModule(task_status_repository, shared_config))
+    return s

{kodit-0.4.1 → kodit-0.4.3}/src/kodit/application/services/auto_indexing_service.py

@@ -11,7 +11,9 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from kodit.application.factories.code_indexing_factory import (
     create_code_indexing_application_service,
 )
+from kodit.application.factories.reporting_factory import create_noop_operation
 from kodit.application.services.queue_service import QueueService
+from kodit.application.services.reporting import ProgressTracker
 from kodit.config import AppContext
 from kodit.domain.entities import Task
 from kodit.domain.value_objects import QueuePriority
@@ -31,8 +33,11 @@ class AutoIndexingService:
         self.log = structlog.get_logger(__name__)
         self._indexing_task: asyncio.Task | None = None
 
-    async def start_background_indexing(self) -> None:
+    async def start_background_indexing(
+        self, operation: ProgressTracker | None = None
+    ) -> None:
         """Start background indexing of configured sources."""
+        operation = operation or create_noop_operation()
         if (
             not self.app_context.auto_indexing
             or len(self.app_context.auto_indexing.sources) == 0
@@ -48,40 +53,43 @@ class AutoIndexingService:
 
         auto_sources = [source.uri for source in self.app_context.auto_indexing.sources]
         self.log.info("Starting background indexing", num_sources=len(auto_sources))
-        self._indexing_task = asyncio.create_task(self._index_sources(auto_sources))
+        self._indexing_task = asyncio.create_task(
+            self._index_sources(auto_sources, operation)
+        )
 
-    async def _index_sources(self, sources: list[str]) -> None:
+    async def _index_sources(
+        self, sources: list[str], operation: ProgressTracker | None = None
+    ) -> None:
         """Index all configured sources in the background."""
-        async with self.session_factory() as session:
-            queue_service = QueueService(session=session)
-            service = create_code_indexing_application_service(
-                app_context=self.app_context,
-                session=session,
-            )
-
-            for source in sources:
-                try:
-                    # Only auto-index a source if it is new
-                    if await service.does_index_exist(source):
-                        self.log.info("Index already exists, skipping", source=source)
-                        continue
-
-                    self.log.info("Adding auto-indexing task to queue", source=source)
-
-                    # Create index
-                    index = await service.create_index_from_uri(source)
-
-                    await queue_service.enqueue_task(
-                        Task.create_index_update_task(
-                            index.id, QueuePriority.BACKGROUND
-                        )
-                    )
-
-                except Exception as exc:
-                    self.log.exception(
-                        "Failed to auto-index source", source=source, error=str(exc)
-                    )
-                    # Continue with other sources even if one fails
+        operation = operation or create_noop_operation()
+        queue_service = QueueService(session_factory=self.session_factory)
+        service = create_code_indexing_application_service(
+            app_context=self.app_context,
+            session_factory=self.session_factory,
+            operation=operation,
+        )
+
+        for source in sources:
+            try:
+                # Only auto-index a source if it is new
+                if await service.does_index_exist(source):
+                    self.log.info("Index already exists, skipping", source=source)
+                    continue
+
+                self.log.info("Adding auto-indexing task to queue", source=source)
+
+                # Create index
+                index = await service.create_index_from_uri(source)
+
+                await queue_service.enqueue_task(
+                    Task.create_index_update_task(index.id, QueuePriority.BACKGROUND)
+                )
+
+            except Exception as exc:
+                self.log.exception(
+                    "Failed to auto-index source", source=source, error=str(exc)
+                )
+                # Continue with other sources even if one fails
 
     async def stop(self) -> None:
         """Stop background indexing."""