bluera-knowledge 0.11.17 → 0.11.19

package/src/crawl/intelligent-crawler.ts

@@ -141,17 +141,7 @@ export class IntelligentCrawler extends EventEmitter {
   ): AsyncIterable<CrawlResult> {
     // Check if Claude CLI is available before attempting intelligent mode
     if (!ClaudeClient.isAvailable()) {
-      const fallbackProgress: CrawlProgress = {
-        type: 'error',
-        pagesVisited: 0,
-        totalPages: maxPages,
-        message:
-          'Claude CLI not found, using simple crawl mode (install Claude Code for intelligent crawling)',
-        error: new Error('Claude CLI not available'),
-      };
-      this.emit('progress', fallbackProgress);
-      yield* this.crawlSimple(seedUrl, extractInstruction, maxPages, useHeadless);
-      return;
+      throw new Error('Claude CLI not available: install Claude Code for intelligent crawling');
     }
 
     let strategy: CrawlStrategy;
@@ -180,18 +170,8 @@ export class IntelligentCrawler extends EventEmitter {
       };
       this.emit('progress', strategyCompleteProgress);
     } catch (error) {
-      // Fallback to simple mode if Claude fails
-      const errorProgress: CrawlProgress = {
-        type: 'error',
-        pagesVisited: 0,
-        totalPages: maxPages,
-        message: 'Claude crawl strategy failed, falling back to simple mode',
-        error: error instanceof Error ? error : new Error(String(error)),
-      };
-      this.emit('progress', errorProgress);
-
-      yield* this.crawlSimple(seedUrl, extractInstruction, maxPages);
-      return;
+      // Re-throw strategy errors - do not fall back silently
+      throw error instanceof Error ? error : new Error(String(error));
     }
 
     // Step 3: Crawl each URL from Claude's strategy
@@ -288,12 +268,25 @@ export class IntelligentCrawler extends EventEmitter {
           }
         }
       } catch (error) {
+        const errorObj = error instanceof Error ? error : new Error(String(error));
+
+        // Re-throw non-recoverable errors (extraction failures, Claude CLI not available, headless failures)
+        // These represent failures in user-requested functionality that should not be silently skipped
+        if (
+          errorObj.message.includes('Extraction failed') ||
+          errorObj.message.includes('Claude CLI not available') ||
+          errorObj.message.includes('Headless fetch failed')
+        ) {
+          throw errorObj;
+        }
+
+        // For recoverable errors (page fetch failures), emit progress and continue
         const simpleErrorProgress: CrawlProgress = {
           type: 'error',
           pagesVisited,
           totalPages: maxPages,
           currentUrl: current.url,
-          error: error instanceof Error ? error : new Error(String(error)),
+          error: errorObj,
         };
         this.emit('progress', simpleErrorProgress);
       }
