bluera-knowledge 0.11.18 → 0.11.20

package/dist/mcp/server.js

@@ -1,9 +1,9 @@
 import {
   createMCPServer,
   runMCPServer
-} from "../chunk-5NUI6JL6.js";
-import "../chunk-ZZNABJMQ.js";
-import "../chunk-6FHWC36B.js";
+} from "../chunk-ZSKQIMD7.js";
+import "../chunk-MQGRQ2EG.js";
+import "../chunk-HRQD3MPH.js";
 export {
   createMCPServer,
   runMCPServer

package/dist/watch.service-OPLKIDFQ.js

@@ -0,0 +1,7 @@
+import {
+  WatchService
+} from "./chunk-HRQD3MPH.js";
+export {
+  WatchService
+};
+//# sourceMappingURL=watch.service-OPLKIDFQ.js.map

package/dist/workers/background-worker-cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   IntelligentCrawler
-} from "../chunk-ZDEO4WJT.js";
+} from "../chunk-Q2ZGPJ66.js";
 import {
   JobService,
   createDocumentId,
@@ -9,8 +9,8 @@ import {
   createServices,
   createStoreId,
   shutdownLogger
-} from "../chunk-ZZNABJMQ.js";
-import "../chunk-6FHWC36B.js";
+} from "../chunk-MQGRQ2EG.js";
+import "../chunk-HRQD3MPH.js";
 
 // src/workers/background-worker.ts
 import { createHash } from "crypto";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bluera-knowledge",
