kodit 0.3.16__tar.gz → 0.4.0__tar.gz

{kodit-0.3.16 → kodit-0.4.0}/Makefile

@@ -10,11 +10,14 @@ openapi: build
 openapi-check: openapi
 	git diff --exit-code docs/reference/api/index.md
 
+generate-api-paths: openapi
+	uv run python src/kodit/utils/generate_api_paths.py
+
 type:
 	uv run mypy --config-file pyproject.toml .
 
 lint:
 	uv run ruff check --fix --unsafe-fixes
 
-test: lint type
+test: lint type openapi-check
 	uv run pytest -s --cov=src --cov-report=xml tests/kodit

{kodit-0.3.16 → kodit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.16
+Version: 0.4.0
 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.3.16 → kodit-0.4.0}/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.16
+Current version: 0.3.17
 
 ## Authentication
 

{kodit-0.3.16 → kodit-0.4.0}/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.16"
+    "version": "0.3.17"
   },
   "paths": {
     "/healthz": {

{kodit-0.3.16 → kodit-0.4.0}/docs/reference/deployment/index.md

@@ -32,3 +32,29 @@ Deploy with `kubectl -n kodit apply -f kubernetes.yaml`
 
 1. `kind create cluster`
 2. `kubectl -n kodit apply -f kubernetes.yaml`
+
+## Remote CLI Access
+
+Once you have Kodit deployed as a server, you can connect to it remotely using the [REST
+API](../api/index.md) or the Kodit CLI (which uses the REST API).
+
+### Configuration
+
+Remote mode is activated when you configure a server URL. You can do this via environment variables or CLI flags:
+
+**Environment Variables:**
+
+```bash
+export REMOTE_SERVER_URL=https://your-kodit-server.com
+export REMOTE_API_KEY=your-api-key-here # Optional: Only if you have API key's enabled
+export REMOTE_TIMEOUT=60.0              # Optional: request timeout in seconds
+export REMOTE_MAX_RETRIES=5             # Optional: max retry attempts
+export REMOTE_VERIFY_SSL=true           # Optional: verify SSL certificates
+```
+
+### Security
+
+- Always use HTTPS in production environments
+- Store API keys securely and never commit them to version control
+- Use environment variables or secure credential stores for API keys
+- The CLI verifies SSL certificates by default (can be disabled with `REMOTE_VERIFY_SSL=false`)

{kodit-0.3.16 → kodit-0.4.0}/docs/reference/mcp/index.md

@@ -148,19 +148,15 @@ Add the following configuration:
   "mcpServers": {
     "kodit": {
       "autoApprove": [],
-      "disabled": true,
+      "disabled": false,
       "timeout": 60,
-      "url": "https://kodit.helix.ml/mcp",
-      "transportType": "http"
+      "type": "streamableHttp",
+      "url": "https://kodit.helix.ml/mcp"
     }
   }
 }
 ```
 
-Note that some cline users are still [reporting issues with HTTP
-streaming](https://github.com/cline/cline/issues/3315), so you may need to use sse
-instead.
-
 #### Cline STDIO Mode
 
 For STDIO mode, please use:

{kodit-0.3.16 → kodit-0.4.0}/src/kodit/_version.py

@@ -1,14 +1,7 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -16,19 +9,13 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
-    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.16'
-__version_tuple__ = version_tuple = (0, 3, 16)
-
-__commit_id__ = commit_id = None
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)

{kodit-0.3.16 → kodit-0.4.0}/src/kodit/app.py

@@ -9,6 +9,7 @@ from fastapi.responses import RedirectResponse
 
 from kodit._version import version
 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
 from kodit.config import AppContext
 from kodit.infrastructure.api.v1.routers import indexes_router, search_router
@@ -28,9 +29,16 @@ 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()
+
+    # Start the queue worker service
+    _indexing_worker_service = IndexingWorkerService(
+        app_context=app_context,
+        session_factory=db.session_factory,
+    )
+    await _indexing_worker_service.start()
 
     # Start auto-indexing service
-    db = await app_context.get_db()
     _auto_indexing_service = AutoIndexingService(
         app_context=app_context,
         session_factory=db.session_factory,
@@ -40,7 +48,6 @@ async def app_lifespan(_: FastAPI) -> AsyncIterator[AppLifespanState]:
     # Start sync scheduler service
     if app_context.periodic_sync.enabled:
         _sync_scheduler_service = SyncSchedulerService(
-            app_context=app_context,
             session_factory=db.session_factory,
         )
         _sync_scheduler_service.start_periodic_sync(
@@ -54,6 +61,8 @@ async def app_lifespan(_: FastAPI) -> AsyncIterator[AppLifespanState]:
         await _sync_scheduler_service.stop_periodic_sync()
     if _auto_indexing_service:
         await _auto_indexing_service.stop()
+    if _indexing_worker_service:
+        await _indexing_worker_service.stop()
 
 
 # See https://gofastmcp.com/integrations/fastapi#mounting-an-mcp-server

{kodit-0.3.16 → kodit-0.4.0}/src/kodit/application/services/auto_indexing_service.py

@@ -1,6 +1,7 @@
 """Service for automatically indexing configured sources."""
 
 import asyncio
+import warnings
 from collections.abc import Callable
 from contextlib import suppress
 
@@ -10,8 +11,10 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from kodit.application.factories.code_indexing_factory import (
     create_code_indexing_application_service,
 )
+from kodit.application.services.queue_service import QueueService
 from kodit.config import AppContext
-from kodit.infrastructure.ui.progress import create_log_progress_callback
+from kodit.domain.entities import Task
+from kodit.domain.value_objects import QueuePriority
 
 
 class AutoIndexingService:
@@ -37,6 +40,12 @@ class AutoIndexingService:
             self.log.info("Auto-indexing is disabled (no sources configured)")
             return
 
+        warnings.warn(
+            "Auto-indexing is deprecated and will be removed in a future version, please use the API to index sources.",  # noqa: E501
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
         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))
@@ -44,6 +53,7 @@ class AutoIndexingService:
     async def _index_sources(self, sources: list[str]) -> 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,
@@ -56,18 +66,17 @@ class AutoIndexingService:
                         self.log.info("Index already exists, skipping", source=source)
                         continue
 
-                    self.log.info("Auto-indexing source", source=source)
+                    self.log.info("Adding auto-indexing task to queue", source=source)
 
                     # Create index
                     index = await service.create_index_from_uri(source)
 
-                    # Run indexing (without progress callback for background mode)
-                    await service.run_index(
-                        index, progress_callback=create_log_progress_callback()
+                    await queue_service.enqueue_task(
+                        Task.create_index_update_task(
+                            index.id, QueuePriority.BACKGROUND
+                        )
                     )
 
-                    self.log.info("Successfully auto-indexed source", source=source)
-
                 except Exception as exc:
                     self.log.exception(
                         "Failed to auto-index source", source=source, error=str(exc)

kodit-0.4.0/src/kodit/application/services/indexing_worker_service.py

@@ -0,0 +1,154 @@
+"""Service for processing indexing tasks from the database queue."""
+
+import asyncio
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import suppress
+from datetime import UTC, datetime
+
+import structlog
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from kodit.application.factories.code_indexing_factory import (
+    create_code_indexing_application_service,
+)
+from kodit.config import AppContext
+from kodit.domain.entities import Task
+from kodit.domain.value_objects import TaskType
+from kodit.infrastructure.sqlalchemy.task_repository import SqlAlchemyTaskRepository
+
+
+class IndexingWorkerService:
+    """Service for processing indexing tasks from the database queue.
+
+    This worker polls the database for pending tasks and processes the heavy
+    indexing work in separate threads to prevent blocking API responsiveness.
+    """
+
+    def __init__(
+        self,
+        app_context: AppContext,
+        session_factory: Callable[[], AsyncSession],
+    ) -> None:
+        """Initialize the indexing worker service."""
+        self.app_context = app_context
+        self.session_factory = session_factory
+        self._worker_task: asyncio.Task | None = None
+        self._shutdown_event = asyncio.Event()
+        self._executor = ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="indexing-worker"
+        )
+        self.log = structlog.get_logger(__name__)
+
+    async def start(self) -> None:
+        """Start the worker to process the queue."""
+        self._running = True
+
+        # Start single worker task
+        self._worker_task = asyncio.create_task(self._worker_loop())
+
+        self.log.info(
+            "Indexing worker started",
+        )
+
+    async def stop(self) -> None:
+        """Stop the worker gracefully."""
+        self.log.info("Stopping indexing worker")
+        self._shutdown_event.set()
+
+        if self._worker_task and not self._worker_task.done():
+            self._worker_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await self._worker_task
+
+        # Shutdown the thread pool executor
+        self._executor.shutdown(wait=True)
+
+        self.log.info("Indexing worker stopped")
+
+    async def _worker_loop(self) -> None:
+        self.log.debug("Worker loop started")
+
+        while not self._shutdown_event.is_set():
+            try:
+                async with self.session_factory() as session:
+                    repo = SqlAlchemyTaskRepository(session)
+                    task = await repo.take()
+                    await session.commit()
+
+                # If there's a task, process it in a new thread
+                if task:
+                    await asyncio.get_event_loop().run_in_executor(
+                        self._executor, self._process_task, task
+                    )
+                    continue
+
+                # If no task, sleep for a bit
+                await asyncio.sleep(1)
+                continue
+
+            except Exception as e:
+                self.log.exception(
+                    "Error processing task",
+                    error=str(e),
+                )
+                continue
+
+        self.log.info("Worker loop stopped")
+
+    def _process_task(self, task: Task) -> None:
+        """Process a single task."""
+        self.log.info(
+            "Processing task",
+            task_id=task.id,
+            task_type=task.type.value,
+        )
+
+        start_time = datetime.now(UTC)
+
+        # Create a new event loop for this thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        try:
+            # Process based on task type (currently only INDEX_UPDATE is supported)
+            if task.type is TaskType.INDEX_UPDATE:
+                loop.run_until_complete(self._process_index_update(task))
+            else:
+                self.log.warning(
+                    "Unknown task type",
+                    task_id=task.id,
+                    task_type=task.type,
+                )
+                return
+        finally:
+            loop.close()
+
+        duration = (datetime.now(UTC) - start_time).total_seconds()
+        self.log.info(
+            "Task completed successfully",
+            task_id=task.id,
+            duration_seconds=duration,
+        )
+
+    async def _process_index_update(self, task: Task) -> None:
+        """Process index update/sync task."""
+        index_id = task.payload.get("index_id")
+        if not index_id:
+            raise ValueError("Missing index_id in task payload")
+
+        # Create a fresh database connection for this thread's event loop
+        db = await self.app_context.new_db(run_migrations=True)
+        try:
+            async with db.session_factory() as session:
+                service = create_code_indexing_application_service(
+                    app_context=self.app_context,
+                    session=session,
+                )
+                index = await service.index_repository.get(index_id)
+                if not index:
+                    raise ValueError(f"Index not found: {index_id}")
+
+                await service.run_index(index)
+        finally:
+            await db.close()

kodit-0.4.0/src/kodit/application/services/queue_service.py

@@ -0,0 +1,52 @@
+"""Queue service for managing tasks."""
+
+import structlog
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from kodit.domain.entities import Task
+from kodit.domain.value_objects import TaskType
+from kodit.infrastructure.sqlalchemy.task_repository import SqlAlchemyTaskRepository
+
+
+class QueueService:
+    """Service for queue operations using database persistence.
+
+    This service provides the main interface for enqueuing and managing tasks.
+    It uses the existing Task entity in the database with a flexible JSON payload.
+    """
+
+    def __init__(
+        self,
+        session: AsyncSession,
+    ) -> None:
+        """Initialize the queue service."""
+        self.session = session
+        self.log = structlog.get_logger(__name__)
+
+    async def enqueue_task(self, task: Task) -> None:
+        """Queue a task in the database."""
+        repo = SqlAlchemyTaskRepository(self.session)
+
+        # See if task already exists
+        db_task = await repo.get(task.id)
+        if db_task:
+            # Task already exists, update priority
+            db_task.priority = task.priority
+            await repo.update(db_task)
+            self.log.info("Task updated", task_id=task.id, task_type=task.type)
+        else:
+            # Otherwise, add task
+            await repo.add(task)
+            self.log.info(
+                "Task queued",
+                task_id=task.id,
+                task_type=task.type,
+                payload=task.payload,
+            )
+
+        await self.session.commit()
+
+    async def list_tasks(self, task_type: TaskType | None = None) -> list[Task]:
+        """List all tasks in the queue."""
+        repo = SqlAlchemyTaskRepository(self.session)
+        return await repo.list(task_type)

{kodit-0.3.16 → kodit-0.4.0}/src/kodit/application/services/sync_scheduler.py

@@ -7,14 +7,12 @@ from contextlib import suppress
 import structlog
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.application.factories.code_indexing_factory import (
-    create_code_indexing_application_service,
-)
-from kodit.config import AppContext
+from kodit.application.services.queue_service import QueueService
+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.ui.progress import create_log_progress_callback
 
 
 class SyncSchedulerService:
@@ -22,11 +20,9 @@ class SyncSchedulerService:
 
     def __init__(
         self,
-        app_context: AppContext,
         session_factory: Callable[[], AsyncSession],
     ) -> None:
         """Initialize the sync scheduler service."""
-        self.app_context = app_context
         self.session_factory = session_factory
         self.log = structlog.get_logger(__name__)
         self._sync_task: asyncio.Task | None = None
@@ -73,10 +69,7 @@ class SyncSchedulerService:
 
         async with self.session_factory() as session:
             # Create services
-            service = create_code_indexing_application_service(
-                app_context=self.app_context,
-                session=session,
-            )
+            queue_service = QueueService(session=session)
             index_query_service = IndexQueryService(
                 index_repository=SqlAlchemyIndexRepository(session=session),
                 fusion_service=ReciprocalRankFusionService(),
@@ -89,43 +82,12 @@ class SyncSchedulerService:
                 self.log.info("No indexes found to sync")
                 return
 
-            self.log.info("Syncing indexes", count=len(all_indexes))
-
-            success_count = 0
-            failure_count = 0
+            self.log.info("Adding sync tasks to queue", count=len(all_indexes))
 
             # Sync each index
             for index in all_indexes:
-                try:
-                    self.log.info(
-                        "Syncing index",
-                        index_id=index.id,
-                        source=str(index.source.working_copy.remote_uri),
-                    )
-
-                    await service.run_index(
-                        index, progress_callback=create_log_progress_callback()
-                    )
-                    success_count += 1
-
-                    self.log.info(
-                        "Index sync completed",
-                        index_id=index.id,
-                        source=str(index.source.working_copy.remote_uri),
-                    )
-
-                except Exception as e:
-                    failure_count += 1
-                    self.log.exception(
-                        "Index sync failed",
-                        index_id=index.id,
-                        source=str(index.source.working_copy.remote_uri),
-                        error=e,
-                    )
-
-            self.log.info(
-                "Sync operation completed",
-                total=len(all_indexes),
-                success=success_count,
-                failures=failure_count,
-            )
+                await queue_service.enqueue_task(
+                    Task.create_index_update_task(index.id, QueuePriority.BACKGROUND)
+                )
+
+            self.log.info("Sync operation completed")