@lojban/semantic-search-mcp 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lojban/semantic-search-mcp",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Local-first MCP server for semantic search using transformers.js and SQLite",
   "type": "module",
   "scripts": {

package/src/index.ts

@@ -36,17 +36,31 @@ const indexStatus: IndexStatus = {
   directories: [],
 };
 
-async function startIndexing(storage: VectorStorage, directories: string[]): Promise<void> {
+// Single "mutex": only one indexing job is allowed to run. Starting a new job aborts the previous one.
+let currentIndexingAbortController: AbortController | null = null;
+let currentJobId = 0;
+
+/**
+ * Request indexing of directories. If another indexing job is running, it is aborted first.
+ * Then a new job is started (clears index and rebuilds).
+ */
+function requestIndexing(storage: VectorStorage, directories: string[]): void {
   if (!directories.length) {
     console.error('No directories to index. Set SEMANTIC_SEARCH_INDEX_DIRS (comma-separated paths).');
     return;
   }
 
-  if (indexStatus.isIndexing) {
-    console.error('Indexing already in progress, not starting a new job.');
-    return;
+  // Abort any in-progress indexing so it doesn't conflict or flush this job's work.
+  if (currentIndexingAbortController) {
+    currentIndexingAbortController.abort();
+    currentIndexingAbortController = null;
   }
 
+  currentJobId += 1;
+  const jobId = currentJobId;
+  currentIndexingAbortController = new AbortController();
+  const signal = currentIndexingAbortController.signal;
+
   indexStatus.isIndexing = true;
   indexStatus.startedAt = Date.now();
   indexStatus.finishedAt = null;
@@ -55,9 +69,21 @@ async function startIndexing(storage: VectorStorage, directories: string[]): Pro
   indexStatus.indexedLines = 0;
   indexStatus.indexedFiles = 0;
 
+  void startIndexing(storage, directories, signal, jobId);
+}
+
+async function startIndexing(
+  storage: VectorStorage,
+  directories: string[],
+  signal: AbortSignal,
+  jobId: number
+): Promise<void> {
+  const isCurrentJob = (): boolean => currentJobId === jobId;
+
   try {
-    storage.clear();
+    if (signal.aborted) return;
 
+    storage.clear();
     console.error(`Scanning ${directories.length} directories (background indexing)...`);
 
     let indexedCount = 0;
@@ -79,43 +105,45 @@ async function startIndexing(storage: VectorStorage, directories: string[]): Pro
 
       await storage.upsertLinesBatch(batchData);
       indexedCount += batchToProcess.length;
-      indexStatus.indexedLines = indexedCount;
+      if (isCurrentJob()) indexStatus.indexedLines = indexedCount;
       console.error(`Indexed ${indexedCount} lines...`);
     };
 
-    // Pipelining: Read next batch while processing current batch
-    // We allow ONE batch to be processed in parallel with reading the next one.
     let processingPromise: Promise<void> | null = null;
 
     for await (const line of scanDirectories(directories)) {
+      if (signal.aborted) break;
+
       currentBatch.push(line);
       if (currentBatch.length >= BATCH_SIZE) {
-        // If there's a previous batch still processing, wait for it
         if (processingPromise) {
           await processingPromise;
         }
+        if (signal.aborted) break;
 
         const batchToProcess = currentBatch;
         currentBatch = [];
 
-        // Start processing this batch, but don't await it yet!
-        // This allows the loop to continue and read the next batch from disk.
         processingPromise = processBatch(batchToProcess).catch((err) => {
           console.error('Error in background batch processing:', err);
         });
       }
     }
 
-    // Wait for the last async batch
+    if (signal.aborted) {
+      console.error('Indexing aborted (new job started or cancelled).');
+      return;
+    }
+
     if (processingPromise) {
       await processingPromise;
     }
-
-    // Process any remaining lines
     if (currentBatch.length > 0) {
       await processBatch(currentBatch);
     }
 
+    if (!isCurrentJob()) return;
+
     const stats = await storage.getStats();
     indexStatus.indexedFiles = stats.totalFiles;
     indexStatus.indexedLines = stats.totalLines;
@@ -126,15 +154,22 @@ async function startIndexing(storage: VectorStorage, directories: string[]): Pro
     );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    indexStatus.lastError = message;
-    indexStatus.finishedAt = Date.now();
+    if (isCurrentJob()) {
+      indexStatus.lastError = message;
+      indexStatus.finishedAt = Date.now();
+    }
     console.error('Error during indexing job:', err);
   } finally {
-    indexStatus.isIndexing = false;
+    if (isCurrentJob()) {
+      indexStatus.isIndexing = false;
+    }
+    if (currentIndexingAbortController && currentJobId === jobId) {
+      currentIndexingAbortController = null;
+    }
   }
 }
 
-async function ensureInitialIndexing(storage: VectorStorage): Promise<void> {
+function ensureInitialIndexing(storage: VectorStorage): void {
   const envDirs = process.env.SEMANTIC_SEARCH_INDEX_DIRS;
   const directories = envDirs ? envDirs.split(',').map((d) => d.trim()).filter(Boolean) : [];
 
@@ -145,8 +180,7 @@ async function ensureInitialIndexing(storage: VectorStorage): Promise<void> {
     return;
   }
 
-  // Fire-and-forget; indexing runs in background.
-  void startIndexing(storage, directories);
+  requestIndexing(storage, directories);
 }
 
 async function main() {
@@ -222,10 +256,8 @@ async function main() {
             );
           }
 
-          // Trigger (or reuse) background indexing job.
-          if (!indexStatus.isIndexing) {
-            void startIndexing(storage, directories);
-          }
+          // Abort any in-progress indexing and start a new job (clears and rebuilds).
+          requestIndexing(storage, directories);
 
           const stats = await storage.getStats();
           return {
@@ -313,7 +345,7 @@ async function main() {
   console.error('Semantic Search MCP Server running on stdio');
 
   // Kick off initial background indexing when the MCP server is enabled.
-  await ensureInitialIndexing(storage);
+  ensureInitialIndexing(storage);
 }
 
 main().catch(console.error);