bluera-knowledge 0.9.21

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

@@ -0,0 +1,423 @@
+import { describe, it, expect } from 'vitest';
+import { ASTParser } from './ast-parser.js';
+
+describe('ASTParser', () => {
+  const parser = new ASTParser();
+
+  describe('Function parsing', () => {
+    it('parses basic function declaration', () => {
+      const code = 'function hello() { return "world"; }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes).toHaveLength(1);
+      expect(nodes[0]).toMatchObject({
+        type: 'function',
+        name: 'hello',
+        exported: false,
+        async: false
+      });
+    });
+
+    it('parses async function', () => {
+      const code = 'async function fetchData() { return await fetch("/api"); }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.async).toBe(true);
+      expect(nodes[0]?.name).toBe('fetchData');
+    });
+
+    it('parses exported function', () => {
+      const code = 'export function publicFn() { return true; }';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.exported).toBe(true);
+      expect(nodes[0]?.name).toBe('publicFn');
+    });
+
+    it('parses default exported function', () => {
+      const code = 'export default function main() { console.log("hi"); }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.exported).toBe(true);
+      expect(nodes[0]?.name).toBe('main');
+    });
+
+    it('captures function line numbers', () => {
+      const code = `// Comment
+function test() {
+  console.log("hello");
+  return true;
+}`;
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.startLine).toBe(2);
+      expect(nodes[0]?.endLine).toBe(5);
+    });
+
+    it('extracts function signature with parameters', () => {
+      const code = 'function add(a, b) { return a + b; }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.signature).toBe('add(a, b)');
+    });
+
+    it('handles function with no parameters', () => {
+      const code = 'function noParams() { return 42; }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.signature).toBe('noParams()');
+    });
+
+    it('ignores arrow functions (not declarations)', () => {
+      const code = 'const arrow = () => 42;';
+      const nodes = parser.parse(code, 'javascript');
+
+      // Should not capture arrow functions, only declarations
+      expect(nodes.filter(n => n.type === 'function')).toHaveLength(0);
+    });
+  });
+
+  describe('Class parsing', () => {
+    it('parses basic class declaration', () => {
+      const code = 'class MyClass { constructor() {} }';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes).toHaveLength(1);
+      expect(nodes[0]).toMatchObject({
+        type: 'class',
+        name: 'MyClass',
+        exported: false
+      });
+    });
+
+    it('parses exported class', () => {
+      const code = 'export class PublicClass {}';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.exported).toBe(true);
+      expect(nodes[0]?.name).toBe('PublicClass');
+    });
+
+    it('extracts class methods', () => {
+      const code = `class Calculator {
+  add(a, b) { return a + b; }
+  subtract(a, b) { return a - b; }
+}`;
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.methods).toHaveLength(2);
+      expect(nodes[0]?.methods?.[0]?.name).toBe('add');
+      expect(nodes[0]?.methods?.[1]?.name).toBe('subtract');
+    });
+
+    it('identifies async methods', () => {
+      const code = `class API {
+  async fetch() { return await getData(); }
+}`;
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.methods?.[0]?.async).toBe(true);
+    });
+
+    it('extracts method signatures', () => {
+      const code = `class Math {
+  multiply(x, y) { return x * y; }
+}`;
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.methods?.[0]?.signature).toBe('multiply(x, y)');
+    });
+
+    it('captures class line numbers', () => {
+      const code = `
+class Test {
+  method() {}
+}`;
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.startLine).toBe(2);
+      expect(nodes[0]?.endLine).toBe(4);
+    });
+  });
+
+  describe('Interface and type parsing (TypeScript)', () => {
+    it('parses interface declaration', () => {
+      const code = 'interface User { name: string; age: number; }';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes).toHaveLength(1);
+      expect(nodes[0]).toMatchObject({
+        type: 'interface',
+        name: 'User',
+        exported: false
+      });
+    });
+
+    it('parses exported interface', () => {
+      const code = 'export interface Config { apiKey: string; }';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.exported).toBe(true);
+      expect(nodes[0]?.name).toBe('Config');
+    });
+
+    it('captures interface line numbers', () => {
+      const code = `interface Person {
+  firstName: string;
+  lastName: string;
+}`;
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.startLine).toBe(1);
+      expect(nodes[0]?.endLine).toBe(4);
+    });
+  });
+
+  describe('Malformed code handling', () => {
+    it('returns empty array for syntax errors', () => {
+      const code = 'function broken( { this is not valid }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes).toEqual([]);
+    });
+
+    it('handles incomplete function', () => {
+      const code = 'function incomplete() {';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes).toEqual([]);
+    });
+
+    it('handles invalid TypeScript syntax', () => {
+      const code = 'interface Broken { prop: ;;;; }';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes).toEqual([]);
+    });
+
+    it('handles mixed valid and invalid code', () => {
+      const code = `
+function valid() { return true; }
+function invalid( { syntax error
+`;
+      const nodes = parser.parse(code, 'javascript');
+
+      // Should fail to parse and return empty array
+      expect(nodes).toEqual([]);
+    });
+
+    it('handles empty string', () => {
+      const nodes = parser.parse('', 'javascript');
+
+      expect(nodes).toEqual([]);
+    });
+
+    it('handles only whitespace', () => {
+      const nodes = parser.parse('   \n  \t  ', 'javascript');
+
+      expect(nodes).toEqual([]);
+    });
+
+    it('handles only comments', () => {
+      const code = `// Just a comment
+/* And a block comment */`;
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes).toEqual([]);
+    });
+  });
+
+  describe('Import extraction', () => {
+    it('extracts named imports', () => {
+      const code = 'import { foo, bar } from "module";';
+      const imports = parser.extractImports(code);
+
+      expect(imports).toHaveLength(1);
+      expect(imports[0]).toMatchObject({
+        source: 'module',
+        specifiers: ['foo', 'bar'],
+        isType: false
+      });
+    });
+
+    it('extracts default import', () => {
+      const code = 'import React from "react";';
+      const imports = parser.extractImports(code);
+
+      expect(imports[0]?.specifiers).toContain('React');
+      expect(imports[0]?.source).toBe('react');
+    });
+
+    it('extracts namespace import', () => {
+      const code = 'import * as utils from "./utils";';
+      const imports = parser.extractImports(code);
+
+      expect(imports[0]?.specifiers).toContain('utils');
+      expect(imports[0]?.source).toBe('./utils');
+    });
+
+    it('identifies type imports', () => {
+      const code = 'import type { User } from "./types";';
+      const imports = parser.extractImports(code);
+
+      expect(imports[0]?.isType).toBe(true);
+      expect(imports[0]?.source).toBe('./types');
+    });
+
+    it('extracts multiple imports', () => {
+      const code = `
+import React from "react";
+import { useState } from "react";
+import type { Props } from "./types";
+`;
+      const imports = parser.extractImports(code);
+
+      expect(imports).toHaveLength(3);
+      expect(imports[0]?.source).toBe('react');
+      expect(imports[1]?.source).toBe('react');
+      expect(imports[2]?.isType).toBe(true);
+    });
+
+    it('handles imports with aliases', () => {
+      const code = 'import { original as alias } from "module";';
+      const imports = parser.extractImports(code);
+
+      expect(imports[0]?.specifiers).toContain('alias');
+    });
+
+    it('returns empty array for malformed imports', () => {
+      const code = 'import { broken from "module"';
+      const imports = parser.extractImports(code);
+
+      expect(imports).toEqual([]);
+    });
+
+    it('handles file with no imports', () => {
+      const code = 'function test() { return 42; }';
+      const imports = parser.extractImports(code);
+
+      expect(imports).toEqual([]);
+    });
+
+    it('handles empty file', () => {
+      const imports = parser.extractImports('');
+
+      expect(imports).toEqual([]);
+    });
+  });
+
+  describe('Export detection', () => {
+    it('detects named export', () => {
+      const code = 'export function namedExport() {}';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.exported).toBe(true);
+    });
+
+    it('detects default export', () => {
+      const code = 'export default function defaultExport() {}';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.exported).toBe(true);
+    });
+
+    it('detects non-exported functions', () => {
+      const code = 'function privateFunction() {}';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.exported).toBe(false);
+    });
+
+    it('detects exported class', () => {
+      const code = 'export class ExportedClass {}';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.exported).toBe(true);
+    });
+
+    it('detects exported interface', () => {
+      const code = 'export interface ExportedInterface { prop: string; }';
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.exported).toBe(true);
+    });
+  });
+
+  describe('Module system handling', () => {
+    it('handles CJS/ESM module variations', () => {
+      // This test ensures the getTraverse function handles both module formats
+      // The actual implementation is tested by the fact that all other tests work
+      const code = 'function test() { return true; }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes).toHaveLength(1);
+      expect(nodes[0]?.name).toBe('test');
+    });
+  });
+
+  describe('Edge cases and special scenarios', () => {
+    it('handles functions with complex destructured parameters', () => {
+      const code = 'function complex({ a, b }, [c, d]) { return a + b + c + d; }';
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.name).toBe('complex');
+      expect(nodes[0]?.signature).toContain('complex(');
+    });
+
+    it('handles JSX in TypeScript', () => {
+      const code = `
+function Component() {
+  return <div>Hello</div>;
+}`;
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes[0]?.name).toBe('Component');
+    });
+
+    it('handles multiple declarations in one file', () => {
+      const code = `
+function fn1() {}
+class Class1 {}
+interface Interface1 {}
+function fn2() {}
+`;
+      const nodes = parser.parse(code, 'typescript');
+
+      expect(nodes).toHaveLength(4);
+      expect(nodes.map(n => n.name)).toEqual(['fn1', 'Class1', 'Interface1', 'fn2']);
+    });
+
+    it('handles anonymous function expressions (no id)', () => {
+      const code = 'export default function() { return 42; }';
+      const nodes = parser.parse(code, 'javascript');
+
+      // Anonymous functions don't have an id, should be skipped
+      expect(nodes.filter(n => n.name)).toHaveLength(0);
+    });
+
+    it('handles class with constructor', () => {
+      const code = `class MyClass {
+  constructor(name) {
+    this.name = name;
+  }
+}`;
+      const nodes = parser.parse(code, 'javascript');
+
+      expect(nodes[0]?.name).toBe('MyClass');
+      // Constructor is a method
+      expect(nodes[0]?.methods?.some(m => m.name === 'constructor')).toBe(true);
+    });
+
+    it('handles very long file with many declarations', () => {
+      const functions = Array.from({ length: 50 }, (_, i) =>
+        `function fn${i}() { return ${i}; }`
+      ).join('\n');
+
+      const nodes = parser.parse(functions, 'javascript');
+
+      expect(nodes).toHaveLength(50);
+      expect(nodes[0]?.name).toBe('fn0');
+      expect(nodes[49]?.name).toBe('fn49');
+    });
+  });
+});

