bluera-knowledge 0.13.3 → 0.14.1

package/src/analysis/parser-factory.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ParserFactory } from './parser-factory.js';
-import type { PythonBridge, ParsePythonResult } from '../crawl/bridge.js';
-import { AdapterRegistry } from './adapter-registry.js';
-import type { LanguageAdapter } from './language-adapter.js';
-import type { CodeNode, ImportInfo } from './ast-parser.js';
-
-describe('ParserFactory', () => {
-  describe('parseFile', () => {
-    it('parses .ts files with ASTParser typescript', async () => {
-      const factory = new ParserFactory();
-      const code = 'export function hello(): string { return "world"; }';
-      const nodes = await factory.parseFile('test.ts', code);
-
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'hello',
-        exported: true,
-      });
-    });
-
-    it('parses .tsx files with ASTParser typescript', async () => {
-      const factory = new ParserFactory();
-      const code = 'export function Button() { return <button>Click</button>; }';
-      const nodes = await factory.parseFile('component.tsx', code);
-
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]?.name).toBe('Button');
-    });
-
-    it('parses .js files with ASTParser javascript', async () => {
-      const factory = new ParserFactory();
-      const code = 'export function add(a, b) { return a + b; }';
-      const nodes = await factory.parseFile('math.js', code);
-
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'add',
-        exported: true,
-      });
-    });
-
-    it('parses .jsx files with ASTParser javascript', async () => {
-      const factory = new ParserFactory();
-      const code = 'export function Card() { return <div>Card</div>; }';
-      const nodes = await factory.parseFile('card.jsx', code);
-
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]?.name).toBe('Card');
-    });
-
-    it('parses .py files with PythonASTParser when bridge available', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [
-          {
-            type: 'function',
-            name: 'greet',
-            exported: true,
-            startLine: 1,
-            endLine: 2,
-            signature: 'def greet(name: str) -> str',
-          },
-        ],
-      };
-
-      const mockBridge = {
-        parsePython: vi.fn().mockResolvedValue(mockResult),
-      } as unknown as PythonBridge;
-
-      const factory = new ParserFactory(mockBridge);
-      const code = 'def greet(name: str) -> str:\n    return f"Hello {name}"';
-      const nodes = await factory.parseFile('hello.py', code);
-
-      expect(mockBridge.parsePython).toHaveBeenCalledWith(code, 'hello.py');
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'greet',
-        exported: true,
-      });
-    });
-
-    it('throws error for .py files when pythonBridge not available', async () => {
-      const factory = new ParserFactory();
-      const code = 'def hello(): pass';
-
-      await expect(factory.parseFile('test.py', code)).rejects.toThrow(
-        'Python bridge not available for parsing Python files'
-      );
-    });
-
-    it('parses .rs files with RustASTParser', async () => {
-      const factory = new ParserFactory();
-      const code = 'pub fn calculate(x: i32) -> i32 { x * 2 }';
-      const nodes = await factory.parseFile('lib.rs', code);
-
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'calculate',
-        exported: true,
-      });
-    });
-
-    it('parses .go files with GoASTParser', async () => {
-      const factory = new ParserFactory();
-      const code = 'package main\n\nfunc Add(a, b int) int { return a + b }';
-      const nodes = await factory.parseFile('main.go', code);
-
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'Add',
-        exported: true,
-      });
-    });
-
-    it('returns empty array for unsupported file extensions', async () => {
-      const factory = new ParserFactory();
-      const code = '/* some C code */ int main() { return 0; }';
-      const nodes = await factory.parseFile('main.c', code);
-
-      expect(nodes).toEqual([]);
-    });
-
-    it('returns empty array for unknown file extensions', async () => {
-      const factory = new ParserFactory();
-      const nodes = await factory.parseFile('data.yaml', 'key: value');
-
-      expect(nodes).toEqual([]);
-    });
-  });
-
-  describe('adapter integration', () => {
-    beforeEach(() => {
-      // Reset adapter registry before each test
-      AdapterRegistry.resetInstance();
-    });
-
-    it('should use registered adapter for unknown extension', async () => {
-      const mockNodes: CodeNode[] = [
-        {
-          type: 'function',
-          name: 'V-LOOK',
-          exported: true,
-          startLine: 1,
-          endLine: 5,
-          signature: 'ROUTINE V-LOOK ()',
-        },
-      ];
-
-      const mockAdapter: LanguageAdapter = {
-        languageId: 'zil',
-        extensions: ['.zil'],
-        displayName: 'ZIL',
-        parse: vi.fn().mockReturnValue(mockNodes),
-        extractImports: vi.fn().mockReturnValue([]),
-      };
-
-      const registry = AdapterRegistry.getInstance();
-      registry.register(mockAdapter);
-
-      const factory = new ParserFactory();
-      const code = '<ROUTINE V-LOOK () <TELL "You see nothing special.">>';
-      const nodes = await factory.parseFile('actions.zil', code);
-
-      expect(mockAdapter.parse).toHaveBeenCalledWith(code, 'actions.zil');
-      expect(nodes).toEqual(mockNodes);
-    });
-
-    it('should prefer built-in parser over adapter for supported extensions', async () => {
-      // Register an adapter that claims to handle .ts files
-      const mockAdapter: LanguageAdapter = {
-        languageId: 'fake-ts',
-        extensions: ['.ts'],
-        displayName: 'Fake TypeScript',
-        parse: vi.fn().mockReturnValue([]),
-        extractImports: vi.fn().mockReturnValue([]),
-      };
-
-      // This should throw because .ts is handled by built-in
-      // But we want built-in to take precedence, so adapter shouldn't even be called
-      // Actually, registration should work, but built-in should be used first
-
-      // For now, test that built-in works even if we could register
-      const factory = new ParserFactory();
-      const code = 'export function hello(): string { return "world"; }';
-      const nodes = await factory.parseFile('test.ts', code);
-
-      // Built-in parser should work
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'hello',
-      });
-
-      // Adapter should not have been called (it wasn't registered in this test)
-      expect(mockAdapter.parse).not.toHaveBeenCalled();
-    });
-
-    it('should return empty array when no adapter and unsupported extension', async () => {
-      const factory = new ParserFactory();
-      const nodes = await factory.parseFile('unknown.xyz', 'some content');
-
-      expect(nodes).toEqual([]);
-    });
-  });
-});

