bluera-knowledge 0.9.30 → 0.9.31

package/package.json

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

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,37 @@ 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('multiple documents operations', () => {
     it('adds multiple documents at once', async () => {
       const multiStoreId = createStoreId('multi-doc-store');

package/src/db/lance.ts

@@ -145,6 +145,14 @@ export class LanceStore {
     }
   }
 
+  close(): void {
+    this.tables.clear();
+    if (this.connection !== null) {
+      this.connection.close();
+      this.connection = null;
+    }
+  }
+
   private getTableName(storeId: StoreId): string {
     return `documents_${storeId}`;
   }

package/src/services/index.ts

@@ -79,6 +79,15 @@ export async function createServices(
  */
 export async function destroyServices(services: ServiceContainer): Promise<void> {
   logger.info('Shutting down services');
-  await services.pythonBridge.stop();
+  try {
+    services.lance.close();
+  } 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

@@ -25,8 +25,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 () => {

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`));