-  "version": "0.11.18",
+  "version": "0.11.20",
   "description": "CLI tool for managing knowledge stores with semantic search",
   "type": "module",
   "bin": {

package/src/cli/commands/crawl.ts

@@ -77,7 +77,7 @@ export function createCrawlCommand(getOptions: () => GlobalOptions): Command {
           store = existingStore;
         }
 
-        const maxPages = cmdOptions.maxPages !== undefined ? parseInt(cmdOptions.maxPages) : 50;
+        const maxPages = cmdOptions.maxPages !== undefined ? parseInt(cmdOptions.maxPages, 10) : 50;
 
         // Use spinner in interactive mode
         const isInteractive =

package/src/cli/commands/index-cmd.test.ts

@@ -407,7 +407,12 @@ describe('createIndexCommand - Execution Tests', () => {
 
       expect(mockServices.store.getByIdOrName).toHaveBeenCalledWith('test-store');
       expect(WatchService).toHaveBeenCalledWith(mockServices.index, mockServices.lance);
-      expect(mockWatchService.watch).toHaveBeenCalledWith(mockStore, 1000, expect.any(Function));
+      expect(mockWatchService.watch).toHaveBeenCalledWith(
+        mockStore,
+        1000,
+        expect.any(Function),
+        expect.any(Function)
+      );
     });
 
     it('watches a repo store successfully', async () => {
@@ -467,7 +472,12 @@ describe('createIndexCommand - Execution Tests', () => {
       const action = watchCmd!._actionHandler;
       await action(['test']);
 
-      expect(mockWatchService.watch).toHaveBeenCalledWith(mockStore, 2500, expect.any(Function));
+      expect(mockWatchService.watch).toHaveBeenCalledWith(
+        mockStore,
+        2500,
+        expect.any(Function),
+        expect.any(Function)
+      );
     });
 
     it('outputs watching message in normal mode', async () => {
@@ -550,8 +560,8 @@ describe('createIndexCommand - Execution Tests', () => {
 
       let capturedCallback: (() => void) | undefined;
       const mockWatchService = {
-        watch: vi.fn((store, debounce, callback) => {
-          capturedCallback = callback;
+        watch: vi.fn((store, debounce, onReindex, onError) => {
+          capturedCallback = onReindex;
         }),
         unwatchAll: vi.fn(),
       };

package/src/cli/commands/index-cmd.ts

@@ -100,11 +100,18 @@ export function createIndexCommand(getOptions: () => GlobalOptions): Command {
       if (globalOpts.quiet !== true) {
         console.log(`Watching ${store.name} for changes...`);
       }
-      await watchService.watch(store, parseInt(options.debounce ?? '1000', 10), () => {
-        if (globalOpts.quiet !== true) {
-          console.log(`Re-indexed ${store.name}`);
+      await watchService.watch(
+        store,
+        parseInt(options.debounce ?? '1000', 10),
+        () => {
+          if (globalOpts.quiet !== true) {
+            console.log(`Re-indexed ${store.name}`);
+          }
+        },
+        (error: Error) => {
+          console.error(`Watch error: ${error.message}`);
         }
-      });
+      );
 
       // Keep process alive
       process.on('SIGINT', () => {

package/src/cli/commands/store.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach, type MockInstance } from 'vitest';
 import { createStoreCommand } from './store.js';
-import { createServices } from '../../services/index.js';
+import { createServices, destroyServices } from '../../services/index.js';
 import type { GlobalOptions } from '../program.js';
 import type { FileStore, RepoStore, WebStore } from '../../types/store.js';
 import { createStoreId } from '../../types/brands.js';
@@ -10,11 +10,22 @@ vi.mock('../../services/index.js', () => ({
   destroyServices: vi.fn().mockResolvedValue(undefined),
 }));
 
+interface MockStoreService {
+  list: MockInstance;
+  getByIdOrName: MockInstance;
+  create: MockInstance;
+  delete: MockInstance;
+}
+
+interface MockServices {
+  store: MockStoreService;
+}
+
 describe('store command execution', () => {
-  let mockServices: any;
-  let consoleLogSpy: any;
-  let consoleErrorSpy: any;
-  let processExitSpy: any;
+  let mockServices: MockServices;
+  let consoleLogSpy: MockInstance;
+  let consoleErrorSpy: MockInstance;
+  let processExitSpy: MockInstance;
   let getOptions: () => GlobalOptions;
 
   beforeEach(() => {
@@ -402,10 +413,12 @@ describe('store command execution', () => {
       const actionHandler = createCommand?._actionHandler;
 
       createCommand.parseOptions(['--type', 'file', '--source', '/path/to/files']);
-      await expect(actionHandler!(['duplicate-store'])).rejects.toThrow('process.exit: 1');
+      await actionHandler!(['duplicate-store']);
 
       expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Store already exists');
-      expect(processExitSpy).toHaveBeenCalledWith(1);
+      expect(process.exitCode).toBe(1);
+      // Reset for other tests
+      process.exitCode = undefined;
     });
   });
 
@@ -536,10 +549,12 @@ describe('store command execution', () => {
       const infoCommand = command.commands.find((c) => c.name() === 'info');
       const actionHandler = infoCommand?._actionHandler;
 
-      await expect(actionHandler!(['nonexistent'])).rejects.toThrow('process.exit: 3');
+      await actionHandler!(['nonexistent']);
 
       expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Store not found: nonexistent');
-      expect(processExitSpy).toHaveBeenCalledWith(3);
+      expect(process.exitCode).toBe(3);
+      // Reset for other tests
+      process.exitCode = undefined;
     });
 
     it('can lookup store by ID', async () => {
@@ -629,11 +644,13 @@ describe('store command execution', () => {
       const actionHandler = deleteCommand?._actionHandler;
 
       deleteCommand.parseOptions(['--force']);
-      await expect(actionHandler!(['nonexistent'])).rejects.toThrow('process.exit: 3');
+      await actionHandler!(['nonexistent']);
 
       expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Store not found: nonexistent');
-      expect(processExitSpy).toHaveBeenCalledWith(3);
+      expect(process.exitCode).toBe(3);
       expect(mockServices.store.delete).not.toHaveBeenCalled();
+      // Reset for other tests
+      process.exitCode = undefined;
     });
 
     it('exits with code 1 when deletion fails', async () => {
@@ -659,10 +676,12 @@ describe('store command execution', () => {
       const actionHandler = deleteCommand?._actionHandler;
 
       deleteCommand.parseOptions(['--force']);
-      await expect(actionHandler!(['locked-store'])).rejects.toThrow('process.exit: 1');
+      await actionHandler!(['locked-store']);
 
       expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Store is locked');
-      expect(processExitSpy).toHaveBeenCalledWith(1);
+      expect(process.exitCode).toBe(1);
+      // Reset for other tests
+      process.exitCode = undefined;
     });
 
     it('exits with code 1 when force not provided in non-TTY mode', async () => {
@@ -688,12 +707,12 @@ describe('store command execution', () => {
       const deleteCommand = command.commands.find((c) => c.name() === 'delete');
       const actionHandler = deleteCommand?._actionHandler;
 
-      await expect(actionHandler!(['my-store'])).rejects.toThrow('process.exit: 1');
+      await actionHandler!(['my-store']);
 
       expect(consoleErrorSpy).toHaveBeenCalledWith(
         'Error: Use --force or -y to delete without confirmation in non-interactive mode'
       );
-      expect(processExitSpy).toHaveBeenCalledWith(1);
+      expect(process.exitCode).toBe(1);
       expect(mockServices.store.delete).not.toHaveBeenCalled();
 
       // Restore original value
@@ -701,6 +720,8 @@ describe('store command execution', () => {
         value: originalIsTTY,
         configurable: true,
       });
+      // Reset for other tests
+      process.exitCode = undefined;
     });
 
     it('prompts for confirmation in TTY mode when user confirms', async () => {
@@ -788,10 +809,11 @@ describe('store command execution', () => {
       const deleteCommand = command.commands.find((c) => c.name() === 'delete');
       const actionHandler = deleteCommand?._actionHandler;
 
-      await expect(actionHandler!(['my-store'])).rejects.toThrow('process.exit: 0');
+      await actionHandler!(['my-store']);
 
       expect(consoleLogSpy).toHaveBeenCalledWith('Cancelled.');
-      expect(processExitSpy).toHaveBeenCalledWith(0);
+      // exitCode stays 0 (undefined) for user-initiated cancellation - not an error
+      expect(process.exitCode).toBeUndefined();
       expect(mockServices.store.delete).not.toHaveBeenCalled();
 
       // Restore original value
@@ -1096,4 +1118,175 @@ describe('store command execution', () => {
       });
     });
   });
+
+  describe('destroyServices cleanup on error paths', () => {
+    it('calls destroyServices when store info returns store not found', async () => {
+      mockServices.store.getByIdOrName.mockResolvedValue(undefined);
+
+      const command = createStoreCommand(getOptions);
+      const infoCommand = command.commands.find((c) => c.name() === 'info');
+      const actionHandler = infoCommand?._actionHandler;
+
+      await actionHandler!(['nonexistent']);
+
+      // destroyServices should be called before setting exitCode
+      expect(destroyServices).toHaveBeenCalledWith(mockServices);
+      expect(process.exitCode).toBe(3);
+      process.exitCode = undefined;
+    });
+
+    it('calls destroyServices when store delete returns store not found', async () => {
+      mockServices.store.getByIdOrName.mockResolvedValue(undefined);
+
+      const command = createStoreCommand(getOptions);
+      const deleteCommand = command.commands.find((c) => c.name() === 'delete');
+      const actionHandler = deleteCommand?._actionHandler;
+
+      deleteCommand.parseOptions(['--force']);
+      await actionHandler!(['nonexistent']);
+
+      // destroyServices should be called before setting exitCode
+      expect(destroyServices).toHaveBeenCalledWith(mockServices);
+      expect(process.exitCode).toBe(3);
+      process.exitCode = undefined;
+    });
+
+    it('calls destroyServices when delete requires --force in non-TTY mode', async () => {
+      const mockStore: FileStore = {
+        id: createStoreId('store-1'),
+        name: 'my-store',
+        type: 'file',
+        path: '/path/to/files',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      mockServices.store.getByIdOrName.mockResolvedValue(mockStore);
+
+      // Mock non-TTY mode
+      const originalIsTTY = process.stdin.isTTY;
+      Object.defineProperty(process.stdin, 'isTTY', {
+        value: false,
+        configurable: true,
+      });
+
+      const command = createStoreCommand(getOptions);
+      const deleteCommand = command.commands.find((c) => c.name() === 'delete');
+      const actionHandler = deleteCommand?._actionHandler;
+
+      await actionHandler!(['my-store']);
+
+      // destroyServices should be called before setting exitCode
+      expect(destroyServices).toHaveBeenCalledWith(mockServices);
+      expect(process.exitCode).toBe(1);
+
+      // Restore
+      Object.defineProperty(process.stdin, 'isTTY', {
+        value: originalIsTTY,
+        configurable: true,
+      });
+      process.exitCode = undefined;
+    });
+
+    it('calls destroyServices when deletion fails', async () => {
+      const mockStore: FileStore = {
+        id: createStoreId('store-1'),
+        name: 'locked-store',
+        type: 'file',
+        path: '/path/to/files',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      mockServices.store.getByIdOrName.mockResolvedValue(mockStore);
+      mockServices.store.delete.mockResolvedValue({
+        success: false,
+        error: {
+          message: 'Store is locked',
+        },
+      });
+
+      const command = createStoreCommand(getOptions);
+      const deleteCommand = command.commands.find((c) => c.name() === 'delete');
+      const actionHandler = deleteCommand?._actionHandler;
+
+      deleteCommand.parseOptions(['--force']);
+      await actionHandler!(['locked-store']);
+
+      // destroyServices should be called before setting exitCode
+      expect(destroyServices).toHaveBeenCalledWith(mockServices);
+      expect(process.exitCode).toBe(1);
+      process.exitCode = undefined;
+    });
+
+    it('calls destroyServices when user cancels delete in TTY mode', async () => {
+      const mockStore: FileStore = {
+        id: createStoreId('store-1'),
+        name: 'my-store',
+        type: 'file',
+        path: '/path/to/files',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      mockServices.store.getByIdOrName.mockResolvedValue(mockStore);
+
+      // Mock TTY mode
+      const originalIsTTY = process.stdin.isTTY;
+      Object.defineProperty(process.stdin, 'isTTY', {
+        value: true,
+        configurable: true,
+      });
+
+      // Mock readline to simulate user typing 'n'
+      const mockReadline = {
+        question: vi.fn((prompt: string, callback: (answer: string) => void) => {
+          callback('n');
+        }),
+        close: vi.fn(),
+      };
+
+      vi.doMock('node:readline', () => ({
+        createInterface: vi.fn(() => mockReadline),
+      }));
+
+      const command = createStoreCommand(getOptions);
+      const deleteCommand = command.commands.find((c) => c.name() === 'delete');
+      const actionHandler = deleteCommand?._actionHandler;
+
+      await actionHandler!(['my-store']);
+
+      // destroyServices should be called even for user cancellation
+      expect(destroyServices).toHaveBeenCalledWith(mockServices);
+      // exitCode stays undefined (0) for user-initiated cancellation
+      expect(process.exitCode).toBeUndefined();
+
+      // Restore
+      Object.defineProperty(process.stdin, 'isTTY', {
+        value: originalIsTTY,
+        configurable: true,
+      });
+    });
+
+    it('calls destroyServices when create fails', async () => {
+      mockServices.store.create.mockResolvedValue({
+        success: false,
+        error: {
+          message: 'Store already exists',
+        },
+      });
+
+      const command = createStoreCommand(getOptions);
+      const createCommand = command.commands.find((c) => c.name() === 'create');
+      const actionHandler = createCommand?._actionHandler;
+
+      createCommand.parseOptions(['--type', 'file', '--source', '/path/to/files']);
+      await actionHandler!(['duplicate-store']);
+
+      // destroyServices should be called before setting exitCode
+      expect(destroyServices).toHaveBeenCalledWith(mockServices);
+      expect(process.exitCode).toBe(1);
+      process.exitCode = undefined;
+    });
+  });
 });

package/src/cli/commands/store.ts

@@ -97,7 +97,9 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
           await destroyServices(services);
         }
         if (exitCode !== 0) {
-          process.exit(exitCode);
+          // Set exit code and let Node.js exit naturally after event loop drains
+          // Using process.exit() causes mutex crashes from native code (LanceDB, tree-sitter)
+          process.exitCode = exitCode;
         }
       }
     );
@@ -108,12 +110,14 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
     .action(async (storeIdOrName: string) => {
       const globalOpts = getOptions();
       const services = await createServices(globalOpts.config, globalOpts.dataDir);
-      try {
+      let exitCode = 0;
+      storeInfo: try {
         const s = await services.store.getByIdOrName(storeIdOrName);
 
         if (s === undefined) {
           console.error(`Error: Store not found: ${storeIdOrName}`);
-          process.exit(3);
+          exitCode = 3;
+          break storeInfo;
         }
 
         if (globalOpts.format === 'json') {
@@ -132,6 +136,11 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
       } finally {
         await destroyServices(services);
       }
+      if (exitCode !== 0) {
+        // Set exit code and let Node.js exit naturally after event loop drains
+        // Using process.exit() causes mutex crashes from native code (LanceDB, tree-sitter)
+        process.exitCode = exitCode;
+      }
     });
 
   store
@@ -142,12 +151,14 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
     .action(async (storeIdOrName: string, options: { force?: boolean; yes?: boolean }) => {
       const globalOpts = getOptions();
       const services = await createServices(globalOpts.config, globalOpts.dataDir);
-      try {
+      let exitCode = 0;
+      storeDelete: try {
         const s = await services.store.getByIdOrName(storeIdOrName);
 
         if (s === undefined) {
           console.error(`Error: Store not found: ${storeIdOrName}`);
-          process.exit(3);
+          exitCode = 3;
+          break storeDelete;
         }
 
         // Require --force or -y in non-TTY mode, prompt in TTY mode
@@ -157,7 +168,8 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
             console.error(
               'Error: Use --force or -y to delete without confirmation in non-interactive mode'
             );
-            process.exit(1);
+            exitCode = 1;
+            break storeDelete;
           }
           // Interactive confirmation
           const readline = await import('node:readline');
@@ -171,7 +183,8 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
           rl.close();
           if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
             console.log('Cancelled.');
-            process.exit(0);
+            // exitCode stays 0 for user-initiated cancellation
+            break storeDelete;
           }
         }
 
@@ -181,11 +194,16 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
           console.log(`Deleted store: ${s.name}`);
         } else {
           console.error(`Error: ${result.error.message}`);
-          process.exit(1);
+          exitCode = 1;
         }
       } finally {
         await destroyServices(services);
       }
+      if (exitCode !== 0) {
+        // Set exit code and let Node.js exit naturally after event loop drains
+        // Using process.exit() causes mutex crashes from native code (LanceDB, tree-sitter)
+        process.exitCode = exitCode;
+      }
     });
 
   return store;