package/src/analysis/parser-factory.ts

@@ -1,52 +0,0 @@
-import path from 'node:path';
-import { AdapterRegistry } from './adapter-registry.js';
-import { ASTParser, type CodeNode } from './ast-parser.js';
-import { GoASTParser } from './go-ast-parser.js';
-import { PythonASTParser } from './python-ast-parser.js';
-import { RustASTParser } from './rust-ast-parser.js';
-import type { PythonBridge } from '../crawl/bridge.js';
-
-export class ParserFactory {
-  constructor(private readonly pythonBridge?: PythonBridge) {}
-
-  async parseFile(filePath: string, code: string): Promise<CodeNode[]> {
-    const ext = path.extname(filePath);
-
-    if (['.ts', '.tsx'].includes(ext)) {
-      const parser = new ASTParser();
-      return parser.parse(code, 'typescript');
-    }
-
-    if (['.js', '.jsx'].includes(ext)) {
-      const parser = new ASTParser();
-      return parser.parse(code, 'javascript');
-    }
-
-    if (ext === '.py') {
-      if (!this.pythonBridge) {
-        throw new Error('Python bridge not available for parsing Python files');
-      }
-      const parser = new PythonASTParser(this.pythonBridge);
-      return parser.parse(code, filePath);
-    }
-
-    if (ext === '.rs') {
-      const parser = new RustASTParser();
-      return parser.parse(code, filePath);
-    }
-
-    if (ext === '.go') {
-      const parser = new GoASTParser();
-      return parser.parse(code, filePath);
-    }
-
-    // Check for registered language adapters
-    const registry = AdapterRegistry.getInstance();
-    const adapter = registry.getByExtension(ext);
-    if (adapter !== undefined) {
-      return adapter.parse(code, filePath);
-    }
-
-    return [];
-  }
-}