package/src/analysis/ast-parser.ts

@@ -0,0 +1,192 @@
+import { parse, type ParserPlugin } from '@babel/parser';
+import type { NodePath } from '@babel/traverse';
+import traverseModule from '@babel/traverse';
+import * as t from '@babel/types';
+
+// Handle both ESM and CJS module formats
+type TraverseFunction = (ast: t.File, visitor: Record<string, unknown>) => void;
+function getTraverse(mod: unknown): TraverseFunction {
+  if (typeof mod === 'function') {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return mod as TraverseFunction;
+  }
+  if (mod !== null && typeof mod === 'object' && 'default' in mod) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const withDefault = mod as { default: unknown };
+    if (typeof withDefault.default === 'function') {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return withDefault.default as TraverseFunction;
+    }
+  }
+  throw new Error('Invalid traverse module export');
+}
+const traverse = getTraverse(traverseModule);
+
+export interface CodeNode {
+  type: 'function' | 'class' | 'interface' | 'type' | 'const';
+  name: string;
+  exported: boolean;
+  async?: boolean;
+  startLine: number;
+  endLine: number;
+  signature?: string;
+  methods?: Array<{
+    name: string;
+    async: boolean;
+    signature: string;
+    startLine: number;
+    endLine: number;
+  }>;
+}
+
+export interface ImportInfo {
+  source: string;
+  specifiers: string[];
+  isType: boolean;
+}
+
+export class ASTParser {
+  parse(code: string, language: 'typescript' | 'javascript'): CodeNode[] {
+    try {
+      const plugins: ParserPlugin[] = ['jsx'];
+      if (language === 'typescript') {
+        plugins.push('typescript');
+      }
+
+      const ast = parse(code, {
+        sourceType: 'module',
+        plugins
+      });
+
+      const nodes: CodeNode[] = [];
+
+      traverse(ast, {
+        FunctionDeclaration: (path: NodePath<t.FunctionDeclaration>) => {
+          const node = path.node;
+          if (!node.id) return;
+
+          const exported = path.parent.type === 'ExportNamedDeclaration' ||
+                          path.parent.type === 'ExportDefaultDeclaration';
+
+          nodes.push({
+            type: 'function',
+            name: node.id.name,
+            exported,
+            async: node.async,
+            startLine: node.loc?.start.line ?? 0,
+            endLine: node.loc?.end.line ?? 0,
+            signature: this.extractFunctionSignature(node)
+          });
+        },
+
+        ClassDeclaration: (path: NodePath<t.ClassDeclaration>) => {
+          const node = path.node;
+          if (!node.id) return;
+
+          const exported = path.parent.type === 'ExportNamedDeclaration' ||
+                          path.parent.type === 'ExportDefaultDeclaration';
+
+          const methods: CodeNode['methods'] = [];
+
+          for (const member of node.body.body) {
+            if (t.isClassMethod(member) && t.isIdentifier(member.key)) {
+              methods.push({
+                name: member.key.name,
+                async: member.async,
+                signature: this.extractMethodSignature(member),
+                startLine: member.loc?.start.line ?? 0,
+                endLine: member.loc?.end.line ?? 0
+              });
+            }
+          }
+
+          nodes.push({
+            type: 'class',
+            name: node.id.name,
+            exported,
+            startLine: node.loc?.start.line ?? 0,
+            endLine: node.loc?.end.line ?? 0,
+            methods
+          });
+        },
+
+        TSInterfaceDeclaration: (path: NodePath<t.TSInterfaceDeclaration>) => {
+          const node = path.node;
+
+          const exported = path.parent.type === 'ExportNamedDeclaration';
+
+          nodes.push({
+            type: 'interface',
+            name: node.id.name,
+            exported,
+            startLine: node.loc?.start.line ?? 0,
+            endLine: node.loc?.end.line ?? 0
+          });
+        }
+      });
+
+      return nodes;
+    } catch {
+      // Return empty array for malformed code
+      return [];
+    }
+  }
+
+  extractImports(code: string): ImportInfo[] {
+    try {
+      const ast = parse(code, {
+        sourceType: 'module',
+        plugins: ['typescript', 'jsx']
+      });
+
+      const imports: ImportInfo[] = [];
+
+      traverse(ast, {
+        ImportDeclaration: (path: NodePath<t.ImportDeclaration>) => {
+          const node = path.node;
+          const specifiers: string[] = [];
+
+          for (const spec of node.specifiers) {
+            if (t.isImportDefaultSpecifier(spec)) {
+              specifiers.push(spec.local.name);
+            } else if (t.isImportSpecifier(spec)) {
+              specifiers.push(spec.local.name);
+            } else if (t.isImportNamespaceSpecifier(spec)) {
+              specifiers.push(spec.local.name);
+            }
+          }
+
+          imports.push({
+            source: node.source.value,
+            specifiers,
+            isType: node.importKind === 'type'
+          });
+        }
+      });
+
+      return imports;
+    } catch {
+      // Return empty array for malformed code
+      return [];
+    }
+  }
+
+  private extractFunctionSignature(node: t.FunctionDeclaration): string {
+    const params = node.params.map(p => {
+      if (t.isIdentifier(p)) return p.name;
+      return 'param';
+    }).join(', ');
+
+    return `${node.id?.name ?? 'anonymous'}(${params})`;
+  }
+
+  private extractMethodSignature(node: t.ClassMethod): string {
+    const params = node.params.map(p => {
+      if (t.isIdentifier(p)) return p.name;
+      return 'param';
+    }).join(', ');
+
+    const name = t.isIdentifier(node.key) ? node.key.name : 'method';
+    return `${name}(${params})`;
+  }
+}