openlore 2.0.0

package/dist/core/analyzer/dependency-graph.js

@@ -0,0 +1,752 @@
+/**
+ * Dependency Graph Service
+ *
+ * Builds a complete graph of how files relate to each other through imports.
+ * Provides metrics like in-degree, out-degree, betweenness centrality, and PageRank.
+ * Detects clusters, cycles, and special nodes (centers, leaves, bridges, orphans).
+ */
+import { ImportExportParser, resolveImport } from './import-parser.js';
+import { extractAllHttpEdges } from './http-route-parser.js';
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const CLUSTER_PALETTE = [
+    '#7c6af7',
+    '#3ecfcf',
+    '#f77c6a',
+    '#6af7a0',
+    '#f7c76a',
+    '#f76ac8',
+    '#6aaff7',
+    '#c8f76a',
+    '#f7a06a',
+    '#a0a0ff',
+    '#ff6b9d',
+    '#00d4aa',
+    '#ffb347',
+];
+// ============================================================================
+// DEPENDENCY GRAPH BUILDER
+// ============================================================================
+/**
+ * Builds and analyzes a dependency graph from scored files
+ */
+export class DependencyGraphBuilder {
+    nodes = new Map();
+    edges = [];
+    adjacencyList = new Map();
+    reverseAdjacencyList = new Map();
+    httpEdgeCount = 0;
+    parser;
+    options;
+    constructor(options) {
+        this.parser = new ImportExportParser();
+        this.options = {
+            rootDir: options.rootDir,
+            extensions: options.extensions ?? [], // empty = auto-detect per file in resolveImport
+            minClusterSize: options.minClusterSize ?? 2,
+            dampingFactor: options.dampingFactor ?? 0.85,
+            maxIterations: options.maxIterations ?? 100,
+        };
+    }
+    /**
+     * Build the dependency graph from scored files
+     */
+    async build(files) {
+        // Clear any previous state
+        this.nodes.clear();
+        this.edges = [];
+        this.adjacencyList.clear();
+        this.reverseAdjacencyList.clear();
+        this.httpEdgeCount = 0;
+        // Parse all files and create nodes
+        const analyses = await this.parseFiles(files);
+        // Create nodes for each file
+        for (const file of files) {
+            const analysis = analyses.get(file.absolutePath);
+            this.nodes.set(file.absolutePath, {
+                id: file.absolutePath,
+                file,
+                exports: analysis?.exports ?? [],
+                metrics: {
+                    inDegree: 0,
+                    outDegree: 0,
+                    betweenness: 0,
+                    pageRank: 1 / files.length,
+                },
+            });
+            this.adjacencyList.set(file.absolutePath, new Set());
+            this.reverseAdjacencyList.set(file.absolutePath, new Set());
+        }
+        // Create edges from imports
+        await this.buildEdges(files, analyses);
+        // Create cross-language edges from HTTP calls (fetch/axios → FastAPI routes)
+        await this.buildHttpCrossEdges(files);
+        // Calculate metrics
+        this.calculateDegrees();
+        this.calculateBetweenness();
+        this.calculatePageRank();
+        // Detect clusters
+        const clusters = this.detectClusters();
+        // Assign clusters to nodes
+        const clusterByNode = {};
+        clusters.forEach((cl) => {
+            cl.files.forEach((fid) => {
+                clusterByNode[fid] = { id: cl.id, name: cl.name, color: cl.color };
+            });
+        });
+        for (const [id, node] of this.nodes) {
+            node.cluster = clusterByNode[id];
+        }
+        // Detect cycles
+        const cycles = this.detectCycles();
+        // Generate rankings
+        const rankings = this.generateRankings(clusters);
+        // Calculate statistics
+        const statistics = this.calculateStatistics(clusters, cycles);
+        const structuralClusters = clusters.filter(c => c.isStructural);
+        return {
+            nodes: Array.from(this.nodes.values()),
+            edges: this.edges,
+            clusters,
+            structuralClusters,
+            rankings,
+            cycles,
+            statistics,
+        };
+    }
+    /**
+     * Parse all files to extract imports/exports
+     */
+    async parseFiles(files) {
+        const analyses = new Map();
+        for (const file of files) {
+            try {
+                const analysis = await this.parser.parseFile(file.absolutePath);
+                analyses.set(file.absolutePath, analysis);
+            }
+            catch (error) {
+                // File couldn't be parsed (binary, syntax error, etc.) — skip it
+                if (process.env.DEBUG) {
+                    console.debug(`[dep-graph] Failed to parse ${file.absolutePath}: ${error.message}`);
+                }
+            }
+        }
+        return analyses;
+    }
+    /**
+     * Build cross-language edges by matching HTTP calls in JS/TS files to
+     * FastAPI/Flask/Django route definitions in Python files.
+     * Only creates edges between files that are already nodes in the graph.
+     */
+    async buildHttpCrossEdges(files) {
+        const fileSet = new Set(files.map(f => f.absolutePath));
+        const filePaths = Array.from(fileSet);
+        // Skip HTTP edge detection entirely when there cannot be any cross-language
+        // edges: we need at least one caller file AND at least one handler file.
+        // Callers are JS/TS. Handlers can be Python, Java, or TS/JS (server-side).
+        const jsExts = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+        const pyExts = new Set(['.py', '.pyw']);
+        const hasJs = filePaths.some(fp => jsExts.has(fp.slice(fp.lastIndexOf('.')).toLowerCase()));
+        const hasHandler = filePaths.some(fp => {
+            const ext = fp.slice(fp.lastIndexOf('.')).toLowerCase();
+            return pyExts.has(ext) || ext === '.java';
+        });
+        if (!hasJs || !hasHandler)
+            return;
+        const { edges: httpEdges } = await extractAllHttpEdges(filePaths);
+        for (const httpEdge of httpEdges) {
+            // Both ends must be known nodes
+            if (!fileSet.has(httpEdge.callerFile) || !fileSet.has(httpEdge.handlerFile))
+                continue;
+            // Skip self-loops
+            if (httpEdge.callerFile === httpEdge.handlerFile)
+                continue;
+            // Weight by confidence: exact=1.0, path=0.75, fuzzy=0.5
+            const weight = httpEdge.confidence === 'exact' ? 1.0 :
+                httpEdge.confidence === 'path' ? 0.75 : 0.5;
+            const edge = {
+                source: httpEdge.callerFile,
+                target: httpEdge.handlerFile,
+                importedNames: [httpEdge.route.handlerName],
+                isTypeOnly: false,
+                weight,
+                httpEdge,
+            };
+            this.edges.push(edge);
+            this.httpEdgeCount++;
+            this.adjacencyList.get(httpEdge.callerFile)?.add(httpEdge.handlerFile);
+            this.reverseAdjacencyList.get(httpEdge.handlerFile)?.add(httpEdge.callerFile);
+        }
+    }
+    /**
+     * Build edges from import relationships
+     */
+    async buildEdges(files, analyses) {
+        const fileSet = new Set(files.map(f => f.absolutePath));
+        for (const file of files) {
+            const analysis = analyses.get(file.absolutePath);
+            if (!analysis)
+                continue;
+            const isPythonFile = file.absolutePath.endsWith('.py') || file.absolutePath.endsWith('.pyw');
+            const isJavaFile = file.absolutePath.endsWith('.java');
+            for (const imp of analysis.imports) {
+                // Skip non-relative imports for JS/TS (those are always npm packages).
+                // For Python files we must NOT skip: `from services.retriever import X`
+                // is flagged isRelative=false but may resolve to a local module.
+                // For Java files we also must NOT skip: imports are always absolute
+                // class FQNs and we try to resolve them against the project source root.
+                if (!imp.isRelative && !isPythonFile && !isJavaFile)
+                    continue;
+                // Skip known builtins and third-party packages that can't resolve to
+                // a file inside the project (Python stdlib, JDK, Spring, etc.).
+                if (!imp.isRelative && imp.isBuiltin)
+                    continue;
+                // Resolve the import to an absolute path
+                const resolvedPath = await resolveImport(imp.source, file.absolutePath, {
+                    baseDir: this.options.rootDir,
+                    extensions: this.options.extensions.length > 0 ? this.options.extensions : undefined,
+                    sourcePackage: isJavaFile ? analysis.javaPackage : undefined,
+                });
+                // Skip if not resolved or not in our file set
+                if (!resolvedPath || !fileSet.has(resolvedPath))
+                    continue;
+                // Create edge
+                const edge = {
+                    source: file.absolutePath,
+                    target: resolvedPath,
+                    importedNames: imp.importedNames,
+                    isTypeOnly: imp.isTypeOnly,
+                    weight: imp.isTypeOnly ? 0.5 : 1,
+                };
+                this.edges.push(edge);
+                // Update adjacency lists
+                this.adjacencyList.get(file.absolutePath)?.add(resolvedPath);
+                this.reverseAdjacencyList.get(resolvedPath)?.add(file.absolutePath);
+            }
+        }
+    }
+    /**
+     * Calculate in-degree and out-degree for each node
+     */
+    calculateDegrees() {
+        for (const [nodeId, node] of this.nodes) {
+            node.metrics.outDegree = this.adjacencyList.get(nodeId)?.size ?? 0;
+            node.metrics.inDegree = this.reverseAdjacencyList.get(nodeId)?.size ?? 0;
+        }
+    }
+    /**
+     * Calculate betweenness centrality using Brandes' algorithm
+     */
+    calculateBetweenness() {
+        const nodeIds = Array.from(this.nodes.keys());
+        const betweenness = new Map();
+        // Initialize betweenness to 0
+        for (const id of nodeIds) {
+            betweenness.set(id, 0);
+        }
+        // Brandes' algorithm
+        for (const source of nodeIds) {
+            const stack = [];
+            const predecessors = new Map();
+            const sigma = new Map();
+            const distance = new Map();
+            const delta = new Map();
+            // Initialize
+            for (const v of nodeIds) {
+                predecessors.set(v, []);
+                sigma.set(v, 0);
+                distance.set(v, -1);
+                delta.set(v, 0);
+            }
+            sigma.set(source, 1);
+            distance.set(source, 0);
+            // BFS
+            const queue = [source];
+            while (queue.length > 0) {
+                const v = queue.shift();
+                stack.push(v);
+                const neighbors = this.adjacencyList.get(v) ?? new Set();
+                for (const w of neighbors) {
+                    // First visit?
+                    if (distance.get(w) < 0) {
+                        queue.push(w);
+                        distance.set(w, distance.get(v) + 1);
+                    }
+                    // Shortest path to w via v?
+                    if (distance.get(w) === distance.get(v) + 1) {
+                        sigma.set(w, sigma.get(w) + sigma.get(v));
+                        predecessors.get(w).push(v);
+                    }
+                }
+            }
+            // Back-propagation
+            while (stack.length > 0) {
+                const w = stack.pop();
+                for (const v of predecessors.get(w)) {
+                    delta.set(v, delta.get(v) + (sigma.get(v) / sigma.get(w)) * (1 + delta.get(w)));
+                }
+                if (w !== source) {
+                    betweenness.set(w, betweenness.get(w) + delta.get(w));
+                }
+            }
+        }
+        // Normalize and update nodes
+        const maxBetweenness = Array.from(betweenness.values()).reduce((a, b) => Math.max(a, b), 1);
+        for (const [nodeId, node] of this.nodes) {
+            node.metrics.betweenness = betweenness.get(nodeId) / maxBetweenness;
+        }
+    }
+    /**
+     * Calculate PageRank-style importance scores
+     */
+    calculatePageRank() {
+        const nodeIds = Array.from(this.nodes.keys());
+        const n = nodeIds.length;
+        if (n === 0)
+            return;
+        const d = this.options.dampingFactor;
+        let pageRank = new Map();
+        let newPageRank = new Map();
+        // Initialize
+        for (const id of nodeIds) {
+            pageRank.set(id, 1 / n);
+        }
+        // Iterate until convergence
+        for (let iter = 0; iter < this.options.maxIterations; iter++) {
+            let maxDiff = 0;
+            for (const id of nodeIds) {
+                // Sum contributions from nodes that link to this one
+                let sum = 0;
+                const incomingNodes = this.reverseAdjacencyList.get(id) ?? new Set();
+                for (const source of incomingNodes) {
+                    const outDegree = this.adjacencyList.get(source)?.size ?? 1;
+                    sum += pageRank.get(source) / outDegree;
+                }
+                const newRank = (1 - d) / n + d * sum;
+                newPageRank.set(id, newRank);
+                maxDiff = Math.max(maxDiff, Math.abs(newRank - pageRank.get(id)));
+            }
+            // Swap
+            [pageRank, newPageRank] = [newPageRank, pageRank];
+            // Check convergence
+            if (maxDiff < 1e-6)
+                break;
+        }
+        // Normalize and update nodes
+        const maxPageRank = Array.from(pageRank.values()).reduce((a, b) => Math.max(a, b), 0.001);
+        for (const [nodeId, node] of this.nodes) {
+            node.metrics.pageRank = pageRank.get(nodeId) / maxPageRank;
+        }
+    }
+    /**
+     * Detect clusters using a simple community detection approach
+     * Groups files by their common directory prefix and connectivity
+     */
+    detectClusters() {
+        const clusters = [];
+        const nodeIds = Array.from(this.nodes.keys());
+        // Group by directory
+        const dirGroups = new Map();
+        for (const nodeId of nodeIds) {
+            const node = this.nodes.get(nodeId);
+            const dir = node.file.directory || '(root)';
+            if (!dirGroups.has(dir)) {
+                dirGroups.set(dir, []);
+            }
+            dirGroups.get(dir).push(nodeId);
+        }
+        // Create clusters from directory groups
+        let clusterId = 0;
+        for (const [dir, files] of dirGroups) {
+            if (files.length < this.options.minClusterSize)
+                continue;
+            // Calculate internal and external edges
+            let internalEdges = 0;
+            let externalEdges = 0;
+            const fileSet = new Set(files);
+            for (const edge of this.edges) {
+                const sourceInCluster = fileSet.has(edge.source);
+                const targetInCluster = fileSet.has(edge.target);
+                if (sourceInCluster && targetInCluster) {
+                    internalEdges++;
+                }
+                else if (sourceInCluster || targetInCluster) {
+                    externalEdges++;
+                }
+            }
+            // Calculate cohesion (internal density)
+            const possibleInternalEdges = files.length * (files.length - 1);
+            const cohesion = possibleInternalEdges > 0 ? internalEdges / possibleInternalEdges : 0;
+            // Calculate coupling (external connections)
+            const totalEdges = internalEdges + externalEdges;
+            const coupling = totalEdges > 0 ? externalEdges / totalEdges : 0;
+            // Generate suggested domain name
+            const suggestedDomain = this.suggestDomainName(dir, files);
+            clusters.push({
+                id: `cluster-${clusterId}`,
+                name: dir,
+                files,
+                internalEdges,
+                externalEdges,
+                cohesion,
+                coupling,
+                suggestedDomain,
+                color: CLUSTER_PALETTE[clusterId++ % CLUSTER_PALETTE.length],
+                isStructural: internalEdges > 0,
+            });
+        }
+        return clusters;
+    }
+    /**
+     * Suggest a domain name based on directory and file contents
+     */
+    suggestDomainName(dir, files) {
+        // Extract meaningful name from directory
+        const parts = dir.split('/').filter(p => p && p !== '(root)');
+        // Common patterns to convert
+        const patterns = [
+            [/^src$/i, ''],
+            [/^lib$/i, ''],
+            [/^app$/i, ''],
+            [/^(api|routes|endpoints?)$/i, 'api'],
+            [/^(models?|entities|schemas?)$/i, 'domain'],
+            [/^(services?)$/i, 'services'],
+            [/^(controllers?)$/i, 'controllers'],
+            [/^(utils?|helpers?|common)$/i, 'utilities'],
+            [/^(components?)$/i, 'components'],
+            [/^(hooks?)$/i, 'hooks'],
+            [/^(auth|authentication)$/i, 'authentication'],
+            [/^(users?)$/i, 'users'],
+            [/^(products?)$/i, 'products'],
+            [/^(orders?)$/i, 'orders'],
+            [/^(payments?)$/i, 'payments'],
+            [/^(core)$/i, 'core'],
+        ];
+        // Try to find a meaningful name
+        for (const part of parts.reverse()) {
+            for (const [pattern, replacement] of patterns) {
+                if (pattern.test(part)) {
+                    return replacement || part.toLowerCase();
+                }
+            }
+            // If no pattern matches, use the part as-is
+            if (!/^(src|lib|app)$/i.test(part)) {
+                return part.toLowerCase().replace(/[^a-z0-9]/g, '-');
+            }
+        }
+        // Fallback: use first file's name pattern
+        if (files.length > 0) {
+            const firstFile = this.nodes.get(files[0])?.file.name ?? 'unknown';
+            return firstFile.replace(/\.(ts|js|tsx|jsx|py)x?$/, '').toLowerCase();
+        }
+        return 'misc';
+    }
+    /**
+     * Detect cycles in the dependency graph using DFS
+     */
+    detectCycles() {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        const dfs = (node) => {
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const neighbors = this.adjacencyList.get(node) ?? new Set();
+            for (const neighbor of neighbors) {
+                if (!visited.has(neighbor)) {
+                    dfs(neighbor);
+                }
+                else if (recursionStack.has(neighbor)) {
+                    // Found a cycle
+                    const cycleStart = path.indexOf(neighbor);
+                    const cycle = path.slice(cycleStart);
+                    cycle.push(neighbor); // Complete the cycle
+                    // Check if this cycle is not a duplicate (or rotation of existing)
+                    if (!this.isDuplicateCycle(cycles, cycle)) {
+                        cycles.push(cycle);
+                    }
+                }
+            }
+            path.pop();
+            recursionStack.delete(node);
+        };
+        for (const nodeId of this.nodes.keys()) {
+            if (!visited.has(nodeId)) {
+                dfs(nodeId);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * Check if a cycle is a duplicate or rotation of an existing cycle
+     */
+    isDuplicateCycle(existingCycles, newCycle) {
+        const normalizedNew = this.normalizeCycle(newCycle);
+        for (const existing of existingCycles) {
+            const normalizedExisting = this.normalizeCycle(existing);
+            if (normalizedNew === normalizedExisting) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Normalize a cycle for comparison (smallest element first, then compare)
+     */
+    normalizeCycle(cycle) {
+        // Remove the duplicate closing element
+        const clean = cycle.slice(0, -1);
+        if (clean.length === 0)
+            return '';
+        // Find the smallest element
+        const minIdx = clean.indexOf(clean.reduce((min, curr) => (curr < min ? curr : min)));
+        // Rotate so smallest is first
+        const rotated = [...clean.slice(minIdx), ...clean.slice(0, minIdx)];
+        return rotated.join('|');
+    }
+    /**
+     * Generate various rankings of nodes
+     */
+    generateRankings(clusters) {
+        const nodes = Array.from(this.nodes.values());
+        // By PageRank importance — use .slice() to avoid mutating the shared array
+        const byImportance = nodes
+            .slice()
+            .sort((a, b) => b.metrics.pageRank - a.metrics.pageRank)
+            .map(n => n.id);
+        // By total connectivity (in + out degree)
+        const byConnectivity = nodes
+            .slice()
+            .sort((a, b) => (b.metrics.inDegree + b.metrics.outDegree) -
+            (a.metrics.inDegree + a.metrics.outDegree))
+            .map(n => n.id);
+        // Cluster centers (highest in-degree within each cluster)
+        const clusterCenters = [];
+        for (const cluster of clusters) {
+            const clusterNodes = cluster.files
+                .map(f => this.nodes.get(f))
+                .filter((n) => n !== undefined);
+            if (clusterNodes.length > 0) {
+                const center = clusterNodes.reduce((max, n) => n.metrics.inDegree > max.metrics.inDegree ? n : max);
+                clusterCenters.push(center.id);
+            }
+        }
+        // Leaf nodes (high out-degree, low in-degree)
+        const leafNodes = nodes
+            .filter(n => n.metrics.outDegree > 0 && n.metrics.inDegree === 0)
+            .sort((a, b) => b.metrics.outDegree - a.metrics.outDegree)
+            .map(n => n.id);
+        // Bridge nodes (high betweenness)
+        const bridgeNodes = nodes
+            .filter(n => n.metrics.betweenness > 0.1)
+            .sort((a, b) => b.metrics.betweenness - a.metrics.betweenness)
+            .map(n => n.id);
+        // Orphan nodes (no connections)
+        const orphanNodes = nodes
+            .filter(n => n.metrics.inDegree === 0 && n.metrics.outDegree === 0)
+            .map(n => n.id);
+        return {
+            byImportance,
+            byConnectivity,
+            clusterCenters,
+            leafNodes,
+            bridgeNodes,
+            orphanNodes,
+        };
+    }
+    /**
+     * Calculate overall statistics
+     */
+    calculateStatistics(clusters, cycles) {
+        const nodeCount = this.nodes.size;
+        const edgeCount = this.edges.length;
+        // Average degree
+        let totalDegree = 0;
+        for (const node of this.nodes.values()) {
+            totalDegree += node.metrics.inDegree + node.metrics.outDegree;
+        }
+        const avgDegree = nodeCount > 0 ? totalDegree / nodeCount : 0;
+        // Density: actual edges / possible edges
+        const possibleEdges = nodeCount * (nodeCount - 1);
+        const density = possibleEdges > 0 ? edgeCount / possibleEdges : 0;
+        return {
+            nodeCount,
+            edgeCount,
+            importEdgeCount: edgeCount - this.httpEdgeCount,
+            httpEdgeCount: this.httpEdgeCount,
+            avgDegree,
+            density,
+            clusterCount: clusters.length,
+            structuralClusterCount: clusters.filter(c => c.isStructural).length,
+            cycleCount: cycles.length,
+        };
+    }
+}
+// ============================================================================
+// CONVENIENCE FUNCTIONS
+// ============================================================================
+/**
+ * Build a dependency graph from scored files
+ */
+export async function buildDependencyGraph(files, options) {
+    const builder = new DependencyGraphBuilder(options);
+    return builder.build(files);
+}
+// ============================================================================
+// CALL-GRAPH EDGE INJECTION
+// ============================================================================
+/**
+ * Languages that share a module-level namespace without explicit intra-file imports.
+ * For these, dependency edges must be derived from the call graph rather than imports.
+ */
+const IMPLICIT_IMPORT_LANGS = new Set(['Swift', 'C++', 'C']);
+/**
+ * Synthesize dependency edges from cross-file call edges and inject them into
+ * an existing DependencyGraphResult in-place.
+ *
+ * Use this for languages like Swift or C++ that don't have explicit intra-module
+ * imports, resulting in an empty dep graph when only import-based edges are built.
+ */
+export function injectCallGraphEdges(depGraph, callEdges, nodeFilePath) {
+    // Build a Set of node IDs for quick membership test
+    const nodeIds = new Set(depGraph.nodes.map(n => n.id));
+    // Collect unique file-level edges
+    const seen = new Set();
+    const newEdges = [];
+    for (const ce of callEdges) {
+        const callerFile = nodeFilePath(ce.callerId);
+        const calleeFile = nodeFilePath(ce.calleeId);
+        if (!callerFile || !calleeFile || callerFile === calleeFile)
+            continue;
+        if (!nodeIds.has(callerFile) || !nodeIds.has(calleeFile))
+            continue;
+        const key = `${callerFile}→${calleeFile}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        newEdges.push({ source: callerFile, target: calleeFile, importedNames: [], isTypeOnly: false, weight: 1, isCallEdge: true });
+    }
+    if (newEdges.length === 0)
+        return;
+    depGraph.edges.push(...newEdges);
+    // Recompute node in/out degrees
+    const inDeg = new Map();
+    const outDeg = new Map();
+    for (const e of depGraph.edges) {
+        outDeg.set(e.source, (outDeg.get(e.source) ?? 0) + 1);
+        inDeg.set(e.target, (inDeg.get(e.target) ?? 0) + 1);
+    }
+    for (const node of depGraph.nodes) {
+        node.metrics.inDegree = inDeg.get(node.id) ?? 0;
+        node.metrics.outDegree = outDeg.get(node.id) ?? 0;
+    }
+    // Update statistics
+    depGraph.statistics.edgeCount = depGraph.edges.length;
+    const totalDegree = depGraph.nodes.reduce((s, n) => s + n.metrics.inDegree + n.metrics.outDegree, 0);
+    depGraph.statistics.avgDegree = depGraph.nodes.length > 0 ? totalDegree / depGraph.nodes.length : 0;
+    const possible = depGraph.statistics.nodeCount * (depGraph.statistics.nodeCount - 1);
+    depGraph.statistics.density = possible > 0 ? depGraph.statistics.edgeCount / possible : 0;
+    // Recompute cluster internalEdges and rebuild structuralClusters.
+    // Without this, the viewer's cluster view stays empty even when edges exist.
+    const fileToCluster = new Map();
+    for (const cl of depGraph.clusters) {
+        for (const fid of cl.files)
+            fileToCluster.set(fid, cl.id);
+    }
+    const clusterInternalEdges = new Map();
+    for (const e of depGraph.edges) {
+        const sc = fileToCluster.get(e.source);
+        const tc = fileToCluster.get(e.target);
+        if (sc && sc === tc)
+            clusterInternalEdges.set(sc, (clusterInternalEdges.get(sc) ?? 0) + 1);
+    }
+    for (const cl of depGraph.clusters) {
+        cl.internalEdges = clusterInternalEdges.get(cl.id) ?? 0;
+        cl.isStructural = cl.internalEdges > 0;
+    }
+    depGraph.structuralClusters = depGraph.clusters.filter(cl => cl.internalEdges > 0);
+    depGraph.statistics.structuralClusterCount = depGraph.structuralClusters.length;
+}
+export { IMPLICIT_IMPORT_LANGS };
+// ============================================================================
+// EXPORT FORMATS
+// ============================================================================
+/**
+ * Convert graph to D3.js force graph format
+ */
+export function toD3Format(result) {
+    // Use only structural clusters for group colouring — directory-only
+    // clusters (cohesion=0) would produce too many indistinct colour groups.
+    const clusterIndex = new Map();
+    result.structuralClusters.forEach((cluster, idx) => {
+        for (const file of cluster.files) {
+            clusterIndex.set(file, idx);
+        }
+    });
+    return {
+        nodes: result.nodes.map(n => ({
+            id: n.file.path,
+            group: clusterIndex.get(n.id) ?? -1,
+            score: n.metrics.pageRank,
+        })),
+        links: result.edges.map(e => ({
+            source: result.nodes.find(n => n.id === e.source)?.file.path ?? e.source,
+            target: result.nodes.find(n => n.id === e.target)?.file.path ?? e.target,
+            value: e.weight,
+        })),
+    };
+}
+/**
+ * Convert graph to Mermaid diagram syntax
+ */
+export function toMermaidFormat(result, maxNodes = 50) {
+    const lines = ['graph TD'];
+    // Take top nodes by importance
+    const topNodes = result.rankings.byImportance.slice(0, maxNodes);
+    const nodeSet = new Set(topNodes);
+    // Create node labels
+    const nodeLabels = new Map();
+    result.nodes
+        .filter(n => nodeSet.has(n.id))
+        .forEach((n, idx) => {
+        const label = `N${idx}`;
+        nodeLabels.set(n.id, label);
+        const name = n.file.name.replace(/["[\]]/g, '');
+        lines.push(`    ${label}["${name}"]`);
+    });
+    // Create edges
+    for (const edge of result.edges) {
+        const sourceLabel = nodeLabels.get(edge.source);
+        const targetLabel = nodeLabels.get(edge.target);
+        if (sourceLabel && targetLabel) {
+            const style = edge.isTypeOnly ? '-.->' : '-->';
+            lines.push(`    ${sourceLabel} ${style} ${targetLabel}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Convert graph to DOT format (Graphviz)
+ */
+export function toDotFormat(result) {
+    const lines = ['digraph Dependencies {'];
+    lines.push('    rankdir=LR;');
+    lines.push('    node [shape=box];');
+    // Create node definitions with labels
+    for (const node of result.nodes) {
+        const name = node.file.name.replace(/"/g, '\\"');
+        const color = node.metrics.pageRank > 0.5 ? 'lightblue' : 'white';
+        lines.push(`    "${node.id}" [label="${name}" fillcolor="${color}" style="filled"];`);
+    }
+    // Create edges
+    for (const edge of result.edges) {
+        const style = edge.isTypeOnly ? 'dashed' : 'solid';
+        lines.push(`    "${edge.source}" -> "${edge.target}" [style="${style}"];`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+//# sourceMappingURL=dependency-graph.js.map