package/src/analysis/python-ast-parser.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PythonASTParser } from './python-ast-parser.js';
-import type { PythonBridge, ParsePythonResult } from '../crawl/bridge.js';
-
-function createMockBridge(result: ParsePythonResult): PythonBridge {
-  return {
-    parsePython: vi.fn().mockResolvedValue(result),
-  } as unknown as PythonBridge;
-}
-
-describe('PythonASTParser', () => {
-  describe('parse', () => {
-    it('parses Python code and returns CodeNodes', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [
-          {
-            type: 'function',
-            name: 'hello',
-            exported: true,
-            startLine: 1,
-            endLine: 2,
-          },
-        ],
-        imports: [],
-      };
-
-      const bridge = createMockBridge(mockResult);
-      const parser = new PythonASTParser(bridge);
-      const nodes = await parser.parse('def hello(): pass', 'test.py');
-
-      expect(bridge.parsePython).toHaveBeenCalledWith('def hello(): pass', 'test.py');
-      expect(nodes).toHaveLength(1);
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'hello',
-        exported: true,
-        startLine: 1,
-        endLine: 2,
-      });
-    });
-
-    it('handles async functions', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [
-          {
-            type: 'function',
-            name: 'fetch_data',
-            exported: true,
-            startLine: 1,
-            endLine: 3,
-            async: true,
-          },
-        ],
-        imports: [],
-      };
-
-      const bridge = createMockBridge(mockResult);
-      const parser = new PythonASTParser(bridge);
-      const nodes = await parser.parse('async def fetch_data(): pass', 'async.py');
-
-      expect(nodes[0]?.async).toBe(true);
-      expect(nodes[0]?.name).toBe('fetch_data');
-    });
-
-    it('handles function signatures', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [
-          {
-            type: 'function',
-            name: 'greet',
-            exported: true,
-            startLine: 1,
-            endLine: 2,
-            signature: 'def greet(name: str) -> str',
-          },
-        ],
-        imports: [],
-      };
-
-      const bridge = createMockBridge(mockResult);
-      const parser = new PythonASTParser(bridge);
-      const nodes = await parser.parse('def greet(name: str) -> str: pass', 'greet.py');
-
-      expect(nodes[0]?.signature).toBe('def greet(name: str) -> str');
-    });
-
-    it('handles class methods', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [
-          {
-            type: 'class',
-            name: 'Calculator',
-            exported: true,
-            startLine: 1,
-            endLine: 10,
-            methods: [
-              {
-                name: 'add',
-                async: false,
-                signature: 'def add(self, a: int, b: int) -> int',
-                startLine: 2,
-                endLine: 3,
-                calls: [],
-              },
-              {
-                name: 'subtract',
-                async: false,
-                signature: 'def subtract(self, a: int, b: int) -> int',
-                startLine: 4,
-                endLine: 5,
-                calls: [],
-              },
-            ],
-          },
-        ],
-        imports: [],
-      };
-
-      const bridge = createMockBridge(mockResult);
-      const parser = new PythonASTParser(bridge);
-      const nodes = await parser.parse('class Calculator: pass', 'calc.py');
-
-      expect(nodes[0]?.type).toBe('class');
-      expect(nodes[0]?.methods).toHaveLength(2);
-      expect(nodes[0]?.methods?.[0]?.name).toBe('add');
-      expect(nodes[0]?.methods?.[1]?.name).toBe('subtract');
-    });
-
-    it('handles nodes without optional fields', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [
-          {
-            type: 'function',
-            name: 'simple',
-            exported: false,
-            startLine: 1,
-            endLine: 1,
-            // No async, signature, or methods
-          },
-        ],
-        imports: [],
-      };
-
-      const bridge = createMockBridge(mockResult);
-      const parser = new PythonASTParser(bridge);
-      const nodes = await parser.parse('def simple(): pass', 'simple.py');
-
-      expect(nodes[0]).toMatchObject({
-        type: 'function',
-        name: 'simple',
-        exported: false,
-      });
-      // Optional fields should not be present
-      expect(nodes[0]?.async).toBeUndefined();
-      expect(nodes[0]?.signature).toBeUndefined();
-      expect(nodes[0]?.methods).toBeUndefined();
-    });
-
-    it('handles multiple nodes', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [
-          {
-            type: 'function',
-            name: 'func1',
-            exported: true,
-            startLine: 1,
-            endLine: 2,
-          },
-          {
-            type: 'class',
-            name: 'MyClass',
-            exported: true,
-            startLine: 3,
-            endLine: 10,
-          },
-          {
-            type: 'function',
-            name: 'func2',
-            exported: false,
-            startLine: 11,
-            endLine: 12,
-          },
-        ],
-        imports: [],
-      };
-
-      const bridge = createMockBridge(mockResult);
-      const parser = new PythonASTParser(bridge);
-      const nodes = await parser.parse('# multiple definitions', 'multi.py');
-
-      expect(nodes).toHaveLength(3);
-      expect(nodes[0]?.name).toBe('func1');
-      expect(nodes[1]?.name).toBe('MyClass');
-      expect(nodes[2]?.name).toBe('func2');
-    });
-
-    it('returns empty array when no nodes found', async () => {
-      const mockResult: ParsePythonResult = {
-        nodes: [],
-        imports: [],
-      };
-
-      const bridge = createMockBridge(mockResult);
-      const parser = new PythonASTParser(bridge);
-      const nodes = await parser.parse('# just a comment', 'empty.py');
-
-      expect(nodes).toEqual([]);
-    });
-  });
-});

package/src/analysis/python-ast-parser.ts

@@ -1,34 +0,0 @@
-import type { CodeNode } from './ast-parser.js';
-import type { PythonBridge, ParsePythonResult } from '../crawl/bridge.js';
-
-export class PythonASTParser {
-  constructor(private readonly bridge: PythonBridge) {}
-
-  async parse(code: string, filePath: string): Promise<CodeNode[]> {
-    const result: ParsePythonResult = await this.bridge.parsePython(code, filePath);
-
-    return result.nodes.map((node) => {
-      const codeNode: CodeNode = {
-        type: node.type,
-        name: node.name,
-        exported: node.exported,
-        startLine: node.startLine,
-        endLine: node.endLine,
-      };
-
-      if (node.async !== undefined) {
-        codeNode.async = node.async;
-      }
-
-      if (node.signature !== undefined) {
-        codeNode.signature = node.signature;
-      }
-
-      if (node.methods !== undefined) {
-        codeNode.methods = node.methods;
-      }
-
-      return codeNode;
-    });
-  }
-}