refactor(lancedb): simplify error handling for auto-heal

- Keep schema validation in initialize() where it belongs
- Only trigger auto-heal for verified 'no vector column' pattern
- Remove complex verifyTableHealth() method (48 fewer lines)
- Add test for graceful degradation on transient errors
- Gracefully degrade to keyword search for unknown errors

Addresses Greptile code review feedback on PR #8

Author: PatrickSys

src/storage/lancedb.ts

@@ -21,46 +21,24 @@ export class LanceDBStorageProvider implements VectorStorageProvider {
 
     try {
       this.storagePath = storagePath;
-
-      // Ensure directory exists
       await fs.mkdir(storagePath, { recursive: true });
 
-      // Dynamic import to avoid issues at require time
       const lancedb = await import('@lancedb/lancedb');
-
-      // Connect to database
       this.db = await lancedb.connect(storagePath);
 
-      // Check if table exists and has valid schema
+      // Check if table exists and validate schema
       const tableNames = await this.db.tableNames();
       if (tableNames.includes('code_chunks')) {
         this.table = await this.db.openTable('code_chunks');
 
-        // Validate schema has vector column (required for semantic search)
-        try {
-          const schema = await this.table.schema();
-          const hasVectorColumn = schema.fields.some((f: any) => f.name === 'vector');
-
-          if (!hasVectorColumn) {
-            console.error('Stale index detected (missing vector column). Rebuilding...');
-            await this.db.dropTable('code_chunks');
-            this.table = null;
-            throw new IndexCorruptedError('LanceDB index corrupted: missing vector column');
-          } else {
-            console.error('Opened existing LanceDB table');
-          }
-        } catch (schemaError) {
-          if (schemaError instanceof IndexCorruptedError) {
-            throw schemaError;
-          }
-          // If schema check fails, table is likely corrupted - drop and rebuild
-          console.error('Failed to validate table schema, rebuilding index...');
-          await this.db.dropTable('code_chunks');
-          this.table = null;
-          throw new IndexCorruptedError('LanceDB index corrupted: schema validation failed');
+        const schema = await this.table.schema();
+        const hasVectorColumn = schema.fields.some((f: any) => f.name === 'vector');
+
+        if (!hasVectorColumn) {
+          throw new IndexCorruptedError('LanceDB index corrupted: missing vector column');
         }
+        console.error('Opened existing LanceDB table');
       } else {
-        // Table missing entirely - not necessarily an error during initialization
         this.table = null;
       }
 
@@ -127,7 +105,6 @@ export class LanceDBStorageProvider implements VectorStorageProvider {
     filters?: SearchFilters
   ): Promise<VectorSearchResult[]> {
     if (!this.initialized || !this.table) {
-      // If table is missing, throw so auto-heal can fix it
       throw new IndexCorruptedError('LanceDB index corrupted: no table available for search');
     }
 
@@ -183,18 +160,13 @@ export class LanceDBStorageProvider implements VectorStorageProvider {
         distance: result._distance || 0
       }));
     } catch (error) {
-      if (error instanceof Error && error.message.includes('No vector column')) {
-        throw new IndexCorruptedError('LanceDB index corrupted: missing vector column');
-      }
-      console.error('Failed to search:', error);
-      // For other errors, we throw IndexCorruptedError to be safe and trigger auto-heal
-      // if it looks like a database issue
-      if (
-        error instanceof Error &&
-        (error.message.includes('LanceDB') || error.message.includes('Arrow'))
-      ) {
-        throw new IndexCorruptedError(`LanceDB runtime error: ${error.message}`);
+      // Only trigger auto-heal for verified corruption patterns
+      if (error instanceof Error && error.message.toLowerCase().includes('no vector column')) {
+        throw new IndexCorruptedError(`LanceDB index corrupted: ${error.message}`);
       }
+
+      // Transient errors - log and gracefully degrade
+      console.error('[LanceDB] Search error:', error instanceof Error ? error.message : error);
       return [];
     }
   }
@@ -223,8 +195,7 @@ export class LanceDBStorageProvider implements VectorStorageProvider {
     }
 
     try {
-      const result = await this.table.countRows();
-      return result;
+      return await this.table.countRows();
     } catch (error) {
       console.error('Failed to count rows:', error);
       return 0;

tests/lancedb-corruption.test.ts

@@ -19,7 +19,7 @@ describe('LanceDBStorageProvider corruption detection', () => {
   beforeEach(async () => {
     tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lancedb-test-'));
     lancedb.connect.mockReset();
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
   });
 
   afterEach(async () => {
@@ -28,13 +28,11 @@ describe('LanceDBStorageProvider corruption detection', () => {
   });
 
   it('throws IndexCorruptedError when vector column missing during initialize()', async () => {
-    const dropTable = vi.fn(async () => {});
     const db = {
       tableNames: vi.fn(async () => ['code_chunks']),
       openTable: vi.fn(async () => ({
         schema: vi.fn(async () => ({ fields: [{ name: 'id' }] }))
-      })),
-      dropTable
+      }))
     };
 
     lancedb.connect.mockResolvedValue(db);
@@ -43,28 +41,26 @@ describe('LanceDBStorageProvider corruption detection', () => {
     const provider = new LanceDBStorageProvider();
 
     await expect(provider.initialize(tempDir)).rejects.toBeInstanceOf(IndexCorruptedError);
-    expect(dropTable).toHaveBeenCalledWith('code_chunks');
+    // dropTable is no longer called within initialize (senior mindset: separation of concerns)
   });
 
-  it('throws IndexCorruptedError when schema validation fails during initialize()', async () => {
-    const dropTable = vi.fn(async () => {});
+  it('throws IndexCorruptedError when schema() throws during initialize()', async () => {
     const db = {
       tableNames: vi.fn(async () => ['code_chunks']),
       openTable: vi.fn(async () => ({
         schema: vi.fn(async () => {
           throw new Error('schema error');
         })
-      })),
-      dropTable
+      }))
     };
 
     lancedb.connect.mockResolvedValue(db);
 
     const { LanceDBStorageProvider } = await import('../src/storage/lancedb.js');
     const provider = new LanceDBStorageProvider();
 
-    await expect(provider.initialize(tempDir)).rejects.toBeInstanceOf(IndexCorruptedError);
-    expect(dropTable).toHaveBeenCalledWith('code_chunks');
+    // This now throws the raw error (not IndexCorruptedError) since we don't wrap all errors
+    await expect(provider.initialize(tempDir)).rejects.toThrow('schema error');
   });
 
   it('throws IndexCorruptedError when vector search fails with "No vector column"', async () => {
@@ -86,5 +82,25 @@ describe('LanceDBStorageProvider corruption detection', () => {
 
     await expect(provider.search([0.1, 0.2], 5)).rejects.toBeInstanceOf(IndexCorruptedError);
   });
-});
 
+  it('returns empty array for transient search errors', async () => {
+    const { LanceDBStorageProvider } = await import('../src/storage/lancedb.js');
+    const provider = new LanceDBStorageProvider() as any;
+
+    const query = {
+      limit: vi.fn(() => query),
+      where: vi.fn(() => query),
+      toArray: vi.fn(async () => {
+        throw new Error('Network timeout');
+      })
+    };
+
+    provider.initialized = true;
+    provider.table = {
+      vectorSearch: vi.fn(() => query)
+    };
+
+    const results = await provider.search([0.1, 0.2], 5);
+    expect(results).toEqual([]);
+  });
+});