neuronlayer 0.1.6 → 0.1.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "neuronlayer",
-  "version": "0.1.6",
-  "description": "Persistent memory layer for AI coding assistants - MCP server that makes AI truly understand your codebase",
+  "version": "0.1.8",
+  "description": "Code intelligence layer disguised as memory - MCP server giving AI persistent understanding of your codebase",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/src/cli/commands.ts

@@ -159,13 +159,19 @@ export function exportDecisions(
     };
   }
 
-  // Open database and get decisions
-  const dbPath = join(projectInfo.dataDir, 'memorylayer.db');
+  // Open database and get decisions (check both new and old names)
+  let dbPath = join(projectInfo.dataDir, 'neuronlayer.db');
   if (!existsSync(dbPath)) {
-    return {
-      success: false,
-      message: `Project database not found. Has the project been indexed?`
-    };
+    // Fall back to old name for backwards compatibility
+    const oldDbPath = join(projectInfo.dataDir, 'memorylayer.db');
+    if (existsSync(oldDbPath)) {
+      dbPath = oldDbPath;
+    } else {
+      return {
+        success: false,
+        message: `Project database not found. Has the project been indexed?`
+      };
+    }
   }
 
   const db = initializeDatabase(dbPath);

package/src/core/engine.ts

@@ -1,5 +1,5 @@
 import { join, basename } from 'path';
-import { existsSync, mkdirSync, readFileSync, statSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, statSync, renameSync } from 'fs';
 import { initializeDatabase, closeDatabase } from '../storage/database.js';
 import { Tier1Storage } from '../storage/tier1.js';
 import { Tier2Storage } from '../storage/tier2.js';
@@ -68,8 +68,22 @@ export class MemoryLayerEngine {
       mkdirSync(config.dataDir, { recursive: true });
     }
 
-    // Initialize database
-    const dbPath = join(config.dataDir, 'memorylayer.db');
+    // Initialize database (with migration from old name)
+    let dbPath = join(config.dataDir, 'neuronlayer.db');
+    const oldDbPath = join(config.dataDir, 'memorylayer.db');
+
+    // Migrate from old database name if it exists
+    if (!existsSync(dbPath) && existsSync(oldDbPath)) {
+      try {
+        console.error('Migrating database from memorylayer.db to neuronlayer.db...');
+        renameSync(oldDbPath, dbPath);
+      } catch (err) {
+        // If rename fails (file locked), use the old database path
+        console.error('Migration skipped (file in use), using existing database');
+        dbPath = oldDbPath;
+      }
+    }
+
     this.db = initializeDatabase(dbPath);
 
     // Initialize storage tiers
