bluera-knowledge 0.9.30 → 0.9.32

package/package.json

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

package/src/cli/commands/crawl.ts

@@ -82,6 +82,7 @@ export function createCrawlCommand(getOptions: () => GlobalOptions): Command {
       const webChunker = ChunkingService.forContentType('web');
       let pagesIndexed = 0;
       let chunksCreated = 0;
+      let exitCode = 0;
 
       // Listen for progress events
       crawler.on('progress', (progress: CrawlProgress) => {
@@ -184,10 +185,14 @@ export function createCrawlCommand(getOptions: () => GlobalOptions): Command {
         } else {
           console.error(`Error: ${message}`);
         }
-        process.exit(6);
+        exitCode = 6;
       } finally {
         await crawler.stop();
         await destroyServices(services);
       }
+
+      if (exitCode !== 0) {
+        process.exit(exitCode);
+      }
     });
 }

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

@@ -935,7 +935,7 @@ describe('store command execution', () => {
       });
     });
 
-    it('routes source to path for repo stores', async () => {
+    it('routes source to path for repo stores with local path', async () => {
       const mockStore: RepoStore = {
         id: createStoreId('store-2'),
         name: 'repo-store',
@@ -967,6 +967,73 @@ describe('store command execution', () => {
       });
     });
 
+    it('routes URL source to url for repo stores (Bug #1 fix)', async () => {
+      const mockStore: RepoStore = {
+        id: createStoreId('store-2'),
+        name: 'repo-url-store',
+        type: 'repo',
+        path: '/cloned/repo/path',
+        url: 'https://github.com/user/repo',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      mockServices.store.create.mockResolvedValue({
+        success: true,
+        data: mockStore,
+      });
+
+      const command = createStoreCommand(getOptions);
+      const createCommand = command.commands.find(c => c.name() === 'create');
+      const actionHandler = createCommand?._actionHandler;
+
+      createCommand.parseOptions(['--type', 'repo', '--source', 'https://github.com/user/repo']);
+      await actionHandler!(['repo-url-store']);
+
+      // URL should be routed to 'url' parameter, not 'path'
+      expect(mockServices.store.create).toHaveBeenCalledWith({
+        name: 'repo-url-store',
+        type: 'repo',
+        path: undefined,
+        url: 'https://github.com/user/repo',
+        description: undefined,
+        tags: undefined,
+      });
+    });
+
+    it('routes http:// URL source to url for repo stores', async () => {
+      const mockStore: RepoStore = {
+        id: createStoreId('store-2'),
+        name: 'repo-http-store',
+        type: 'repo',
+        path: '/cloned/repo/path',
+        url: 'http://internal-git.example.com/repo',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      mockServices.store.create.mockResolvedValue({
+        success: true,
+        data: mockStore,
+      });
+
+      const command = createStoreCommand(getOptions);
+      const createCommand = command.commands.find(c => c.name() === 'create');
+      const actionHandler = createCommand?._actionHandler;
+
+      createCommand.parseOptions(['--type', 'repo', '--source', 'http://internal-git.example.com/repo']);
+      await actionHandler!(['repo-http-store']);
+
+      expect(mockServices.store.create).toHaveBeenCalledWith({
+        name: 'repo-http-store',
+        type: 'repo',
+        path: undefined,
+        url: 'http://internal-git.example.com/repo',
+        description: undefined,
+        tags: undefined,
+      });
+    });
+
     it('routes source to url for web stores', async () => {
       const mockStore: WebStore = {
         id: createStoreId('store-3'),

package/src/cli/commands/store.ts

@@ -54,12 +54,15 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
     }) => {
       const globalOpts = getOptions();
       const services = await createServices(globalOpts.config, globalOpts.dataDir);
+      let exitCode = 0;
       try {
+        // Detect if source is a URL (for repo stores that should clone from remote)
+        const isUrl = options.source.startsWith('http://') || options.source.startsWith('https://');
         const result = await services.store.create({
           name,
           type: options.type,
-          path: options.type !== 'web' ? options.source : undefined,
-          url: options.type === 'web' ? options.source : undefined,
+          path: options.type === 'file' || (options.type === 'repo' && !isUrl) ? options.source : undefined,
+          url: options.type === 'web' || (options.type === 'repo' && isUrl) ? options.source : undefined,
           description: options.description,
           tags: options.tags?.split(',').map((t) => t.trim()),
         });
@@ -72,11 +75,14 @@ export function createStoreCommand(getOptions: () => GlobalOptions): Command {
           }
         } else {
           console.error(`Error: ${result.error.message}`);
-          process.exit(1);
+          exitCode = 1;
         }
       } finally {
         await destroyServices(services);
       }
+      if (exitCode !== 0) {
+        process.exit(exitCode);
+      }
     });
 
   store

package/src/db/lance.test.ts

@@ -292,6 +292,96 @@ describe('LanceStore', () => {
     });
   });
 
+  describe('close', () => {
+    it('clears tables and connection', async () => {
+      const closeStoreId = createStoreId('close-test-store');
+      const closeStore = new LanceStore(tempDir);
+      await closeStore.initialize(closeStoreId);
+
+      const doc = {
+        id: createDocumentId('close-doc'),
+        content: 'test',
+        vector: new Array(384).fill(0.1),
+        metadata: {
+          type: 'file' as const,
+          storeId: closeStoreId,
+          indexedAt: new Date(),
+        },
+      };
+
+      await closeStore.addDocuments(closeStoreId, [doc]);
+
+      // Close should not throw
+      expect(() => closeStore.close()).not.toThrow();
+    });
+
+    it('handles close when never initialized', () => {
+      const uninitializedStore = new LanceStore(tempDir);
+
+      // Should not throw even when never initialized
+      expect(() => uninitializedStore.close()).not.toThrow();
+    });
+  });
+
+  describe('closeAsync', () => {
+    it('returns a promise that resolves after cleanup', async () => {
+      const asyncCloseStoreId = createStoreId('async-close-test');
+      const asyncStore = new LanceStore(tempDir);
+      await asyncStore.initialize(asyncCloseStoreId);
+
+      const doc = {
+        id: createDocumentId('async-close-doc'),
+        content: 'test content for async close',
+        vector: new Array(384).fill(0.1),
+        metadata: {
+          type: 'file' as const,
+          storeId: asyncCloseStoreId,
+          indexedAt: new Date(),
+        },
+      };
+
+      await asyncStore.addDocuments(asyncCloseStoreId, [doc]);
+
+      // closeAsync should return a promise
+      const result = asyncStore.closeAsync();
+      expect(result).toBeInstanceOf(Promise);
+      await expect(result).resolves.not.toThrow();
+    });
+
+    it('handles closeAsync when never initialized', async () => {
+      const uninitializedStore = new LanceStore(tempDir);
+
+      // Should not throw even when never initialized
+      await expect(uninitializedStore.closeAsync()).resolves.not.toThrow();
+    });
+
+    it('allows native threads time to complete', async () => {
+      const timedStoreId = createStoreId('timed-close-test');
+      const timedStore = new LanceStore(tempDir);
+      await timedStore.initialize(timedStoreId);
+
+      const doc = {
+        id: createDocumentId('timed-doc'),
+        content: 'test',
+        vector: new Array(384).fill(0.1),
+        metadata: {
+          type: 'file' as const,
+          storeId: timedStoreId,
+          indexedAt: new Date(),
+        },
+      };
+
+      await timedStore.addDocuments(timedStoreId, [doc]);
+
+      const startTime = Date.now();
+      await timedStore.closeAsync();
+      const elapsed = Date.now() - startTime;
+
+      // Should take at least some time for native cleanup
+      expect(elapsed).toBeGreaterThanOrEqual(50);
+    });
+  });
+
   describe('multiple documents operations', () => {
     it('adds multiple documents at once', async () => {
       const multiStoreId = createStoreId('multi-doc-store');

package/src/db/lance.ts

@@ -145,6 +145,29 @@ export class LanceStore {
     }
   }
 
+  close(): void {
+    this.tables.clear();
+    if (this.connection !== null) {
+      this.connection.close();
+      this.connection = null;
+    }
+  }
+
+  /**
+   * Async close that allows native code cleanup time.
+   * Use this before process.exit() to prevent mutex crashes.
+   */
+  async closeAsync(): Promise<void> {
+    this.tables.clear();
+    if (this.connection !== null) {
+      this.connection.close();
+      this.connection = null;
+      // Allow native threads time to complete cleanup
+      // LanceDB's native code has background threads that need time
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+
   private getTableName(storeId: StoreId): string {
     return `documents_${storeId}`;
   }

package/src/services/index.ts

@@ -79,6 +79,16 @@ export async function createServices(
  */
 export async function destroyServices(services: ServiceContainer): Promise<void> {
   logger.info('Shutting down services');
-  await services.pythonBridge.stop();
+  try {
+    // Use async close to allow native threads time to cleanup
+    await services.lance.closeAsync();
+  } catch (e) {
+    logger.error({ error: e }, 'Error closing LanceStore');
+  }
+  try {
+    await services.pythonBridge.stop();
+  } catch (e) {
+    logger.error({ error: e }, 'Error stopping Python bridge');
+  }
   await shutdownLogger();
 }

package/src/services/services.test.ts

@@ -1,9 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { destroyServices, type ServiceContainer } from './index.js';
 import type { PythonBridge } from '../crawl/bridge.js';
+import type { LanceStore } from '../db/lance.js';
 
 describe('destroyServices', () => {
   let mockPythonBridge: { stop: ReturnType<typeof vi.fn> };
+  let mockLance: { closeAsync: ReturnType<typeof vi.fn>; close: ReturnType<typeof vi.fn> };
   let mockServices: ServiceContainer;
 
   beforeEach(() => {
@@ -11,8 +13,14 @@ describe('destroyServices', () => {
       stop: vi.fn().mockResolvedValue(undefined),
     };
 
+    mockLance = {
+      closeAsync: vi.fn().mockResolvedValue(undefined),
+      close: vi.fn(),
+    };
+
     mockServices = {
       pythonBridge: mockPythonBridge as unknown as PythonBridge,
+      lance: mockLance as unknown as LanceStore,
     } as unknown as ServiceContainer;
   });
 
@@ -25,8 +33,8 @@ describe('destroyServices', () => {
   it('handles stop errors gracefully', async () => {
     mockPythonBridge.stop.mockRejectedValue(new Error('stop failed'));
 
-    // destroyServices should propagate errors
-    await expect(destroyServices(mockServices)).rejects.toThrow('stop failed');
+    // destroyServices catches and logs errors instead of propagating (Bug #2 fix)
+    await expect(destroyServices(mockServices)).resolves.not.toThrow();
   });
 
   it('is idempotent - multiple calls work correctly', async () => {
@@ -35,4 +43,32 @@ describe('destroyServices', () => {
 
     expect(mockPythonBridge.stop).toHaveBeenCalledTimes(2);
   });
+
+  it('calls closeAsync on LanceStore for native cleanup', async () => {
+    await destroyServices(mockServices);
+
+    expect(mockLance.closeAsync).toHaveBeenCalledTimes(1);
+    // Should use async version, not sync
+    expect(mockLance.close).not.toHaveBeenCalled();
+  });
+
+  it('handles LanceStore closeAsync errors gracefully', async () => {
+    mockLance.closeAsync.mockRejectedValue(new Error('closeAsync failed'));
+
+    // Should not throw even if closeAsync fails
+    await expect(destroyServices(mockServices)).resolves.not.toThrow();
+  });
+
+  it('waits for LanceStore async cleanup before returning', async () => {
+    let closeCompleted = false;
+    mockLance.closeAsync.mockImplementation(async () => {
+      await new Promise(resolve => setTimeout(resolve, 50));
+      closeCompleted = true;
+    });
+
+    await destroyServices(mockServices);
+
+    // Should have waited for closeAsync to complete
+    expect(closeCompleted).toBe(true);
+  });
 });

package/src/services/store.service.test.ts

@@ -237,6 +237,34 @@ describe('StoreService', () => {
     });
   });
 
+  describe('name validation', () => {
+    it('returns error when name is empty string', async () => {
+      const result = await storeService.create({
+        name: '',
+        type: 'file',
+        path: tempDir
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('Store name cannot be empty');
+      }
+    });
+
+    it('returns error when name is whitespace only', async () => {
+      const result = await storeService.create({
+        name: '   ',
+        type: 'file',
+        path: tempDir
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('Store name cannot be empty');
+      }
+    });
+  });
+
   describe('duplicate name handling', () => {
     it('returns error when creating store with duplicate name', async () => {
       const dir1 = await mkdtemp(join(tmpdir(), 'dup1-'));

package/src/services/store.service.ts

@@ -37,6 +37,10 @@ export class StoreService {
   }
 
   async create(input: CreateStoreInput): Promise<Result<Store>> {
+    if (!input.name || input.name.trim() === '') {
+      return err(new Error('Store name cannot be empty'));
+    }
+
     const existing = await this.getByName(input.name);
     if (existing !== undefined) {
       return err(new Error(`Store with name "${input.name}" already exists`));

package/tests/integration/e2e-workflow.test.ts

@@ -70,6 +70,8 @@ describe('E2E Workflow Tests', () => {
   }, 30000);
 
   afterAll(async () => {
+    // Close LanceStore to prevent mutex crash during process exit
+    lanceStore.close();
     await rm(tempDir, { recursive: true, force: true });
   });