neuronlayer 0.1.7 → 0.1.9

package/src/indexing/ast.ts

@@ -80,6 +80,30 @@ const LANGUAGE_CONFIGS: Record<string, LanguageConfig> = {
         (import_from_statement) @import
       `
     }
+  },
+  go: {
+    wasmFile: 'tree-sitter-go.wasm',
+    extensions: ['.go'],
+    queries: {
+      functions: `(function_declaration name: (identifier) @name) @func`,
+      classes: `(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @class`
+    }
+  },
+  rust: {
+    wasmFile: 'tree-sitter-rust.wasm',
+    extensions: ['.rs'],
+    queries: {
+      functions: `(function_item name: (identifier) @name) @func`,
+      classes: `(struct_item name: (type_identifier) @name) @class`
+    }
+  },
+  java: {
+    wasmFile: 'tree-sitter-java.wasm',
+    extensions: ['.java'],
+    queries: {
+      functions: `(method_declaration name: (identifier) @name) @func`,
+      classes: `(class_declaration name: (identifier) @name) @class`
+    }
   }
 };
 
@@ -95,41 +119,15 @@ export class ASTParser {
 
   async initialize(): Promise<void> {
     if (this.initialized) return;
-
-    try {
-      await Parser.init();
-      this.parser = new Parser();
-      this.initialized = true;
-      console.error('AST Parser initialized');
-    } catch (error) {
-      console.error('Failed to initialize AST parser:', error);
-      throw error;
-    }
+    // Using regex-based parsing for reliable cross-platform support
+    // Tree-sitter WASM support reserved for future enhancement
+    this.initialized = true;
   }
 
-  private async loadLanguage(langName: string): Promise<Parser.Language | null> {
-    if (this.languages.has(langName)) {
-      return this.languages.get(langName)!;
-    }
-
-    const config = LANGUAGE_CONFIGS[langName];
-    if (!config) {
-      return null;
-    }
-
-    try {
-      // Try to load from node_modules or bundled location
-      const wasmDir = join(this.dataDir, 'wasm');
-      const wasmPath = join(wasmDir, config.wasmFile);
-
-      // For now, we'll use a simplified approach without external WASM files
-      // In production, you'd download these from tree-sitter releases
-      console.error(`Language ${langName} WASM not available yet`);
-      return null;
-    } catch (error) {
-      console.error(`Failed to load language ${langName}:`, error);
-      return null;
-    }
+  private async loadLanguage(_langName: string): Promise<Parser.Language | null> {
+    // Tree-sitter WASM loading not implemented - using regex fallback
+    // Language configs are retained for future tree-sitter support
+    return null;
   }
 
   getLanguageForFile(filePath: string): string | null {
@@ -152,11 +150,13 @@ export class ASTParser {
       await this.initialize();
     }
 
-    // Use regex-based parsing as fallback since WASM loading is complex
+    // Regex-based parsing - reliable cross-platform symbol extraction
     return this.parseWithRegex(filePath, content);
   }
 
-  // Regex-based parsing fallback (works without WASM)
+  // Regex-based parsing for symbol extraction
+  // Handles: functions, classes, interfaces, types, imports, exports
+  // Supports: TypeScript, JavaScript, Python, Go, Rust, Java
   private parseWithRegex(filePath: string, content: string): {
     symbols: CodeSymbol[];
     imports: Import[];
@@ -172,6 +172,12 @@ export class ASTParser {
       this.parseTypeScriptJS(filePath, content, lines, symbols, imports, exports);
     } else if (lang === 'python') {
       this.parsePython(filePath, content, lines, symbols, imports, exports);
+    } else if (lang === 'go') {
+      this.parseGo(filePath, content, lines, symbols, imports, exports);
+    } else if (lang === 'rust') {
+      this.parseRust(filePath, content, lines, symbols, imports, exports);
+    } else if (lang === 'java') {
+      this.parseJava(filePath, content, lines, symbols, imports, exports);
     }
 
     return { symbols, imports, exports };
@@ -187,37 +193,60 @@ export class ASTParser {
   ): void {
     // Patterns for TypeScript/JavaScript
     const patterns = {
-      // Functions: function name(), const name = () =>, const name = function()
-      function: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
-      arrowFunc: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+      // Functions: function name(), export default function name(), const name = () =>
+      function: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/,
+      // Arrow functions: handles type annotations and destructured params
+      arrowFunc: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*(?::\s*[^=]+)?\s*=>/,
       // Classes
-      class: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/,
+      class: /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/,
       // Interfaces (TS only)
       interface: /^(?:export\s+)?interface\s+(\w+)/,
       // Types (TS only)
-      type: /^(?:export\s+)?type\s+(\w+)\s*=/,
-      // Imports
-      import: /^import\s+(?:(\w+)(?:\s*,\s*)?)?(?:\{([^}]+)\})?\s*from\s*['"]([^'"]+)['"]/,
-      importAll: /^import\s+\*\s+as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/,
+      type: /^(?:export\s+)?type\s+(\w+)\s*(?:<[^>]*>)?\s*=/,
+      // Imports - supports 'import type'
+      import: /^import\s+(?:type\s+)?(?:(\w+)(?:\s*,\s*)?)?(?:\{([^}]+)\})?\s*from\s*['"]([^'"]+)['"]/,
+      importAll: /^import\s+(?:type\s+)?\*\s+as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/,
       importSideEffect: /^import\s*['"]([^'"]+)['"]/,
       // Exports
-      exportNamed: /^export\s+\{([^}]+)\}/,
+      exportNamed: /^export\s+(?:type\s+)?\{([^}]+)\}/,
       exportDefault: /^export\s+default\s+(?:class|function|const|let|var)?\s*(\w+)?/,
       exportDirect: /^export\s+(?:const|let|var|function|class|interface|type|enum|async\s+function)\s+(\w+)/,
       // Enums (TS)
       enum: /^(?:export\s+)?(?:const\s+)?enum\s+(\w+)/,
-      // Methods inside classes (simplified)
-      method: /^\s+(?:async\s+)?(?:static\s+)?(?:private\s+|public\s+|protected\s+)?(\w+)\s*\([^)]*\)\s*[:{]/,
+      // Methods inside classes - handles generics, readonly, and all modifiers
+      method: /^\s+(?:async\s+)?(?:static\s+)?(?:readonly\s+)?(?:private\s+|public\s+|protected\s+)?(?:get\s+|set\s+)?(\w+)\s*(?:<[^>]+>)?\s*\(/,
     };
 
     let currentClass: { name: string; startLine: number } | null = null;
     let braceDepth = 0;
+    let inBlockComment = false;
 
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] || '';
       const trimmed = line.trim();
       const lineNum = i + 1;
 
+      // Track block comments properly
+      if (inBlockComment) {
+        if (trimmed.includes('*/')) {
+          inBlockComment = false;
+        }
+        continue;
+      }
+
+      // Skip single-line comments
+      if (trimmed.startsWith('//')) {
+        continue;
+      }
+
+      // Handle block comment start
+      if (trimmed.startsWith('/*')) {
+        if (!trimmed.includes('*/')) {
+          inBlockComment = true;
+        }
+        continue;
+      }
+
       // Track brace depth for class scope
       braceDepth += (line.match(/\{/g) || []).length;
       braceDepth -= (line.match(/\}/g) || []).length;
@@ -231,11 +260,6 @@ export class ASTParser {
         currentClass = null;
       }
 
-      // Skip comments
-      if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*')) {
-        continue;
-      }
-
       // Functions
       let match = trimmed.match(patterns.function);
       if (match && match[1]) {
@@ -511,6 +535,287 @@ export class ASTParser {
     }
   }
 
+  private parseGo(
+    filePath: string,
+    content: string,
+    lines: string[],
+    symbols: CodeSymbol[],
+    imports: Import[],
+    exports: Export[]
+  ): void {
+    let inImportBlock = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] || '';
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+
+      // Skip comments
+      if (trimmed.startsWith('//')) continue;
+
+      // Handle import blocks
+      if (trimmed === 'import (') {
+        inImportBlock = true;
+        continue;
+      }
+      if (inImportBlock && trimmed === ')') {
+        inImportBlock = false;
+        continue;
+      }
+
+      // Single import or import block item
+      const importMatch = inImportBlock
+        ? trimmed.match(/^(?:(\w+)\s+)?"([^"]+)"/)
+        : trimmed.match(/^import\s+(?:(\w+)\s+)?"([^"]+)"/);
+      if (importMatch) {
+        const alias = importMatch[1];
+        const path = importMatch[2] || '';
+        const pkg = alias || path.split('/').pop() || '';
+        imports.push({
+          fileId: 0,
+          filePath,
+          importedFrom: path,
+          importedSymbols: [pkg],
+          isDefault: false,
+          isNamespace: false,
+          lineNumber: lineNum
+        });
+        continue;
+      }
+
+      // Functions and methods
+      const funcMatch = trimmed.match(/^func\s+(?:\((\w+)\s+\*?(\w+)\)\s+)?(\w+)\s*\(/);
+      if (funcMatch) {
+        const receiver = funcMatch[2];
+        const name = receiver ? `${receiver}.${funcMatch[3]}` : (funcMatch[3] || '');
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: receiver ? 'method' : 'function',
+          name,
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: /^[A-Z]/.test(funcMatch[3] || ''),
+          signature: trimmed.split('{')[0]?.trim()
+        });
+        continue;
+      }
+
+      // Structs
+      const structMatch = trimmed.match(/^type\s+(\w+)\s+struct\s*\{?/);
+      if (structMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: 'class',
+          name: structMatch[1] || '',
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: /^[A-Z]/.test(structMatch[1] || '')
+        });
+        continue;
+      }
+
+      // Interfaces
+      const ifaceMatch = trimmed.match(/^type\s+(\w+)\s+interface\s*\{?/);
+      if (ifaceMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: 'interface',
+          name: ifaceMatch[1] || '',
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: /^[A-Z]/.test(ifaceMatch[1] || '')
+        });
+      }
+    }
+  }
+
+  private parseRust(
+    filePath: string,
+    content: string,
+    lines: string[],
+    symbols: CodeSymbol[],
+    imports: Import[],
+    exports: Export[]
+  ): void {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] || '';
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+
+      // Skip comments
+      if (trimmed.startsWith('//')) continue;
+
+      // Functions
+      const fnMatch = trimmed.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+      if (fnMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: 'function',
+          name: fnMatch[1] || '',
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith('pub'),
+          signature: trimmed.split('{')[0]?.trim()
+        });
+        continue;
+      }
+
+      // Structs
+      const structMatch = trimmed.match(/^(?:pub\s+)?struct\s+(\w+)/);
+      if (structMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: 'class',
+          name: structMatch[1] || '',
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith('pub')
+        });
+        continue;
+      }
+
+      // Enums
+      const enumMatch = trimmed.match(/^(?:pub\s+)?enum\s+(\w+)/);
+      if (enumMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: 'enum',
+          name: enumMatch[1] || '',
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith('pub')
+        });
+        continue;
+      }
+
+      // Traits (similar to interfaces)
+      const traitMatch = trimmed.match(/^(?:pub\s+)?trait\s+(\w+)/);
+      if (traitMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: 'interface',
+          name: traitMatch[1] || '',
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith('pub')
+        });
+        continue;
+      }
+
+      // Impl blocks
+      const implMatch = trimmed.match(/^impl\s+(?:<[^>]+>\s+)?(?:(\w+)\s+for\s+)?(\w+)/);
+      if (implMatch) {
+        const traitName = implMatch[1];
+        const typeName = implMatch[2] || '';
+        const name = traitName ? `${traitName} for ${typeName}` : typeName;
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: 'class',
+          name: `impl ${name}`,
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: false
+        });
+        continue;
+      }
+
+      // use statements
+      const useMatch = trimmed.match(/^(?:pub\s+)?use\s+(.+);/);
+      if (useMatch) {
+        const path = (useMatch[1] || '').replace(/::/g, '/');
+        imports.push({
+          fileId: 0,
+          filePath,
+          importedFrom: path,
+          importedSymbols: [path.split('/').pop()?.replace(/[{}]/g, '') || ''],
+          isDefault: false,
+          isNamespace: path.includes('*'),
+          lineNumber: lineNum
+        });
+      }
+    }
+  }
+
+  private parseJava(
+    filePath: string,
+    content: string,
+    lines: string[],
+    symbols: CodeSymbol[],
+    imports: Import[],
+    exports: Export[]
+  ): void {
+    let currentClass: string | null = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] || '';
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+
+      // Skip comments
+      if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) continue;
+
+      // Imports
+      const importMatch = trimmed.match(/^import\s+(?:static\s+)?([^;]+);/);
+      if (importMatch) {
+        const path = importMatch[1] || '';
+        imports.push({
+          fileId: 0,
+          filePath,
+          importedFrom: path,
+          importedSymbols: [path.split('.').pop() || ''],
+          isDefault: false,
+          isNamespace: path.endsWith('*'),
+          lineNumber: lineNum
+        });
+        continue;
+      }
+
+      // Classes and interfaces
+      const classMatch = trimmed.match(/^(?:public\s+|private\s+|protected\s+)?(?:abstract\s+)?(?:final\s+)?(class|interface|enum)\s+(\w+)/);
+      if (classMatch) {
+        currentClass = classMatch[2] || '';
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: classMatch[1] === 'interface' ? 'interface' : classMatch[1] === 'enum' ? 'enum' : 'class',
+          name: currentClass,
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.includes('public')
+        });
+        continue;
+      }
+
+      // Methods
+      const methodMatch = trimmed.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:abstract\s+)?(?:<[^>]+>\s+)?(\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/);
+      if (methodMatch && currentClass && !['if', 'for', 'while', 'switch', 'catch', 'class', 'interface', 'enum'].includes(methodMatch[2] || '')) {
+        const returnType = methodMatch[1];
+        const methodName = methodMatch[2] || '';
+        // Skip constructors (name matches class name)
+        if (methodName !== currentClass) {
+          symbols.push({
+            fileId: 0,
+            filePath,
+            kind: 'method',
+            name: `${currentClass}.${methodName}`,
+            lineStart: lineNum,
+            lineEnd: this.findBlockEnd(lines, i),
+            exported: trimmed.includes('public'),
+            signature: `${returnType} ${methodName}(...)`
+          });
+        }
+      }
+    }
+  }
+
   private findBlockEnd(lines: string[], startIndex: number): number {
     let braceCount = 0;
     let started = false;

package/src/indexing/indexer.ts

@@ -7,10 +7,10 @@ import { ASTParser } from './ast.js';
 import { FileWatcher, type FileEvent } from './watcher.js';
 import { Tier2Storage } from '../storage/tier2.js';
 import { isCodeFile, detectLanguage, hashContent, getPreview, countLines } from '../utils/files.js';
-import type { MemoryLayerConfig, IndexingProgress } from '../types/index.js';
+import type { NeuronLayerConfig, IndexingProgress } from '../types/index.js';
 
 export class Indexer extends EventEmitter {
-  private config: MemoryLayerConfig;
+  private config: NeuronLayerConfig;
   private embeddingGenerator: EmbeddingGenerator;
   private astParser: ASTParser;
   private watcher: FileWatcher;
@@ -19,7 +19,7 @@ export class Indexer extends EventEmitter {
   private pendingFiles: Set<string> = new Set();
   private processTimeout: NodeJS.Timeout | null = null;
 
-  constructor(config: MemoryLayerConfig, tier2: Tier2Storage) {
+  constructor(config: NeuronLayerConfig, tier2: Tier2Storage) {
     super();
     this.config = config;
     this.tier2 = tier2;
@@ -149,6 +149,17 @@ export class Indexer extends EventEmitter {
             const exportsWithFileId = parsed.exports.map(e => ({ ...e, fileId }));
             this.tier2.insertExports(exportsWithFileId);
           }
+
+          // Build dependency edges from imports
+          if (parsed.imports.length > 0) {
+            this.tier2.clearDependencies(fileId);
+            for (const imp of parsed.imports) {
+              const targetFile = this.tier2.resolveImportToFile(relativePath, imp.importedFrom);
+              if (targetFile) {
+                this.tier2.addDependency(fileId, targetFile.id, 'imports');
+              }
+            }
+          }
         }
       } catch (astError) {
         // AST parsing is optional, don't fail the whole index
@@ -156,6 +167,20 @@ export class Indexer extends EventEmitter {
       }
 
       this.emit('fileIndexed', relativePath);
+
+      // Emit impact warning for changed files (not during initial indexing)
+      if (!this.isIndexing) {
+        const dependents = this.tier2.getFileDependents(relativePath);
+        if (dependents.length > 0) {
+          this.emit('fileImpact', {
+            file: relativePath,
+            affectedFiles: dependents.map(d => d.file),
+            affectedCount: dependents.length,
+            imports: dependents.map(d => ({ file: d.file, symbols: d.imports }))
+          });
+        }
+      }
+
       return true; // Actually indexed
     } catch (error) {
       console.error(`Error indexing ${absolutePath}:`, error);