@@ -214,6 +228,16 @@ export class MemoryLayerEngine {
       this.updateProjectStats();
       // Extract decisions from git and comments
       this.extractDecisions().catch(err => console.error('Decision extraction error:', err));
+
+      // Index tests after code indexing is complete
+      try {
+        const testResult = this.testAwareness.refreshIndex();
+        if (testResult.testsIndexed > 0) {
+          console.error(`Test index: ${testResult.testsIndexed} tests (${testResult.framework})`);
+        }
+      } catch (err) {
+        console.error('Test indexing error:', err);
+      }
     });
 
     this.indexer.on('fileIndexed', (path) => {
@@ -224,6 +248,22 @@ export class MemoryLayerEngine {
       this.summarizer.invalidateSummaryByPath(path);
     });
 
+    this.indexer.on('fileImpact', (impact: { file: string; affectedFiles: string[]; affectedCount: number }) => {
+      // Log impact warning for file changes
+      if (impact.affectedCount > 0) {
+        console.error(`[Impact] ${impact.file} changed → ${impact.affectedCount} file(s) may be affected`);
+        if (impact.affectedCount <= 5) {
+          impact.affectedFiles.forEach(f => console.error(`  → ${f}`));
+        } else {
+          impact.affectedFiles.slice(0, 3).forEach(f => console.error(`  → ${f}`));
+          console.error(`  ... and ${impact.affectedCount - 3} more`);
+        }
+
+        // Track impact in ghost mode for proactive warnings
+        this.ghostMode.onFileImpact(impact.file, impact.affectedFiles);
+      }
+    });
+
     this.indexer.on('error', (error) => {
       console.error('Indexer error:', error);
     });
@@ -727,6 +767,16 @@ export class MemoryLayerEngine {
     return { imports, importedBy, symbols };
   }
 
+  // Find circular dependencies in the project
+  findCircularDependencies(): Array<string[]> {
+    return this.tier2.findCircularDependencies();
+  }
+
+  // Get transitive dependents (all files affected by changing a file)
+  getTransitiveDependents(filePath: string, maxDepth: number = 3): Array<{ file: string; depth: number; imports: string[] }> {
+    return this.tier2.getTransitiveDependents(filePath, maxDepth);
+  }
+
   // Phase 2: Get symbol count
   getSymbolCount(): number {
     return this.tier2.getSymbolCount();

package/src/core/ghost-mode.ts

@@ -64,9 +64,16 @@ const TECH_PATTERNS = [
   { pattern: /\b(sass|scss|less)\b/i, category: 'styling', term: 'CSS preprocessor' },
 ];
 
+export interface FileImpact {
+  changedFile: string;
+  affectedFiles: string[];
+  timestamp: Date;
+}
+
 export class GhostMode {
   private activeFiles: Map<string, FileContext> = new Map();
   private recentDecisions: Map<string, Decision[]> = new Map();
+  private recentImpacts: Map<string, FileImpact> = new Map(); // Track file impacts
   private tier2: Tier2Storage;
   private embeddingGenerator: EmbeddingGenerator;
 
@@ -74,12 +81,58 @@ export class GhostMode {
   private readonly MAX_ACTIVE_FILES = 20;
   private readonly FILE_TTL_MS = 60 * 60 * 1000; // 1 hour
   private readonly DECISION_CACHE_SIZE = 50;
+  private readonly IMPACT_TTL_MS = 30 * 60 * 1000; // 30 minutes
 
   constructor(tier2: Tier2Storage, embeddingGenerator: EmbeddingGenerator) {
     this.tier2 = tier2;
     this.embeddingGenerator = embeddingGenerator;
   }
 
+  /**
+   * Called when a file change impacts other files
+   */
+  onFileImpact(changedFile: string, affectedFiles: string[]): void {
+    const impact: FileImpact = {
+      changedFile,
+      affectedFiles,
+      timestamp: new Date()
+    };
+
+    // Store impact for each affected file
+    for (const file of affectedFiles) {
+      this.recentImpacts.set(file, impact);
+    }
+
+    // Evict old impacts
+    this.evictStaleImpacts();
+  }
+
+  /**
+   * Check if a file was recently impacted by changes to another file
+   */
+  getImpactWarning(filePath: string): FileImpact | null {
+    const impact = this.recentImpacts.get(filePath);
+    if (!impact) return null;
+
+    // Check if still within TTL
+    const age = Date.now() - impact.timestamp.getTime();
+    if (age > this.IMPACT_TTL_MS) {
+      this.recentImpacts.delete(filePath);
+      return null;
+    }
+
+    return impact;
+  }
+
+  private evictStaleImpacts(): void {
+    const now = Date.now();
+    for (const [file, impact] of this.recentImpacts) {
+      if (now - impact.timestamp.getTime() > this.IMPACT_TTL_MS) {
+        this.recentImpacts.delete(file);
+      }
+    }
+  }
+
   /**
    * Called when any file is read - silently track and pre-fetch decisions
    */

package/src/core/project-manager.ts

@@ -269,7 +269,11 @@ export class ProjectManager {
     const result: Array<{ project: ProjectInfo; db: Database.Database }> = [];
 
     for (const project of this.listProjects()) {
-      const dbPath = join(project.dataDir, 'memorylayer.db');
+      // Check both new and old database names
+      let dbPath = join(project.dataDir, 'neuronlayer.db');
+      if (!existsSync(dbPath)) {
+        dbPath = join(project.dataDir, 'memorylayer.db');
+      }
 
       if (existsSync(dbPath)) {
         try {

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;