@@ -324,13 +317,9 @@ export class IntelligentCrawler extends EventEmitter {
     const html = await this.fetchHtml(url, useHeadless);
 
     // Convert to clean markdown using slurp-ai techniques
+    // Note: convertHtmlToMarkdown throws on errors, no need to check success
     const conversion = await convertHtmlToMarkdown(html, url);
 
-    if (!conversion.success) {
-      logger.error({ url, error: conversion.error }, 'HTML to markdown conversion failed');
-      throw new Error(`Failed to convert HTML: ${conversion.error ?? 'Unknown error'}`);
-    }
-
     logger.debug(
       {
         url,
@@ -344,44 +333,20 @@ export class IntelligentCrawler extends EventEmitter {
 
     // Optional: Extract specific information using Claude
     if (extractInstruction !== undefined && extractInstruction !== '') {
-      // Skip extraction if Claude CLI isn't available
+      // Throw if extraction requested but Claude CLI isn't available
       if (!ClaudeClient.isAvailable()) {
-        const skipProgress: CrawlProgress = {
-          type: 'error',
-          pagesVisited,
-          totalPages: 0,
-          currentUrl: url,
-          message: 'Skipping extraction (Claude CLI not available), storing raw markdown',
-          error: new Error('Claude CLI not available'),
-        };
-        this.emit('progress', skipProgress);
-      } else {
-        try {
-          const extractionProgress: CrawlProgress = {
-            type: 'extraction',
-            pagesVisited,
-            totalPages: 0,
-            currentUrl: url,
-          };
-          this.emit('progress', extractionProgress);
-
-          extracted = await this.claudeClient.extractContent(
-            conversion.markdown,
-            extractInstruction
-          );
-        } catch (error) {
-          // If extraction fails, just store raw markdown
-          const extractionErrorProgress: CrawlProgress = {
-            type: 'error',
-            pagesVisited,
-            totalPages: 0,
-            currentUrl: url,
-            message: 'Extraction failed, storing raw markdown',
-            error: error instanceof Error ? error : new Error(String(error)),
-          };
-          this.emit('progress', extractionErrorProgress);
-        }
+        throw new Error('Claude CLI not available: install Claude Code for extraction');
       }
+
+      const extractionProgress: CrawlProgress = {
+        type: 'extraction',
+        pagesVisited,
+        totalPages: 0,
+        currentUrl: url,
+      };
+      this.emit('progress', extractionProgress);
+
+      extracted = await this.claudeClient.extractContent(conversion.markdown, extractInstruction);
     }
 
     return {
@@ -414,10 +379,9 @@ export class IntelligentCrawler extends EventEmitter {
         );
         return result.html;
       } catch (error) {
-        // Fallback to axios if headless fails
-        logger.warn(
-          { url, error: error instanceof Error ? error.message : String(error) },
-          'Headless fetch failed, falling back to axios'
+        // Wrap with distinctive message so crawlSimple knows not to recover
+        throw new Error(
+          `Headless fetch failed: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }

package/src/plugin/git-clone.test.ts

@@ -266,6 +266,50 @@ describe('GitClone - cloneRepository', () => {
       expect(result.error.message).toContain('not found');
     }
   });
+
+  it('handles spawn error when git is not installed', async () => {
+    const mockProcess = new EventEmitter() as ChildProcess;
+    mockProcess.stderr = new EventEmitter() as any;
+
+    mockSpawn.mockImplementation(() => {
+      setImmediate(() => {
+        mockProcess.emit('error', new Error('spawn git ENOENT'));
+      });
+      return mockProcess;
+    });
+
+    const result = await cloneRepository({
+      url: 'https://github.com/user/repo.git',
+      targetDir: join(tempDir, 'repo'),
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.message).toContain('spawn git ENOENT');
+    }
+  });
+
+  it('handles spawn error with permission denied', async () => {
+    const mockProcess = new EventEmitter() as ChildProcess;
+    mockProcess.stderr = new EventEmitter() as any;
+
+    mockSpawn.mockImplementation(() => {
+      setImmediate(() => {
+        mockProcess.emit('error', new Error('spawn git EACCES'));
+      });
+      return mockProcess;
+    });
+
+    const result = await cloneRepository({
+      url: 'https://github.com/user/repo.git',
+      targetDir: join(tempDir, 'repo'),
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.message).toContain('EACCES');
+    }
+  });
 });
 
 describe('GitClone - isGitUrl', () => {

package/src/plugin/git-clone.ts

@@ -29,6 +29,10 @@ export async function cloneRepository(options: CloneOptions): Promise<Result<str
       stderr += data.toString();
     });
 
+    git.on('error', (error: Error) => {
+      resolve(err(error));
+    });
+
     git.on('close', (code: number | null) => {
       if (code === 0) {
         resolve(ok(targetDir));

package/src/services/code-unit.service.test.ts

@@ -345,7 +345,7 @@ function testLonger() {
       expect(result?.fullContent).not.toContain('testLonger');
     });
 
-    it('does NOT extract interface definitions (known limitation)', () => {
+    it('extracts interface definitions', () => {
       const code = `
 interface User {
   name: string;
@@ -355,11 +355,31 @@ interface User {
 
       const result = service.extractCodeUnit(code, 'User', 'typescript');
 
-      // Interfaces are not currently supported
-      expect(result).toBeUndefined();
+      expect(result).toBeDefined();
+      expect(result?.type).toBe('interface');
+      expect(result?.name).toBe('User');
+      expect(result?.startLine).toBe(1);
+      expect(result?.endLine).toBe(4);
+      expect(result?.fullContent).toContain('name: string');
+      expect(result?.fullContent).toContain('age: number');
+    });
+
+    it('extracts exported interface definitions', () => {
+      const code = `
+export interface Config {
+  host: string;
+  port: number;
+}
+      `.trim();
+
+      const result = service.extractCodeUnit(code, 'Config', 'typescript');
+
+      expect(result).toBeDefined();
+      expect(result?.type).toBe('interface');
+      expect(result?.signature).toBe('interface Config');
     });
 
-    it('does NOT extract type definitions (known limitation)', () => {
+    it('extracts type definitions', () => {
       const code = `
 type Config = {
   host: string;
@@ -369,8 +389,41 @@ type Config = {
 
       const result = service.extractCodeUnit(code, 'Config', 'typescript');
 
-      // Type definitions are not currently supported
-      expect(result).toBeUndefined();
+      expect(result).toBeDefined();
+      expect(result?.type).toBe('type');
+      expect(result?.name).toBe('Config');
+      expect(result?.startLine).toBe(1);
+      expect(result?.endLine).toBe(4);
+      expect(result?.fullContent).toContain('host: string');
+    });
+
+    it('extracts exported type definitions', () => {
+      const code = `
+export type Result<T> = {
+  success: boolean;
+  data: T;
+};
+      `.trim();
+
+      const result = service.extractCodeUnit(code, 'Result', 'typescript');
+
+      expect(result).toBeDefined();
+      expect(result?.type).toBe('type');
+      expect(result?.signature).toContain('type Result');
+    });
+
+    it('extracts type alias (non-object)', () => {
+      const code = `
+type UserId = string;
+      `.trim();
+
+      const result = service.extractCodeUnit(code, 'UserId', 'typescript');
+
+      expect(result).toBeDefined();
+      expect(result?.type).toBe('type');
+      expect(result?.name).toBe('UserId');
+      expect(result?.startLine).toBe(1);
+      expect(result?.endLine).toBe(1);
     });
 
     it('handles function with generics in signature', () => {

package/src/services/code-unit.service.ts

@@ -16,8 +16,6 @@ export class CodeUnitService {
     let startLine = -1;
     let type: CodeUnit['type'] = 'function';
 
-    // NOTE: Now supports function declarations, class declarations, and arrow functions (const/let/var).
-    // Does not handle interfaces or type definitions yet.
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] ?? '';
 
@@ -33,6 +31,20 @@ export class CodeUnitService {
         break;
       }
 
+      // Check for interface declarations
+      if (line.match(new RegExp(`interface\\s+${symbolName}(?:\\s|{|<)`))) {
+        startLine = i + 1;
+        type = 'interface';
+        break;
+      }
+
+      // Check for type declarations
+      if (line.match(new RegExp(`type\\s+${symbolName}(?:\\s|=|<)`))) {
+        startLine = i + 1;
+        type = 'type';
+        break;
+      }
+
       // Check for arrow functions: const/let/var name = ...
       if (line.match(new RegExp(`(?:const|let|var)\\s+${symbolName}\\s*=`))) {
         startLine = i + 1;
@@ -48,6 +60,26 @@ export class CodeUnitService {
     let braceCount = 0;
     let foundFirstBrace = false;
 
+    // For type aliases without braces (e.g., "type UserId = string;"), find semicolon
+    if (type === 'type') {
+      const firstLine = lines[startLine - 1] ?? '';
+      if (!firstLine.includes('{') && firstLine.includes(';')) {
+        // Single-line type alias
+        endLine = startLine;
+        const fullContent = firstLine;
+        const signature = this.extractSignature(firstLine, symbolName, type);
+        return {
+          type,
+          name: symbolName,
+          signature,
+          fullContent,
+          startLine,
+          endLine,
+          language,
+        };
+      }
+    }
+
     // State machine for tracking context
     let inSingleQuote = false;
     let inDoubleQuote = false;
@@ -168,6 +200,19 @@ export class CodeUnitService {
       return `class ${name}`;
     }
 
+    if (type === 'interface') {
+      return `interface ${name}`;
+    }
+
+    if (type === 'type') {
+      // For type aliases, include generics if present
+      const typeMatch = sig.match(new RegExp(`type\\s+(${name}(?:<[^>]+>)?)\\s*=`));
+      if (typeMatch?.[1] !== undefined && typeMatch[1].length > 0) {
+        return `type ${typeMatch[1]}`;
+      }
+      return `type ${name}`;
+    }
+
     if (type === 'const') {
       // For arrow functions, extract the variable declaration part
       // Example: const myFunc = (param: string): void => ...

package/src/services/index.ts

@@ -73,22 +73,38 @@ export async function createServices(
 /**
  * Cleanly shut down all services, stopping background processes.
  * Call this after CLI commands complete to allow the process to exit.
+ * Attempts all cleanup operations and throws if any fail.
  */
 export async function destroyServices(services: ServiceContainer): Promise<void> {
   logger.info('Shutting down services');
+  const errors: Error[] = [];
+
+  // Use async close to allow native threads time to cleanup
   try {
-    // Use async close to allow native threads time to cleanup
     await services.lance.closeAsync();
   } catch (e) {
-    logger.error({ error: e }, 'Error closing LanceStore');
+    const error = e instanceof Error ? e : new Error(String(e));
+    logger.error({ error }, 'Error closing LanceStore');
+    errors.push(error);
   }
+
   try {
     await services.pythonBridge.stop();
   } catch (e) {
-    logger.error({ error: e }, 'Error stopping Python bridge');
+    const error = e instanceof Error ? e : new Error(String(e));
+    logger.error({ error }, 'Error stopping Python bridge');
+    errors.push(error);
   }
+
   // Additional delay to allow native threads (LanceDB, tree-sitter, transformers)
   // to fully complete their cleanup before process exit
   await new Promise((resolve) => setTimeout(resolve, 100));
   await shutdownLogger();
+
+  // Throw if any errors occurred during cleanup
+  if (errors.length === 1 && errors[0] !== undefined) {
+    throw new Error(`Service shutdown failed: ${errors[0].message}`, { cause: errors[0] });
+  } else if (errors.length > 1) {
+    throw new AggregateError(errors, 'Multiple errors during service shutdown');
+  }
 }

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

@@ -111,6 +111,14 @@ describe('JobService', () => {
       const job = jobService.getJob('non-existent-job');
       expect(job).toBeNull();
     });
+
+    it('should throw on corrupted job file', () => {
+      // Create a corrupted job file
+      const jobFile = join(tempDir, 'jobs', 'corrupted-job.json');
+      writeFileSync(jobFile, 'invalid json{{{', 'utf-8');
+
+      expect(() => jobService.getJob('corrupted-job')).toThrow('Failed to read job');
+    });
   });
 
   describe('listJobs', () => {
@@ -138,17 +146,12 @@ describe('JobService', () => {
       expect(activeJobs.length).toBe(2);
     });
 
-    it('should skip corrupted job files', () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
+    it('should throw on corrupted job files', () => {
       // Create a corrupted job file
       const jobFile = join(tempDir, 'jobs', 'corrupted.json');
       writeFileSync(jobFile, 'invalid json{{{', 'utf-8');
 
-      const jobs = jobService.listJobs();
-      expect(jobs.length).toBe(3); // Should skip corrupted file
-
-      consoleErrorSpy.mockRestore();
+      expect(() => jobService.listJobs()).toThrow('Failed to read job file');
     });
 
     it('should skip non-JSON files', () => {

package/src/services/job.service.ts

@@ -89,8 +89,9 @@ export class JobService {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return JSON.parse(content) as Job;
     } catch (error) {
-      console.error(`Error reading job ${jobId}:`, error);
-      return null;
+      throw new Error(
+        `Failed to read job ${jobId}: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
 
@@ -124,7 +125,9 @@ export class JobService {
           jobs.push(job);
         }
       } catch (error) {
-        console.error(`Error reading job file ${file}:`, error);
+        throw new Error(
+          `Failed to read job file ${file}: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
     }
 
@@ -209,7 +212,9 @@ export class JobService {
           fs.unlinkSync(jobFile);
           cleaned++;
         } catch (error) {
-          console.error(`Error deleting job file ${job.id}:`, error);
+          throw new Error(
+            `Failed to delete job file ${job.id}: ${error instanceof Error ? error.message : String(error)}`
+          );
         }
       }
     }
@@ -231,8 +236,9 @@ export class JobService {
       fs.unlinkSync(jobFile);
       return true;
     } catch (error) {
-      console.error(`Error deleting job ${jobId}:`, error);
-      return false;
+      throw new Error(
+        `Failed to delete job ${jobId}: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
 

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 () => {