bluera-knowledge 0.11.18 → 0.11.20

package/src/services/search.service.ts

@@ -518,15 +518,21 @@ export class SearchService {
     const results: SearchResult[] = [];
 
     for (const storeId of stores) {
-      const hits = await this.lanceStore.fullTextSearch(storeId, query, limit);
-      results.push(
-        ...hits.map((r) => ({
-          id: r.id,
-          score: r.score,
-          content: r.content,
-          metadata: r.metadata,
-        }))
-      );
+      try {
+        const hits = await this.lanceStore.fullTextSearch(storeId, query, limit);
+        results.push(
+          ...hits.map((r) => ({
+            id: r.id,
+            score: r.score,
+            content: r.content,
+            metadata: r.metadata,
+          }))
+        );
+      } catch {
+        // FTS index may not exist for this store - continue with other stores
+        // and rely on vector search results. This is expected behavior since
+        // FTS indexing is optional and hybrid search works with vector-only.
+      }
     }
 
     return results.sort((a, b) => b.score - a.score).slice(0, limit);

package/src/services/services.test.ts

@@ -30,11 +30,12 @@ describe('destroyServices', () => {
     expect(mockPythonBridge.stop).toHaveBeenCalledTimes(1);
   });
 
-  it('handles stop errors gracefully', async () => {
+  it('throws on stop errors', async () => {
     mockPythonBridge.stop.mockRejectedValue(new Error('stop failed'));
 
-    // destroyServices catches and logs errors instead of propagating (Bug #2 fix)
-    await expect(destroyServices(mockServices)).resolves.not.toThrow();
+    await expect(destroyServices(mockServices)).rejects.toThrow(
+      'Service shutdown failed: stop failed'
+    );
   });
 
   it('is idempotent - multiple calls work correctly', async () => {
@@ -52,11 +53,23 @@ describe('destroyServices', () => {
     expect(mockLance.close).not.toHaveBeenCalled();
   });
 
-  it('handles LanceStore closeAsync errors gracefully', async () => {
+  it('throws on LanceStore closeAsync errors', async () => {
     mockLance.closeAsync.mockRejectedValue(new Error('closeAsync failed'));
 
-    // Should not throw even if closeAsync fails
-    await expect(destroyServices(mockServices)).resolves.not.toThrow();
+    await expect(destroyServices(mockServices)).rejects.toThrow(
+      'Service shutdown failed: closeAsync failed'
+    );
+  });
+
+  it('attempts all cleanup even if first fails, then throws aggregate', async () => {
+    mockLance.closeAsync.mockRejectedValue(new Error('lance failed'));
+    mockPythonBridge.stop.mockRejectedValue(new Error('bridge failed'));
+
+    await expect(destroyServices(mockServices)).rejects.toThrow();
+
+    // Both should have been called even though first failed
+    expect(mockLance.closeAsync).toHaveBeenCalledTimes(1);
+    expect(mockPythonBridge.stop).toHaveBeenCalledTimes(1);
   });
 
   it('waits for LanceStore async cleanup before returning', async () => {

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

@@ -75,10 +75,12 @@ describe('WatchService', () => {
   });
 
   describe('watch - Lifecycle', () => {
+    const noopErrorHandler = (): void => {};
+
     it('starts watching a file store', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       expect(watch).toHaveBeenCalledWith(
         mockFileStore.path,
@@ -93,13 +95,13 @@ describe('WatchService', () => {
     it('starts watching a repo store', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockRepoStore);
+      await watchService.watch(mockRepoStore, 1000, undefined, noopErrorHandler);
 
       expect(watch).toHaveBeenCalledWith(mockRepoStore.path, expect.any(Object));
     });
 
     it('sets up event handlers on watcher', async () => {
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       expect(watcher?.on).toHaveBeenCalledWith('all', expect.any(Function));
@@ -109,10 +111,10 @@ describe('WatchService', () => {
     it('does not start watching if already watching the same store', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
       const callCount1 = (watch as ReturnType<typeof vi.fn>).mock.calls.length;
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
       const callCount2 = (watch as ReturnType<typeof vi.fn>).mock.calls.length;
 
       expect(callCount2).toBe(callCount1);
@@ -121,17 +123,17 @@ describe('WatchService', () => {
     it('allows watching multiple different stores', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
-      await watchService.watch(mockRepoStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
+      await watchService.watch(mockRepoStore, 1000, undefined, noopErrorHandler);
 
       expect(watch).toHaveBeenCalledTimes(2);
     });
 
     it('resolves immediately when store is already being watched', async () => {
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const startTime = Date.now();
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
       const endTime = Date.now();
 
       // Should resolve immediately
@@ -140,8 +142,10 @@ describe('WatchService', () => {
   });
 
   describe('watch - Debounce Logic', () => {
+    const noopErrorHandler = (): void => {};
+
     it('debounces rapid file changes with default timeout', async () => {
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -236,8 +240,10 @@ describe('WatchService', () => {
   });
 
   describe('watch - Reindexing', () => {
+    const noopErrorHandler = (): void => {};
+
     it('initializes lance store before reindexing', async () => {
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -255,7 +261,7 @@ describe('WatchService', () => {
     });
 
     it('calls indexStore with correct store', async () => {
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -272,7 +278,7 @@ describe('WatchService', () => {
     it('calls onReindex callback after successful reindex', async () => {
       const onReindex = vi.fn();
 
-      await watchService.watch(mockFileStore, 1000, onReindex);
+      await watchService.watch(mockFileStore, 1000, onReindex, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -287,7 +293,7 @@ describe('WatchService', () => {
     });
 
     it('does not call onReindex if not provided', async () => {
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -303,8 +309,8 @@ describe('WatchService', () => {
     });
 
     it('handles concurrent reindexing for different stores', async () => {
-      await watchService.watch(mockFileStore);
-      await watchService.watch(mockRepoStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
+      await watchService.watch(mockRepoStore, 1000, undefined, noopErrorHandler);
 
       const watcher1 = mockWatchers[0];
       const watcher2 = mockWatchers[1];
@@ -330,12 +336,13 @@ describe('WatchService', () => {
   });
 
   describe('watch - Error Handling', () => {
-    it('logs error when reindexing fails', async () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    it('calls onError when reindexing fails', async () => {
+      const onError = vi.fn();
+      const indexError = new Error('Index failed');
 
-      mockIndexService.indexStore = vi.fn().mockRejectedValue(new Error('Index failed'));
+      mockIndexService.indexStore = vi.fn().mockRejectedValue(indexError);
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, onError);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -346,17 +353,16 @@ describe('WatchService', () => {
       vi.advanceTimersByTime(1100);
       await vi.runAllTimersAsync();
 
-      expect(consoleErrorSpy).toHaveBeenCalledWith('Error during reindexing:', expect.any(Error));
-
-      consoleErrorSpy.mockRestore();
+      expect(onError).toHaveBeenCalledWith(indexError);
     });
 
-    it('logs error when lance initialization fails', async () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    it('calls onError when lance initialization fails', async () => {
+      const onError = vi.fn();
+      const initError = new Error('Init failed');
 
-      mockLanceStore.initialize = vi.fn().mockRejectedValue(new Error('Init failed'));
+      mockLanceStore.initialize = vi.fn().mockRejectedValue(initError);
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, onError);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -367,15 +373,13 @@ describe('WatchService', () => {
       vi.advanceTimersByTime(1100);
       await vi.runAllTimersAsync();
 
-      expect(consoleErrorSpy).toHaveBeenCalledWith('Error during reindexing:', expect.any(Error));
-
-      consoleErrorSpy.mockRestore();
+      expect(onError).toHaveBeenCalledWith(initError);
     });
 
-    it('handles watcher errors', async () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    it('calls onError for watcher errors', async () => {
+      const onError = vi.fn();
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, onError);
 
       const watcher = mockWatchers[0];
       const errorHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -385,13 +389,29 @@ describe('WatchService', () => {
       const testError = new Error('Watcher error');
       errorHandler?.(testError);
 
-      expect(consoleErrorSpy).toHaveBeenCalledWith('Watcher error:', testError);
+      expect(onError).toHaveBeenCalledWith(testError);
+    });
+
+    it('requires onError callback to be provided', async () => {
+      // onError is now required - this test verifies the type signature enforces it
+      // TypeScript would catch this at compile time, but runtime behavior should still work
+      const onError = vi.fn();
+      await watchService.watch(mockFileStore, 1000, undefined, onError);
+
+      const watcher = mockWatchers[0];
+      const errorHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
+        (call: unknown[]) => call[0] === 'error'
+      )?.[1] as ((error: Error) => void) | undefined;
+
+      const testError = new Error('Watcher error');
+      errorHandler?.(testError);
 
-      consoleErrorSpy.mockRestore();
+      // Error should be passed to onError, not thrown
+      expect(onError).toHaveBeenCalledWith(testError);
     });
 
     it('continues watching after error during reindex', async () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const onError = vi.fn();
 
       // First call fails
       mockIndexService.indexStore = vi
@@ -399,7 +419,7 @@ describe('WatchService', () => {
         .mockRejectedValueOnce(new Error('First fail'))
         .mockResolvedValueOnce({ ok: true });
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, onError);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -417,15 +437,15 @@ describe('WatchService', () => {
       await vi.runAllTimersAsync();
 
       expect(mockIndexService.indexStore).toHaveBeenCalledTimes(2);
-      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
-
-      consoleErrorSpy.mockRestore();
+      expect(onError).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('unwatch', () => {
+    const noopErrorHandler = (): void => {};
+
     it('stops watching a store', async () => {
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       await watchService.unwatch(mockFileStore.id);
@@ -436,11 +456,11 @@ describe('WatchService', () => {
     it('removes watcher from internal map', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
       await watchService.unwatch(mockFileStore.id);
 
       // Trying to watch again should create new watcher
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       expect(watch).toHaveBeenCalledTimes(2);
     });
@@ -451,8 +471,8 @@ describe('WatchService', () => {
     });
 
     it('does not affect other watchers', async () => {
-      await watchService.watch(mockFileStore);
-      await watchService.watch(mockRepoStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
+      await watchService.watch(mockRepoStore, 1000, undefined, noopErrorHandler);
 
       const watcher1 = mockWatchers[0];
       const watcher2 = mockWatchers[1];
@@ -464,7 +484,7 @@ describe('WatchService', () => {
     });
 
     it('clears pending timeout to prevent timer leak', async () => {
-      await watchService.watch(mockFileStore, 1000);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const watcher = mockWatchers[0];
       const allHandler = (watcher?.on as ReturnType<typeof vi.fn>).mock.calls.find(
@@ -487,9 +507,11 @@ describe('WatchService', () => {
   });
 
   describe('unwatchAll', () => {
+    const noopErrorHandler = (): void => {};
+
     it('stops all watchers', async () => {
-      await watchService.watch(mockFileStore);
-      await watchService.watch(mockRepoStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
+      await watchService.watch(mockRepoStore, 1000, undefined, noopErrorHandler);
 
       const watcher1 = mockWatchers[0];
       const watcher2 = mockWatchers[1];
@@ -503,13 +525,13 @@ describe('WatchService', () => {
     it('clears all watchers from map', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
-      await watchService.watch(mockRepoStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
+      await watchService.watch(mockRepoStore, 1000, undefined, noopErrorHandler);
 
       await watchService.unwatchAll();
 
       // Watching again should create new watchers
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       expect(watch).toHaveBeenCalledTimes(3); // 2 initial + 1 after unwatchAll
     });
@@ -521,10 +543,12 @@ describe('WatchService', () => {
   });
 
   describe('File Watching Configuration', () => {
+    const noopErrorHandler = (): void => {};
+
     it('ignores .git directories', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const config = (watch as ReturnType<typeof vi.fn>).mock.calls[0]?.[1];
       expect(config.ignored).toBeInstanceOf(RegExp);
@@ -535,7 +559,7 @@ describe('WatchService', () => {
     it('ignores node_modules directories', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const config = (watch as ReturnType<typeof vi.fn>).mock.calls[0]?.[1];
       expect(config.ignored.test('.node_modules')).toBe(true);
@@ -545,7 +569,7 @@ describe('WatchService', () => {
     it('ignores dist and build directories', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const config = (watch as ReturnType<typeof vi.fn>).mock.calls[0]?.[1];
       expect(config.ignored.test('.dist')).toBe(true);
@@ -555,7 +579,7 @@ describe('WatchService', () => {
     it('sets persistent to true', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const config = (watch as ReturnType<typeof vi.fn>).mock.calls[0]?.[1];
       expect(config.persistent).toBe(true);
@@ -564,7 +588,7 @@ describe('WatchService', () => {
     it('sets ignoreInitial to true', async () => {
       const { watch } = await import('chokidar');
 
-      await watchService.watch(mockFileStore);
+      await watchService.watch(mockFileStore, 1000, undefined, noopErrorHandler);
 
       const config = (watch as ReturnType<typeof vi.fn>).mock.calls[0]?.[1];
       expect(config.ignoreInitial).toBe(true);

package/src/services/watch.service.ts

@@ -16,8 +16,9 @@ export class WatchService {
 
   async watch(
     store: FileStore | RepoStore,
-    debounceMs = 1000,
-    onReindex?: () => void
+    debounceMs: number,
+    onReindex: (() => void) | undefined,
+    onError: (error: Error) => void
   ): Promise<void> {
     if (this.watchers.has(store.id)) {
       return Promise.resolve(); // Already watching
@@ -40,8 +41,9 @@ export class WatchService {
             await this.lanceStore.initialize(store.id);
             await this.indexService.indexStore(store);
             onReindex?.();
-          } catch (error) {
-            console.error('Error during reindexing:', error);
+          } catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            onError(error);
           }
         })();
       }, debounceMs);
@@ -50,8 +52,9 @@ export class WatchService {
 
     watcher.on('all', reindexHandler);
 
-    watcher.on('error', (error) => {
-      console.error('Watcher error:', error);
+    watcher.on('error', (e) => {
+      const error = e instanceof Error ? e : new Error(String(e));
+      onError(error);
     });
 
     this.watchers.set(store.id, watcher);