codeatlas-mcp-server 2.20.2

package/dist/src/analyzer/parser.js

@@ -0,0 +1,1072 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { parse } from '@typescript-eslint/typescript-estree';
+import ignore from 'ignore';
+import { PythonParser } from './pythonParser.js';
+import { PhpParser } from './phpParser.js';
+export class CodeAnalyzer {
+    workspaceRoot;
+    nodes = new Map();
+    links = [];
+    maxFiles;
+    excludedDirectories;
+    excludedFiles;
+    fileExtensions;
+    ignoreFilter = null;
+    constructor(workspaceRoot, maxFiles = 5000, excludedDirectories = ['node_modules', 'dist', 'out', '.git', '__pycache__', '.venv', 'venv', 'env', '.env', 'vendor', 'build', '.tox', '.mypy_cache', '.pytest_cache', 'coverage', '.next', '.nuxt',
+        // Common user home subdirectories — prevent accidental full-home scans
+        'Downloads', 'Desktop', 'Documents', 'Pictures', 'Music', 'Videos', 'snap', 'go', 'AppData', 'Applications', 'Public', 'Templates'], fileExtensions = ['.ts', '.tsx', '.js', '.jsx', '.py', '.php'], excludedFiles = ['_ide_helper.php', '_ide_helper_models.php', '.phpstorm.meta.php']) {
+        this.workspaceRoot = workspaceRoot;
+        this.maxFiles = maxFiles;
+        this.excludedDirectories = excludedDirectories;
+        this.excludedFiles = excludedFiles;
+        this.fileExtensions = fileExtensions;
+    }
+    getIgnoreFilter() {
+        if (this.ignoreFilter) {
+            return this.ignoreFilter;
+        }
+        const ig = ignore();
+        // Excluded dirs/files will match relative paths correctly
+        ig.add(this.excludedDirectories);
+        ig.add(this.excludedFiles);
+        const gitignorePath = path.join(this.workspaceRoot, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            try {
+                const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+                ig.add(gitignoreContent);
+            }
+            catch (e) {
+                console.warn(`[CodeAnalyzer] Failed to read .gitignore at ${gitignorePath}`, e);
+            }
+        }
+        this.ignoreFilter = ig;
+        return ig;
+    }
+    isIgnored(absolutePath, isDirectory) {
+        const relPath = path.relative(this.workspaceRoot, absolutePath);
+        if (!relPath || relPath === '.' || relPath.startsWith('..')) {
+            return false;
+        }
+        let normalizedPath = relPath.replace(/\\/g, '/');
+        if (isDirectory && !normalizedPath.endsWith('/')) {
+            normalizedPath += '/';
+        }
+        return this.getIgnoreFilter().ignores(normalizedPath);
+    }
+    allFiles = [];
+    totalSkippedCount = 0;
+    async analyzeProject(onProgress) {
+        this.nodes.clear();
+        this.links = [];
+        let files = this.getFiles(this.workspaceRoot);
+        if (files.length > this.maxFiles) {
+            console.warn(`[CodeAnalyzer] Workspace has ${files.length} files, which exceeds maxFiles (${this.maxFiles}). Truncating to ${this.maxFiles} files.`);
+            files = files.slice(0, this.maxFiles);
+        }
+        this.allFiles = [...files];
+        const total = files.length;
+        // Log the files to be indexed
+        const relativeFiles = files.map(f => path.relative(this.workspaceRoot, f));
+        console.error(`[Indexing] 📋 Discovered ${relativeFiles.length} files to index:\n` + relativeFiles.map(f => `  - ${f}`).join('\n'));
+        let totalSkipped = 0;
+        let lastReportedPercent = 0;
+        for (let i = 0; i < total; i++) {
+            const filePath = files[i];
+            const success = this.analyzeFile(filePath);
+            if (!success)
+                totalSkipped++;
+            if (onProgress && total > 0) {
+                const percent = Math.floor(((i + 1) / total) * 100);
+                const relPath = path.relative(this.workspaceRoot, filePath);
+                // Report every 10% milestone to avoid log spam
+                if (percent >= lastReportedPercent + 10 || percent === 100) {
+                    lastReportedPercent = percent;
+                    onProgress(percent, i + 1, total, relPath);
+                }
+            }
+        }
+        this.totalSkippedCount = totalSkipped;
+        return this.buildAnalysisResult();
+    }
+    async analyzeFileIncremental(filePath) {
+        const absPath = path.resolve(filePath);
+        // 1. Remove all existing nodes belonging to this file
+        const nodesToRemove = new Set();
+        this.nodes.forEach((node, id) => {
+            if (node.filePath && path.resolve(this.workspaceRoot, node.filePath) === absPath) {
+                nodesToRemove.add(id);
+            }
+        });
+        // Also remove module node matching this file's module ID
+        const relativePath = path.relative(this.workspaceRoot, absPath);
+        const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+        const moduleId = `module:${normalizedRelativePath}`;
+        nodesToRemove.add(moduleId);
+        nodesToRemove.forEach(id => this.nodes.delete(id));
+        // 2. Remove all links associated with the removed nodes
+        this.links = this.links.filter(link => !nodesToRemove.has(link.source) && !nodesToRemove.has(link.target));
+        // 3. Re-analyze only if file exists and is NOT ignored
+        try {
+            if (fs.existsSync(absPath) && !this.isIgnored(absPath, false)) {
+                this.analyzeFile(absPath);
+                if (!this.allFiles.includes(absPath)) {
+                    this.allFiles.push(absPath);
+                }
+            }
+            else {
+                // File was deleted or is ignored
+                this.allFiles = this.allFiles.filter(f => f !== absPath);
+            }
+        }
+        catch {
+            this.allFiles = this.allFiles.filter(f => f !== absPath);
+        }
+        return this.buildAnalysisResult();
+    }
+    buildAnalysisResult() {
+        // Add graph layout sizes based on relationships
+        this.nodes.forEach(node => {
+            let degree = this.links.filter(l => l.source === node.id || l.target === node.id).length;
+            node.val = (node.type === 'module' ? 8 : (node.type === 'class' ? 6 : 4)) + Math.log1p(degree) * 2;
+        });
+        // Only keep links where both source and target nodes exist
+        const validLinks = this.links.filter(link => this.nodes.has(link.source) && this.nodes.has(link.target));
+        const graph = {
+            nodes: Array.from(this.nodes.values()),
+            links: validLinks
+        };
+        const insights = this.generateAIInsights(graph);
+        const circularDepsCount = this.detectCircularDeps();
+        const counts = {
+            modules: Array.from(this.nodes.values()).filter(n => n.type === 'module').length,
+            functions: Array.from(this.nodes.values()).filter(n => n.type === 'function').length,
+            classes: Array.from(this.nodes.values()).filter(n => n.type === 'class').length,
+            variables: Array.from(this.nodes.values()).filter(n => n.type === 'variable').length,
+            dependencies: this.links.filter(l => l.type === 'import').length,
+            circularDeps: circularDepsCount,
+            deadCode: 0
+        };
+        return {
+            graph,
+            insights,
+            entityCounts: counts,
+            totalFilesAnalyzed: this.allFiles.length - this.totalSkippedCount,
+            totalFilesSkipped: this.totalSkippedCount
+        };
+    }
+    /**
+     * Builds chunked analysis data grouped by folder.
+     * Call this after analyzeProject() to get folder-based chunks.
+     */
+    buildChunkedResult(result) {
+        // Group nodes by their parent folder
+        const folderNodeMap = new Map();
+        for (const node of result.graph.nodes) {
+            let folder = '.'; // root
+            if (node.filePath) {
+                const rel = path.isAbsolute(node.filePath)
+                    ? path.relative(this.workspaceRoot, node.filePath)
+                    : node.filePath;
+                folder = path.dirname(rel).replace(/\\/g, '/');
+            }
+            else if (node.id.startsWith('module:')) {
+                const rel = node.id.replace('module:', '');
+                folder = path.dirname(rel).replace(/\\/g, '/');
+            }
+            else if (node.id.startsWith('external:')) {
+                folder = '__external__';
+            }
+            else {
+                // Extract folder from node id (e.g. "class:module:src/foo.ts:MyClass")
+                const parts = node.id.split(':');
+                if (parts.length >= 3 && parts[1] === 'module') {
+                    // Reconstruct the path from parts[2] (e.g. "src/foo.ts")
+                    folder = path.dirname(parts[2]).replace(/\\/g, '/');
+                }
+                else if (parts.length >= 2) {
+                    const moduleRef = parts.slice(1, -1).join(':').replace(/^module:/, '');
+                    if (moduleRef) {
+                        folder = path.dirname(moduleRef).replace(/\\/g, '/');
+                    }
+                }
+            }
+            if (!folderNodeMap.has(folder)) {
+                folderNodeMap.set(folder, []);
+            }
+            folderNodeMap.get(folder).push(node);
+        }
+        // Build chunks and separate cross-chunk links
+        const chunks = new Map();
+        const nodeToFolder = new Map();
+        const crossLinks = [];
+        // Map each node to its folder
+        for (const [folder, nodes] of folderNodeMap) {
+            for (const node of nodes) {
+                nodeToFolder.set(node.id, folder);
+            }
+        }
+        // Create chunks with internal links
+        for (const [folder, nodes] of folderNodeMap) {
+            const nodeIds = new Set(nodes.map(n => n.id));
+            const internalLinks = result.graph.links.filter(link => nodeIds.has(link.source) && nodeIds.has(link.target));
+            chunks.set(folder, {
+                folderPath: folder,
+                nodes,
+                links: internalLinks
+            });
+        }
+        // Collect cross-chunk links
+        for (const link of result.graph.links) {
+            const srcFolder = nodeToFolder.get(link.source);
+            const tgtFolder = nodeToFolder.get(link.target);
+            if (srcFolder && tgtFolder && srcFolder !== tgtFolder) {
+                crossLinks.push(link);
+            }
+        }
+        // Build folder info for manifest
+        const folders = [];
+        for (const [folder, chunk] of chunks) {
+            const types = {};
+            for (const node of chunk.nodes) {
+                types[node.type] = (types[node.type] || 0) + 1;
+            }
+            folders.push({
+                path: folder,
+                nodeCount: chunk.nodes.length,
+                linkCount: chunk.links.length,
+                types
+            });
+        }
+        // Sort folders by node count descending for prioritized loading
+        folders.sort((a, b) => b.nodeCount - a.nodeCount);
+        const manifest = {
+            totalNodes: result.graph.nodes.length,
+            totalLinks: result.graph.links.length,
+            totalFiles: result.totalFilesAnalyzed + result.totalFilesSkipped,
+            totalFilesSkipped: result.totalFilesSkipped,
+            folders,
+            insights: result.insights,
+            entityCounts: result.entityCounts
+        };
+        return { manifest, chunks, crossChunkLinks: { links: crossLinks } };
+    }
+    /**
+     * Returns the first N nodes for initial loading, picking from folders in order.
+     */
+    getInitialLoadData(result, manifest, chunks, crossChunkLinks, nodeLimit) {
+        if (nodeLimit <= 0 || nodeLimit >= result.graph.nodes.length) {
+            // Load everything
+            return {
+                graph: result.graph,
+                loadedFolders: manifest.folders.map(f => f.path)
+            };
+        }
+        const loadedNodes = [];
+        const loadedFolders = [];
+        let remaining = nodeLimit;
+        // Load folders by priority (sorted by nodeCount descending — most important first)
+        // Actually, for better UX, sort by path alphabetically so root folders load first
+        const sortedFolders = [...manifest.folders].sort((a, b) => {
+            // Root folder first, then by depth, then alphabetically
+            if (a.path === '.')
+                return -1;
+            if (b.path === '.')
+                return 1;
+            const depthA = a.path.split('/').length;
+            const depthB = b.path.split('/').length;
+            if (depthA !== depthB)
+                return depthA - depthB;
+            return a.path.localeCompare(b.path);
+        });
+        for (const folderInfo of sortedFolders) {
+            if (remaining <= 0)
+                break;
+            const chunk = chunks.get(folderInfo.path);
+            if (!chunk)
+                continue;
+            if (chunk.nodes.length <= remaining) {
+                loadedNodes.push(...chunk.nodes);
+                loadedFolders.push(folderInfo.path);
+                remaining -= chunk.nodes.length;
+            }
+            else {
+                // Partial load: take module nodes first, then classes, then functions, then variables
+                const priorityOrder = ['module', 'class', 'function', 'variable'];
+                const sorted = [...chunk.nodes].sort((a, b) => {
+                    const indexA = priorityOrder.indexOf(a.type);
+                    const indexB = priorityOrder.indexOf(b.type);
+                    // Unknown types go to the end
+                    const priorityA = indexA === -1 ? priorityOrder.length : indexA;
+                    const priorityB = indexB === -1 ? priorityOrder.length : indexB;
+                    return priorityA - priorityB;
+                });
+                loadedNodes.push(...sorted.slice(0, remaining));
+                loadedFolders.push(folderInfo.path);
+                remaining = 0;
+            }
+        }
+        // Filter links to only include those where both endpoints are loaded
+        const loadedNodeIds = new Set(loadedNodes.map(n => n.id));
+        const loadedLinks = result.graph.links.filter(link => loadedNodeIds.has(link.source) && loadedNodeIds.has(link.target));
+        return {
+            graph: { nodes: loadedNodes, links: loadedLinks },
+            loadedFolders
+        };
+    }
+    /**
+     * Detects circular dependencies among modules.
+     * Builds a directed graph of module imports and runs DFS cycle detection.
+     * @returns {number} The total number of back-edges (cycles) found.
+     */
+    detectCircularDeps() {
+        const adjList = new Map();
+        // Build adjacency list for module-to-module imports
+        for (const link of this.links) {
+            if (link.type === 'import' && link.source.startsWith('module:') && link.target.startsWith('module:')) {
+                if (!adjList.has(link.source)) {
+                    adjList.set(link.source, []);
+                }
+                adjList.get(link.source).push(link.target);
+            }
+        }
+        let cycles = 0;
+        const visited = new Set();
+        const recStack = new Set();
+        const dfs = (node) => {
+            visited.add(node);
+            recStack.add(node);
+            const neighbors = adjList.get(node) || [];
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    dfs(neighbor);
+                }
+                else if (recStack.has(neighbor)) {
+                    cycles++;
+                }
+            }
+            recStack.delete(node);
+        };
+        for (const node of adjList.keys()) {
+            if (!visited.has(node)) {
+                dfs(node);
+            }
+        }
+        return cycles;
+    }
+    getFiles(dir, fileList = [], depth = 0) {
+        if (!fs.existsSync(dir))
+            return fileList;
+        // Safety: max recursion depth = 20 levels (prevents runaway on broad paths)
+        const MAX_DEPTH = 20;
+        if (depth > MAX_DEPTH) {
+            console.warn(`[CodeAnalyzer] Max depth (${MAX_DEPTH}) reached at ${dir}. Stopping recursion.`);
+            return fileList;
+        }
+        // Check if current directory itself is ignored
+        if (dir !== this.workspaceRoot && this.isIgnored(dir, true)) {
+            return fileList;
+        }
+        let files;
+        try {
+            files = fs.readdirSync(dir);
+        }
+        catch {
+            return fileList;
+        }
+        for (const file of files) {
+            // Keep safety check for hidden files/folders (starting with .)
+            if (file.startsWith('.')) {
+                continue;
+            }
+            const filePath = path.join(dir, file);
+            let stat;
+            try {
+                stat = fs.statSync(filePath);
+            }
+            catch {
+                continue;
+            }
+            const isDirectory = stat.isDirectory();
+            // Check if file/directory is ignored via .gitignore or default rules
+            if (this.isIgnored(filePath, isDirectory)) {
+                continue;
+            }
+            if (isDirectory) {
+                this.getFiles(filePath, fileList, depth + 1);
+            }
+            else if (this.fileExtensions.some(ext => file.endsWith(ext))) {
+                fileList.push(filePath);
+            }
+        }
+        return fileList;
+    }
+    analyzeFile(filePath) {
+        let moduleId = '';
+        try {
+            const code = fs.readFileSync(filePath, 'utf-8');
+            const relativePath = path.relative(this.workspaceRoot, filePath);
+            // Normalize to use forward slashes for matching
+            const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+            moduleId = `module:${normalizedRelativePath}`;
+            const isPython = filePath.endsWith('.py');
+            const isPhp = filePath.endsWith('.php') && !filePath.endsWith('.blade.php');
+            const isBlade = filePath.endsWith('.blade.php');
+            // Set color based on file type
+            let moduleColor = '#4cc9f0'; // TS/JS default
+            if (isPython)
+                moduleColor = '#3572A5';
+            else if (isPhp)
+                moduleColor = '#4F5D95';
+            else if (isBlade)
+                moduleColor = '#FF2D20';
+            this.addNode({
+                id: moduleId,
+                label: path.basename(filePath),
+                type: 'module',
+                color: moduleColor,
+                filePath: filePath,
+                line: 1
+            });
+            if (isPython) {
+                this.analyzePythonFile(code, moduleId, filePath);
+            }
+            else if (isPhp) {
+                this.analyzePhpFile(code, moduleId, filePath);
+            }
+            else if (isBlade) {
+                this.analyzeBladeFile(code, moduleId, filePath);
+            }
+            else {
+                const ast = parse(code, {
+                    loc: true,
+                    range: true,
+                    jsx: true
+                });
+                // Keep track of imports in this file to resolve calls
+                const fileImports = new Map(); // alias/name -> moduleId
+                this.traverseAST(ast, moduleId, filePath, moduleId, fileImports);
+            }
+            return true;
+        }
+        catch (e) {
+            console.warn(`Failed to parse file: ${filePath}`, e);
+            // Clean up the node if it was added
+            if (moduleId && this.nodes.has(moduleId)) {
+                this.nodes.delete(moduleId);
+            }
+            return false;
+        }
+    }
+    /**
+     * Parses Python files using the PythonParser.
+     */
+    analyzePythonFile(code, moduleId, filePath) {
+        const pythonParser = new PythonParser();
+        const result = pythonParser.parseFile(filePath, code);
+        for (const cls of result.classes) {
+            const classId = `class:${moduleId}:${cls.name}`;
+            this.addNode({
+                id: classId,
+                label: cls.name,
+                type: 'class',
+                color: '#f8961e',
+                filePath: filePath,
+                line: cls.line
+            });
+            this.addLink({
+                source: moduleId,
+                target: classId,
+                type: 'contains'
+            });
+            for (const parent of cls.parents) {
+                const parentId = `class:${moduleId}:${parent}`;
+                this.addLink({
+                    source: classId,
+                    target: parentId,
+                    type: 'import'
+                });
+            }
+        }
+        const reversedClasses = [...result.classes].reverse();
+        for (const func of result.functions) {
+            const funcId = `function:${moduleId}:${func.name}`;
+            this.addNode({
+                id: funcId,
+                label: func.name,
+                type: 'function',
+                color: '#f72585',
+                filePath: filePath,
+                line: func.line
+            });
+            let linkSourceId = moduleId;
+            if (func.indent && func.indent > 0) {
+                // Find the most recent class defined before this function
+                const parentClass = reversedClasses
+                    .find(cls => cls.line < func.line);
+                if (parentClass) {
+                    linkSourceId = `class:${moduleId}:${parentClass.name}`;
+                }
+            }
+            this.addLink({
+                source: linkSourceId,
+                target: funcId,
+                type: 'contains'
+            });
+        }
+        for (const variable of result.variables) {
+            const varId = `variable:${moduleId}:${variable.name}`;
+            this.addNode({
+                id: varId,
+                label: variable.name,
+                type: 'variable',
+                color: '#00ff88',
+                filePath: filePath,
+                line: variable.line
+            });
+            this.addLink({
+                source: moduleId,
+                target: varId,
+                type: 'contains'
+            });
+        }
+        for (const imp of result.imports) {
+            const importPathName = imp.source || imp.names[0];
+            if (!importPathName)
+                continue;
+            const resolvedModuleId = this.resolvePythonImportPath(importPathName, filePath);
+            const targetId = resolvedModuleId || `external:${importPathName}`;
+            this.addLink({
+                source: moduleId,
+                target: targetId,
+                type: 'import'
+            });
+            if (!resolvedModuleId) {
+                if (!this.nodes.has(targetId)) {
+                    this.addNode({
+                        id: targetId,
+                        label: importPathName,
+                        type: 'module',
+                        color: '#7209b7'
+                    });
+                }
+            }
+        }
+        // Build a simple scope tracker from functions list
+        const sortedFunctions = [...result.functions].sort((a, b) => a.line - b.line);
+        for (const call of result.calls) {
+            // Find which function this call is inside using binary search
+            let enclosingScope = moduleId;
+            let left = 0;
+            let right = sortedFunctions.length - 1;
+            let match = -1;
+            const callLine = call.line;
+            while (left <= right) {
+                const mid = (left + right) >> 1;
+                if (sortedFunctions[mid].line <= callLine) {
+                    match = mid;
+                    left = mid + 1;
+                }
+                else {
+                    right = mid - 1;
+                }
+            }
+            if (match !== -1) {
+                enclosingScope = `function:${moduleId}:${sortedFunctions[match].name}`;
+            }
+            const targetId = `function:${moduleId}:${call.name}`;
+            // Don't add self-referencing calls
+            if (enclosingScope !== targetId) {
+                this.addLink({
+                    source: enclosingScope,
+                    target: targetId,
+                    type: 'call'
+                });
+            }
+        }
+    }
+    /**
+     * Parses PHP files using the PhpParser.
+     */
+    analyzePhpFile(code, moduleId, filePath) {
+        const phpParser = new PhpParser();
+        const result = phpParser.parseFile(filePath, code);
+        // Classes, Interfaces, Traits, Enums
+        for (const cls of result.classes) {
+            const nodeType = cls.type === 'interface' ? 'class' : cls.type === 'trait' ? 'class' : 'class';
+            const classId = `class:${moduleId}:${cls.name}`;
+            const colorMap = {
+                class: '#f8961e',
+                interface: '#7209b7',
+                trait: '#06d6a0',
+                enum: '#ffd166'
+            };
+            this.addNode({
+                id: classId,
+                label: `${cls.name}`,
+                type: nodeType,
+                color: colorMap[cls.type] || '#f8961e',
+                filePath: filePath,
+                line: cls.line
+            });
+            this.addLink({ source: moduleId, target: classId, type: 'contains' });
+            // Extends
+            for (const parent of cls.parents) {
+                const parentId = `class:external:${parent}`;
+                if (!this.nodes.has(parentId)) {
+                    this.addNode({ id: parentId, label: parent, type: 'class', color: '#f8961e' });
+                }
+                this.addLink({ source: classId, target: parentId, type: 'import' });
+            }
+            // Implements
+            for (const iface of cls.implements) {
+                const ifaceId = `class:external:${iface}`;
+                if (!this.nodes.has(ifaceId)) {
+                    this.addNode({ id: ifaceId, label: iface, type: 'class', color: '#7209b7' });
+                }
+                this.addLink({ source: classId, target: ifaceId, type: 'import' });
+            }
+        }
+        // Functions
+        for (const func of result.functions) {
+            const funcId = `function:${moduleId}:${func.name}`;
+            this.addNode({
+                id: funcId,
+                label: func.name,
+                type: 'function',
+                color: '#f72585',
+                filePath: filePath,
+                line: func.line
+            });
+            this.addLink({ source: moduleId, target: funcId, type: 'contains' });
+        }
+        // Variables (properties, constants)
+        for (const variable of result.variables) {
+            const varId = `variable:${moduleId}:${variable.name}`;
+            this.addNode({
+                id: varId,
+                label: variable.name,
+                type: 'variable',
+                color: '#00ff88',
+                filePath: filePath,
+                line: variable.line
+            });
+            this.addLink({ source: moduleId, target: varId, type: 'contains' });
+        }
+        // Use statements (imports)
+        for (const imp of result.imports) {
+            const importSourceId = `external:${imp.alias}`;
+            this.addLink({ source: moduleId, target: importSourceId, type: 'import' });
+            if (!this.nodes.has(importSourceId)) {
+                this.addNode({
+                    id: importSourceId,
+                    label: imp.alias,
+                    type: 'module',
+                    color: '#7209b7'
+                });
+            }
+        }
+        // Method calls — only link to functions already discovered in the graph
+        const functionNodesByName = new Map();
+        for (const key of this.nodes.keys()) {
+            if (key.startsWith('function:')) {
+                const lastColonIdx = key.lastIndexOf(':');
+                if (lastColonIdx !== -1) {
+                    const funcName = key.substring(lastColonIdx + 1);
+                    let arr = functionNodesByName.get(funcName);
+                    if (!arr) {
+                        arr = [];
+                        functionNodesByName.set(funcName, arr);
+                    }
+                    arr.push(key);
+                }
+            }
+        }
+        for (const call of result.calls) {
+            // Search all known function nodes to find a match
+            const possibleTargets = functionNodesByName.get(call.name);
+            if (possibleTargets && possibleTargets.length > 0) {
+                this.addLink({ source: moduleId, target: possibleTargets[0], type: 'call' });
+            }
+        }
+    }
+    /**
+     * Parses Blade template files to extract template relationships.
+     */
+    analyzeBladeFile(code, moduleId, filePath) {
+        const phpParser = new PhpParser();
+        const result = phpParser.parseBladeFile(filePath, code);
+        // @extends creates a dependency link
+        for (const ext of result.extends) {
+            const targetId = `blade:${ext.replace(/\./g, '/')}`;
+            if (!this.nodes.has(targetId)) {
+                this.addNode({ id: targetId, label: ext, type: 'module', color: '#FF2D20' });
+            }
+            this.addLink({ source: moduleId, target: targetId, type: 'import' });
+        }
+        // @include creates a dependency link
+        for (const inc of result.includes) {
+            const targetId = `blade:${inc.replace(/\./g, '/')}`;
+            if (!this.nodes.has(targetId)) {
+                this.addNode({ id: targetId, label: inc, type: 'module', color: '#FF2D20' });
+            }
+            this.addLink({ source: moduleId, target: targetId, type: 'import' });
+        }
+        // @component / <x-component>
+        for (const comp of result.components) {
+            const targetId = `component:${comp}`;
+            if (!this.nodes.has(targetId)) {
+                this.addNode({ id: targetId, label: comp, type: 'class', color: '#f8961e' });
+            }
+            this.addLink({ source: moduleId, target: targetId, type: 'import' });
+        }
+    }
+    handleImportDeclaration(node, currentModuleId, filePath, fileImports) {
+        const importPath = node.source?.value;
+        if (typeof importPath === 'string') {
+            const targetModuleId = this.resolveImportPath(importPath, filePath);
+            this.addLink({
+                source: currentModuleId,
+                target: targetModuleId,
+                type: 'import'
+            });
+            if (node.specifiers) {
+                for (const specifier of node.specifiers) {
+                    if (specifier.local?.name) {
+                        fileImports.set(specifier.local.name, targetModuleId);
+                    }
+                }
+            }
+            // Ensure target module node exists (even if it's an external module for now)
+            if (!this.nodes.has(targetModuleId)) {
+                this.addNode({
+                    id: targetModuleId,
+                    label: importPath.split('/').pop() || importPath,
+                    type: 'module',
+                    color: '#7209b7' // external module color
+                });
+            }
+        }
+    }
+    handleFunctionDeclaration(node, currentModuleId, filePath, currentScopeId) {
+        if (node.id?.name) {
+            const funcId = `function:${currentModuleId}:${node.id.name}`;
+            this.addNode({
+                id: funcId,
+                label: node.id.name,
+                type: 'function',
+                color: '#f72585',
+                filePath: filePath,
+                line: node.loc?.start?.line
+            });
+            this.addLink({
+                source: currentScopeId,
+                target: funcId,
+                type: 'contains'
+            });
+            return funcId;
+        }
+        return currentScopeId;
+    }
+    handleClassDeclaration(node, currentModuleId, filePath, currentScopeId) {
+        if (node.id?.name) {
+            const classId = `class:${currentModuleId}:${node.id.name}`;
+            this.addNode({
+                id: classId,
+                label: node.id.name,
+                type: 'class',
+                color: '#f8961e',
+                filePath: filePath,
+                line: node.loc?.start?.line
+            });
+            this.addLink({
+                source: currentScopeId,
+                target: classId,
+                type: 'contains'
+            });
+            return classId;
+        }
+        return currentScopeId;
+    }
+    handleMethodDefinition(node, currentModuleId, filePath, currentScopeId) {
+        if (node.key?.name) {
+            const methodId = `function:${currentModuleId}:${node.key.name}`;
+            this.addNode({
+                id: methodId,
+                label: node.key.name,
+                type: 'function',
+                color: '#f72585',
+                filePath: filePath,
+                line: node.loc?.start?.line
+            });
+            this.addLink({
+                source: currentScopeId,
+                target: methodId,
+                type: 'contains'
+            });
+            return methodId;
+        }
+        return currentScopeId;
+    }
+    handleVariableDeclarator(node, currentModuleId, filePath, currentScopeId) {
+        if (node.id?.name) {
+            const varName = node.id.name;
+            if (node.init && (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')) {
+                const funcId = `function:${currentModuleId}:${varName}`;
+                this.addNode({
+                    id: funcId,
+                    label: varName,
+                    type: 'function',
+                    color: '#f72585',
+                    filePath: filePath,
+                    line: node.loc?.start?.line
+                });
+                this.addLink({
+                    source: currentScopeId,
+                    target: funcId,
+                    type: 'contains'
+                });
+                return funcId;
+            }
+            else if (currentScopeId === currentModuleId) {
+                // Top-level variable
+                const varId = `variable:${currentModuleId}:${varName}`;
+                this.addNode({
+                    id: varId,
+                    label: varName,
+                    type: 'variable',
+                    color: '#00ff88', // Green for variables
+                    filePath: filePath,
+                    line: node.loc?.start?.line
+                });
+                this.addLink({
+                    source: currentScopeId,
+                    target: varId,
+                    type: 'contains'
+                });
+            }
+        }
+        return currentScopeId;
+    }
+    handleCallExpression(node, currentModuleId, currentScopeId, fileImports) {
+        let calleeName = '';
+        let objectName = '';
+        if (node.callee.type === 'Identifier') {
+            calleeName = node.callee.name;
+        }
+        else if (node.callee.type === 'MemberExpression' && node.callee.property?.name) {
+            calleeName = node.callee.property.name;
+            if (node.callee.object?.name) {
+                objectName = node.callee.object.name;
+            }
+        }
+        if (calleeName) {
+            let targetId = '';
+            if (objectName && fileImports.has(objectName)) {
+                // It's a method call on an imported namespace/object
+                const targetModule = fileImports.get(objectName);
+                targetId = `function:${targetModule}:${calleeName}`;
+            }
+            else if (fileImports.has(calleeName)) {
+                // It's a direct call to an imported function
+                const targetModule = fileImports.get(calleeName);
+                targetId = `function:${targetModule}:${calleeName}`;
+            }
+            else {
+                // It's a local call
+                targetId = `function:${currentModuleId}:${calleeName}`;
+            }
+            this.addLink({
+                source: currentScopeId,
+                target: targetId,
+                type: 'call'
+            });
+        }
+    }
+    /**
+     * Traverses the AST recursively to extract modules, functions, classes, and variables.
+     * Also detects function calls and updates links.
+     */
+    traverseAST(node, currentModuleId, filePath, currentScopeId, fileImports) {
+        if (!node)
+            return;
+        if (Array.isArray(node)) {
+            node.forEach(child => this.traverseAST(child, currentModuleId, filePath, currentScopeId, fileImports));
+            return;
+        }
+        let nextScopeId = currentScopeId;
+        if (node.type === 'ImportDeclaration') {
+            this.handleImportDeclaration(node, currentModuleId, filePath, fileImports);
+        }
+        else if (node.type === 'FunctionDeclaration') {
+            nextScopeId = this.handleFunctionDeclaration(node, currentModuleId, filePath, currentScopeId);
+        }
+        else if (node.type === 'ClassDeclaration') {
+            nextScopeId = this.handleClassDeclaration(node, currentModuleId, filePath, currentScopeId);
+        }
+        else if (node.type === 'MethodDefinition') {
+            nextScopeId = this.handleMethodDefinition(node, currentModuleId, filePath, currentScopeId);
+        }
+        else if (node.type === 'VariableDeclarator') {
+            nextScopeId = this.handleVariableDeclarator(node, currentModuleId, filePath, currentScopeId);
+        }
+        else if (node.type === 'CallExpression') {
+            this.handleCallExpression(node, currentModuleId, currentScopeId, fileImports);
+        }
+        Object.keys(node).forEach(key => {
+            if (key !== 'loc' && key !== 'range' && typeof node[key] === 'object') {
+                this.traverseAST(node[key], currentModuleId, filePath, nextScopeId, fileImports);
+            }
+        });
+    }
+    /**
+     * Resolves the actual module path checking for index files and standard file extensions.
+     */
+    resolveImportPath(importPath, currentFilePath) {
+        if (importPath.startsWith('.')) {
+            try {
+                let absolutePath = path.resolve(path.dirname(currentFilePath), importPath);
+                let foundPath = absolutePath;
+                const extensions = this.fileExtensions;
+                let matched = false;
+                if (fs.existsSync(absolutePath)) {
+                    const stat = fs.statSync(absolutePath);
+                    if (stat.isDirectory()) {
+                        for (const ext of extensions) {
+                            const indexPath = path.join(absolutePath, `index${ext}`);
+                            if (fs.existsSync(indexPath)) {
+                                foundPath = indexPath;
+                                matched = true;
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        matched = true;
+                    }
+                }
+                if (!matched) {
+                    for (const ext of extensions) {
+                        const extPath = `${absolutePath}${ext}`;
+                        if (fs.existsSync(extPath)) {
+                            foundPath = extPath;
+                            matched = true;
+                            break;
+                        }
+                    }
+                }
+                const relativeToWorkspace = path.relative(this.workspaceRoot, foundPath);
+                // Normalize slashes
+                return `module:${relativeToWorkspace.replace(/\\/g, '/')}`;
+            }
+            catch {
+                return `external:${importPath}`;
+            }
+        }
+        return `external:${importPath}`;
+    }
+    resolvePythonImportPath(importPath, currentFilePath) {
+        let leadingDots = '';
+        let rest = importPath;
+        while (rest.startsWith('.')) {
+            leadingDots += '.';
+            rest = rest.substring(1);
+        }
+        let searchDirs = [];
+        if (leadingDots.length > 0) {
+            let targetDir = path.dirname(currentFilePath);
+            for (let i = 1; i < leadingDots.length; i++) {
+                targetDir = path.dirname(targetDir);
+            }
+            searchDirs = [targetDir];
+        }
+        else {
+            searchDirs = [this.workspaceRoot, path.dirname(currentFilePath)];
+        }
+        const subPath = rest.replace(/\./g, '/');
+        for (const baseDir of searchDirs) {
+            const targetPath = path.join(baseDir, subPath);
+            const pyPath = `${targetPath}.py`;
+            if (fs.existsSync(pyPath)) {
+                return `module:${path.relative(this.workspaceRoot, pyPath).replace(/\\/g, '/')}`;
+            }
+            const initPyPath = path.join(targetPath, '__init__.py');
+            if (fs.existsSync(initPyPath)) {
+                return `module:${path.relative(this.workspaceRoot, initPyPath).replace(/\\/g, '/')}`;
+            }
+        }
+        return null;
+    }
+    addNode(node) {
+        if (node.id.startsWith('external:') || node.id.includes(':external:')) {
+            return;
+        }
+        if (node.filePath && path.isAbsolute(node.filePath)) {
+            node.filePath = path.relative(this.workspaceRoot, node.filePath).replace(/\\/g, '/');
+        }
+        if (!this.nodes.has(node.id)) {
+            this.nodes.set(node.id, node);
+        }
+    }
+    addLink(link) {
+        if (link.source.startsWith('external:') ||
+            link.target.startsWith('external:') ||
+            link.source.includes(':external:') ||
+            link.target.includes(':external:')) {
+            return;
+        }
+        this.links.push(link);
+    }
+    generateAIInsights(graph) {
+        const insights = [];
+        // Mock AI Insights generation based on simple heuristics
+        // 1. Large files / God objects
+        const modulesWithManyFunctions = Array.from(this.nodes.values()).filter(n => {
+            if (n.type !== 'module')
+                return false;
+            const functionCount = graph.links.filter(l => l.source === n.id && l.type === 'import' && l.target.startsWith('function')).length;
+            return functionCount > 10; // threshold
+        });
+        if (modulesWithManyFunctions.length > 0) {
+            insights.push({
+                id: 'i-1',
+                type: 'refactor',
+                title: 'God Object Detected',
+                description: `Found ${modulesWithManyFunctions.length} modules containing a large number of functions. Consider splitting them.`,
+                severity: 'high',
+                affectedNodes: modulesWithManyFunctions.map(n => n.id)
+            });
+        }
+        // 2. High coupling
+        const moduleDependencies = new Map();
+        graph.links.forEach(l => {
+            if (l.type === 'import' && l.source.startsWith('module:') && l.target.startsWith('module:')) {
+                moduleDependencies.set(l.source, (moduleDependencies.get(l.source) || 0) + 1);
+            }
+        });
+        const highlyCoupled = Array.from(moduleDependencies.entries()).filter(([_, count]) => count > 15).map(([id]) => id);
+        if (highlyCoupled.length > 0) {
+            insights.push({
+                id: 'i-2',
+                type: 'architecture',
+                title: 'High Coupling',
+                description: `Some modules have excessive external dependencies, making them hard to test.`,
+                severity: 'medium',
+                affectedNodes: highlyCoupled
+            });
+        }
+        // Generic fallback insight if none found
+        if (insights.length === 0) {
+            insights.push({
+                id: 'i-default',
+                type: 'maintainability',
+                title: 'Clean Architecture',
+                description: 'No major structural issues detected in the analyzed scope.',
+                severity: 'low',
+                affectedNodes: []
+            });
+        }
+        return insights;
+    }
+}
+//# sourceMappingURL=parser.js.map