kynjal-cli 4.0.0 → 4.0.1

package/dist/src/ruvector/graph-analyzer.js

@@ -11,62 +11,6 @@
  *
  * @module @claude-flow/cli/ruvector/graph-analyzer
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { readFile, readdir, stat } from 'fs/promises';
 import { join, relative, extname, dirname, basename } from 'path';
 // ============================================================================
@@ -75,13 +19,13 @@ import { join, relative, extname, dirname, basename } from 'path';
 /**
  * Cache for dependency graphs (5 minute TTL)
  */
-var graphCache = new Map();
-var GRAPH_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const graphCache = new Map();
+const GRAPH_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 /**
  * Cache for analysis results (2 minute TTL)
  */
-var analysisResultCache = new Map();
-var ANALYSIS_CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
+const analysisResultCache = new Map();
+const ANALYSIS_CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
 /**
  * Clear all graph caches
  */
@@ -95,64 +39,53 @@ export function clearGraphCaches() {
 export function getGraphCacheStats() {
     return {
         graphCacheSize: graphCache.size,
-        analysisCacheSize: analysisResultCache.size
+        analysisCacheSize: analysisResultCache.size,
     };
 }
-var ruVectorGraph = null;
-var ruVectorLoadAttempted = false;
+let ruVectorGraph = null;
+let ruVectorLoadAttempted = false;
 /**
  * Attempt to load ruvector graph algorithms
  */
-function loadRuVector() {
-    return __awaiter(this, void 0, Promise, function () {
-        var ruvectorModule, wasmModule, ruvector_1, _a, wasm, analyzer_1, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (ruVectorLoadAttempted)
-                        return [2 /*return*/, ruVectorGraph];
-                    ruVectorLoadAttempted = true;
-                    ruvectorModule = 'ruvector';
-                    wasmModule = '@ruvector/wasm';
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 3, , 8]);
-                    return [4 /*yield*/, import(/* webpackIgnore: true */ ruvectorModule)["catch"](function () { return null; })];
-                case 2:
-                    ruvector_1 = _c.sent();
-                    if (ruvector_1 && typeof ruvector_1.hooks_graph_mincut === 'function' && typeof ruvector_1.hooks_graph_cluster === 'function') {
-                        ruVectorGraph = {
-                            mincut: function (nodes, edges) { return ruvector_1.hooks_graph_mincut(nodes, edges); },
-                            louvain: function (nodes, edges) { return ruvector_1.hooks_graph_cluster(nodes, edges); }
-                        };
-                        return [2 /*return*/, ruVectorGraph];
-                    }
-                    return [3 /*break*/, 8];
-                case 3:
-                    _a = _c.sent();
-                    _c.label = 4;
-                case 4:
-                    _c.trys.push([4, 6, , 7]);
-                    return [4 /*yield*/, import(/* webpackIgnore: true */ wasmModule)["catch"](function () { return null; })];
-                case 5:
-                    wasm = _c.sent();
-                    if (wasm && wasm.GraphAnalyzer) {
-                        analyzer_1 = new wasm.GraphAnalyzer();
-                        ruVectorGraph = {
-                            mincut: function (nodes, edges) { return analyzer_1.mincut(nodes, edges); },
-                            louvain: function (nodes, edges) { return analyzer_1.louvain(nodes, edges); }
-                        };
-                        return [2 /*return*/, ruVectorGraph];
-                    }
-                    return [3 /*break*/, 7];
-                case 6:
-                    _b = _c.sent();
-                    return [3 /*break*/, 7];
-                case 7: return [3 /*break*/, 8];
-                case 8: return [2 /*return*/, null];
+async function loadRuVector() {
+    if (ruVectorLoadAttempted)
+        return ruVectorGraph;
+    ruVectorLoadAttempted = true;
+    // Use dynamic module names to bypass TypeScript static analysis
+    // These modules are optional and may not be installed
+    const ruvectorModule = 'ruvector';
+    const wasmModule = '@ruvector/wasm';
+    try {
+        // Try to load ruvector's graph module
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ruvector = await import(/* webpackIgnore: true */ ruvectorModule).catch(() => null);
+        if (ruvector && typeof ruvector.hooks_graph_mincut === 'function' && typeof ruvector.hooks_graph_cluster === 'function') {
+            ruVectorGraph = {
+                mincut: (nodes, edges) => ruvector.hooks_graph_mincut(nodes, edges),
+                louvain: (nodes, edges) => ruvector.hooks_graph_cluster(nodes, edges),
+            };
+            return ruVectorGraph;
+        }
+    }
+    catch {
+        // Try alternative import paths
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const wasm = await import(/* webpackIgnore: true */ wasmModule).catch(() => null);
+            if (wasm && wasm.GraphAnalyzer) {
+                const analyzer = new wasm.GraphAnalyzer();
+                ruVectorGraph = {
+                    mincut: (nodes, edges) => analyzer.mincut(nodes, edges),
+                    louvain: (nodes, edges) => analyzer.louvain(nodes, edges),
+                };
+                return ruVectorGraph;
             }
-        });
-    });
+        }
+        catch {
+            // Fallback will be used
+        }
+    }
+    return null;
 }
 // ============================================================================
 // Import/Require Parser
@@ -161,30 +94,30 @@ function loadRuVector() {
  * Extract imports from TypeScript/JavaScript file
  */
 function extractImports(content, _filePath) {
-    var imports = [];
+    const imports = [];
     // ES6 import statements
-    var esImportRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s*from\s*['"]([^'"]+)['"]/g;
-    var match;
+    const esImportRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s*from\s*['"]([^'"]+)['"]/g;
+    let match;
     while ((match = esImportRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'import' });
     }
     // Side-effect imports: import 'module'
-    var sideEffectRegex = /import\s+['"]([^'"]+)['"]/g;
+    const sideEffectRegex = /import\s+['"]([^'"]+)['"]/g;
     while ((match = sideEffectRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'import' });
     }
     // CommonJS require
-    var requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
     while ((match = requireRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'require' });
     }
     // Dynamic imports
-    var dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
     while ((match = dynamicImportRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'dynamic' });
     }
     // Re-exports: export * from 'module'
-    var reExportRegex = /export\s+(?:\*|\{[^}]*\})\s+from\s*['"]([^'"]+)['"]/g;
+    const reExportRegex = /export\s+(?:\*|\{[^}]*\})\s+from\s*['"]([^'"]+)['"]/g;
     while ((match = reExportRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 're-export' });
     }
@@ -194,18 +127,18 @@ function extractImports(content, _filePath) {
  * Extract exports from TypeScript/JavaScript file
  */
 function extractExports(content) {
-    var exports = [];
+    const exports = [];
     // Named exports
-    var namedExportRegex = /export\s+(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/g;
-    var match;
+    const namedExportRegex = /export\s+(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/g;
+    let match;
     while ((match = namedExportRegex.exec(content)) !== null) {
         exports.push(match[1]);
     }
     // Export list: export { a, b, c }
-    var exportListRegex = /export\s+\{([^}]+)\}/g;
+    const exportListRegex = /export\s+\{([^}]+)\}/g;
     while ((match = exportListRegex.exec(content)) !== null) {
-        var names = match[1].split(',').map(function (n) { return n.trim().split(/\s+as\s+/)[0].trim(); });
-        exports.push.apply(exports, names.filter(function (n) { return n; }));
+        const names = match[1].split(',').map(n => n.trim().split(/\s+as\s+/)[0].trim());
+        exports.push(...names.filter(n => n));
     }
     // Default export
     if (/export\s+default/.test(content)) {
@@ -221,8 +154,8 @@ function resolveImportPath(importPath, fromFile, rootDir) {
     if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
         return null;
     }
-    var fromDir = dirname(fromFile);
-    var resolved;
+    const fromDir = dirname(fromFile);
+    let resolved;
     if (importPath.startsWith('/')) {
         resolved = join(rootDir, importPath);
     }
@@ -230,13 +163,12 @@ function resolveImportPath(importPath, fromFile, rootDir) {
         resolved = join(fromDir, importPath);
     }
     // Handle extension-less imports
-    var ext = extname(resolved);
+    const ext = extname(resolved);
     if (!ext) {
         // Try common extensions
-        var extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-        for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
-            var tryExt = extensions_1[_i];
-            var tryPath = resolved + tryExt;
+        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+        for (const tryExt of extensions) {
+            const tryPath = resolved + tryExt;
             return tryPath; // Return normalized, existence check done later
         }
         // Could be index file
@@ -250,209 +182,161 @@ function resolveImportPath(importPath, fromFile, rootDir) {
 /**
  * Build dependency graph from source directory (with caching)
  */
-export function buildDependencyGraph(rootDir, options) {
-    var _a;
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, Promise, function () {
-        /**
-         * Check if path should be excluded
-         */
-        function shouldExclude(path) {
-            var name = basename(path);
-            return exclude.some(function (pattern) {
-                if (pattern.includes('*')) {
-                    var regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-                    return regex.test(name);
-                }
-                return name === pattern || path.includes("/" + pattern + "/");
-            });
+export async function buildDependencyGraph(rootDir, options = {}) {
+    // Check cache first
+    const cacheKey = `${rootDir}:${JSON.stringify(options)}`;
+    if (!options.skipCache) {
+        const cached = graphCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < GRAPH_CACHE_TTL_MS) {
+            return cached.graph;
         }
-        /**
-         * Recursively scan directory for source files
-         */
-        function scanDir(dir, depth) {
-            return __awaiter(this, void 0, Promise, function () {
-                var entries, _i, entries_1, entry, fullPath, relPath, ext, _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            if (depth > maxDepth)
-                                return [2 /*return*/];
-                            _b.label = 1;
-                        case 1:
-                            _b.trys.push([1, 9, , 10]);
-                            return [4 /*yield*/, readdir(dir, { withFileTypes: true })];
-                        case 2:
-                            entries = _b.sent();
-                            _i = 0, entries_1 = entries;
-                            _b.label = 3;
-                        case 3:
-                            if (!(_i < entries_1.length)) return [3 /*break*/, 8];
-                            entry = entries_1[_i];
-                            fullPath = join(dir, entry.name);
-                            relPath = relative(rootDir, fullPath);
-                            if (shouldExclude(fullPath))
-                                return [3 /*break*/, 7];
-                            if (!entry.isDirectory()) return [3 /*break*/, 5];
-                            return [4 /*yield*/, scanDir(fullPath, depth + 1)];
-                        case 4:
-                            _b.sent();
-                            return [3 /*break*/, 7];
-                        case 5:
-                            if (!entry.isFile()) return [3 /*break*/, 7];
-                            ext = extname(entry.name);
-                            if (!include.includes(ext)) return [3 /*break*/, 7];
-                            return [4 /*yield*/, processFile(fullPath, relPath)];
-                        case 6:
-                            _b.sent();
-                            _b.label = 7;
-                        case 7:
-                            _i++;
-                            return [3 /*break*/, 3];
-                        case 8: return [3 /*break*/, 10];
-                        case 9:
-                            _a = _b.sent();
-                            return [3 /*break*/, 10];
-                        case 10: return [2 /*return*/];
+    }
+    const startTime = Date.now();
+    const nodes = new Map();
+    const edges = [];
+    const include = options.include || ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+    const exclude = options.exclude || ['node_modules', 'dist', 'build', '.git', '__tests__', '*.test.*', '*.spec.*'];
+    const maxDepth = options.maxDepth ?? 10;
+    /**
+     * Check if path should be excluded
+     */
+    function shouldExclude(path) {
+        const name = basename(path);
+        return exclude.some(pattern => {
+            if (pattern.includes('*')) {
+                const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                return regex.test(name);
+            }
+            return name === pattern || path.includes(`/${pattern}/`);
+        });
+    }
+    /**
+     * Recursively scan directory for source files
+     */
+    async function scanDir(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(dir, entry.name);
+                const relPath = relative(rootDir, fullPath);
+                if (shouldExclude(fullPath))
+                    continue;
+                if (entry.isDirectory()) {
+                    await scanDir(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    const ext = extname(entry.name);
+                    if (include.includes(ext)) {
+                        await processFile(fullPath, relPath);
                     }
-                });
-            });
+                }
+            }
         }
-        /**
-         * Process a single source file
-         */
-        function processFile(fullPath, relPath) {
-            return __awaiter(this, void 0, Promise, function () {
-                var content, fileStats, imports, exportsList, node, _i, imports_1, imp, resolved, targetRel, _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _b.trys.push([0, 3, , 4]);
-                            return [4 /*yield*/, readFile(fullPath, 'utf-8')];
-                        case 1:
-                            content = _b.sent();
-                            return [4 /*yield*/, stat(fullPath)];
-                        case 2:
-                            fileStats = _b.sent();
-                            imports = extractImports(content, fullPath);
-                            exportsList = extractExports(content);
-                            node = {
-                                id: relPath,
-                                path: relPath,
-                                name: basename(relPath, extname(relPath)),
-                                type: 'file',
-                                imports: imports.map(function (i) { return i.path; }),
-                                exports: exportsList,
-                                size: fileStats.size,
-                                complexity: estimateComplexity(content)
-                            };
-                            nodes.set(relPath, node);
-                            // Create edges for imports
-                            for (_i = 0, imports_1 = imports; _i < imports_1.length; _i++) {
-                                imp = imports_1[_i];
-                                resolved = resolveImportPath(imp.path, fullPath, rootDir);
-                                if (resolved) {
-                                    targetRel = relative(rootDir, resolved);
-                                    edges.push({
-                                        source: relPath,
-                                        target: targetRel,
-                                        type: imp.type,
-                                        weight: imp.type === 're-export' ? 2 : 1
-                                    });
-                                }
-                            }
-                            return [3 /*break*/, 4];
-                        case 3:
-                            _a = _b.sent();
-                            return [3 /*break*/, 4];
-                        case 4: return [2 /*return*/];
-                    }
-                });
-            });
+        catch {
+            // Directory not readable, skip
         }
-        var cacheKey, cached, startTime, nodes, edges, include, exclude, maxDepth, normalizedEdges, _i, edges_1, edge, targetKey, extensions, baseTarget, _b, extensions_2, ext, graph;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    cacheKey = rootDir + ":" + JSON.stringify(options);
-                    if (!options.skipCache) {
-                        cached = graphCache.get(cacheKey);
-                        if (cached && Date.now() - cached.timestamp < GRAPH_CACHE_TTL_MS) {
-                            return [2 /*return*/, cached.graph];
-                        }
-                    }
-                    startTime = Date.now();
-                    nodes = new Map();
-                    edges = [];
-                    include = options.include || ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-                    exclude = options.exclude || ['node_modules', 'dist', 'build', '.git', '__tests__', '*.test.*', '*.spec.*'];
-                    maxDepth = (_a = options.maxDepth) !== null && _a !== void 0 ? _a : 10;
-                    // Build the graph
-                    return [4 /*yield*/, scanDir(rootDir, 0)];
-                case 1:
-                    // Build the graph
-                    _c.sent();
-                    normalizedEdges = [];
-                    for (_i = 0, edges_1 = edges; _i < edges_1.length; _i++) {
-                        edge = edges_1[_i];
-                        targetKey = edge.target;
-                        if (!nodes.has(targetKey)) {
-                            extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-                            baseTarget = targetKey.replace(/\.[^.]+$/, '');
-                            for (_b = 0, extensions_2 = extensions; _b < extensions_2.length; _b++) {
-                                ext = extensions_2[_b];
-                                if (nodes.has(baseTarget + ext)) {
-                                    targetKey = baseTarget + ext;
-                                    break;
-                                }
-                                // Try index files
-                                if (nodes.has(join(baseTarget, 'index' + ext))) {
-                                    targetKey = join(baseTarget, 'index' + ext);
-                                    break;
-                                }
-                            }
-                        }
-                        if (nodes.has(targetKey)) {
-                            normalizedEdges.push(__assign(__assign({}, edge), { target: targetKey }));
-                        }
-                    }
-                    graph = {
-                        nodes: nodes,
-                        edges: normalizedEdges,
-                        metadata: {
-                            rootDir: rootDir,
-                            totalFiles: nodes.size,
-                            totalEdges: normalizedEdges.length,
-                            buildTime: Date.now() - startTime
-                        }
-                    };
-                    // Cache the result
-                    graphCache.set(cacheKey, { graph: graph, timestamp: Date.now() });
-                    return [2 /*return*/, graph];
+    }
+    /**
+     * Process a single source file
+     */
+    async function processFile(fullPath, relPath) {
+        try {
+            const content = await readFile(fullPath, 'utf-8');
+            const fileStats = await stat(fullPath);
+            const imports = extractImports(content, fullPath);
+            const exportsList = extractExports(content);
+            // Create node
+            const node = {
+                id: relPath,
+                path: relPath,
+                name: basename(relPath, extname(relPath)),
+                type: 'file',
+                imports: imports.map(i => i.path),
+                exports: exportsList,
+                size: fileStats.size,
+                complexity: estimateComplexity(content),
+            };
+            nodes.set(relPath, node);
+            // Create edges for imports
+            for (const imp of imports) {
+                const resolved = resolveImportPath(imp.path, fullPath, rootDir);
+                if (resolved) {
+                    const targetRel = relative(rootDir, resolved);
+                    edges.push({
+                        source: relPath,
+                        target: targetRel,
+                        type: imp.type,
+                        weight: imp.type === 're-export' ? 2 : 1,
+                    });
+                }
             }
-        });
-    });
+        }
+        catch {
+            // File not readable, skip
+        }
+    }
+    // Build the graph
+    await scanDir(rootDir, 0);
+    // Normalize edges - ensure targets exist (with extension variations)
+    const normalizedEdges = [];
+    for (const edge of edges) {
+        // Try to find matching node
+        let targetKey = edge.target;
+        if (!nodes.has(targetKey)) {
+            // Try with different extensions
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+            const baseTarget = targetKey.replace(/\.[^.]+$/, '');
+            for (const ext of extensions) {
+                if (nodes.has(baseTarget + ext)) {
+                    targetKey = baseTarget + ext;
+                    break;
+                }
+                // Try index files
+                if (nodes.has(join(baseTarget, 'index' + ext))) {
+                    targetKey = join(baseTarget, 'index' + ext);
+                    break;
+                }
+            }
+        }
+        if (nodes.has(targetKey)) {
+            normalizedEdges.push({ ...edge, target: targetKey });
+        }
+    }
+    const graph = {
+        nodes,
+        edges: normalizedEdges,
+        metadata: {
+            rootDir,
+            totalFiles: nodes.size,
+            totalEdges: normalizedEdges.length,
+            buildTime: Date.now() - startTime,
+        },
+    };
+    // Cache the result
+    graphCache.set(cacheKey, { graph, timestamp: Date.now() });
+    return graph;
 }
 /**
  * Estimate cyclomatic complexity from code
  */
 function estimateComplexity(content) {
-    var complexity = 1;
+    let complexity = 1;
     // Count branching statements
-    var patterns = [
+    const patterns = [
         /\bif\s*\(/g,
         /\belse\s+if\s*\(/g,
         /\bfor\s*\(/g,
         /\bwhile\s*\(/g,
         /\bcase\s+/g,
         /\bcatch\s*\(/g,
-        /\?\s*[^:]+:/g,
+        /\?\s*[^:]+:/g, // Ternary operator
         /&&/g,
         /\|\|/g,
     ];
-    for (var _i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
-        var pattern = patterns_1[_i];
-        var matches = content.match(pattern);
+    for (const pattern of patterns) {
+        const matches = content.match(pattern);
         if (matches)
             complexity += matches.length;
     }
@@ -466,49 +350,44 @@ function estimateComplexity(content) {
  * Finds minimum cut with deterministic result
  */
 function fallbackMinCut(nodes, edges) {
-    var _a, _b;
     if (nodes.length < 2) {
         return {
             cutValue: 0,
             partition1: nodes,
             partition2: [],
-            cutEdges: []
+            cutEdges: [],
         };
     }
     // Build adjacency map with weights
-    var adj = new Map();
-    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-        var node = nodes_1[_i];
+    const adj = new Map();
+    for (const node of nodes) {
         adj.set(node, new Map());
     }
-    for (var _c = 0, edges_2 = edges; _c < edges_2.length; _c++) {
-        var _d = edges_2[_c], u = _d[0], v = _d[1], w = _d[2];
+    for (const [u, v, w] of edges) {
         if (adj.has(u) && adj.has(v)) {
             adj.get(u).set(v, (adj.get(u).get(v) || 0) + w);
             adj.get(v).set(u, (adj.get(v).get(u) || 0) + w);
         }
     }
-    var bestCut = Infinity;
-    var bestPartition1 = [];
-    var bestPartition2 = [];
-    var bestCutEdges = [];
+    let bestCut = Infinity;
+    let bestPartition1 = [];
+    let bestPartition2 = [];
+    let bestCutEdges = [];
     // Run multiple iterations for better results
-    var iterations = Math.min(nodes.length * 2, 20);
-    var _loop_1 = function (iter) {
+    const iterations = Math.min(nodes.length * 2, 20);
+    for (let iter = 0; iter < iterations; iter++) {
         // Start from different nodes
-        var startNode = nodes[iter % nodes.length];
-        var inSet = new Set([startNode]);
-        var remaining = new Set(nodes.filter(function (n) { return n !== startNode; }));
+        const startNode = nodes[iter % nodes.length];
+        const inSet = new Set([startNode]);
+        const remaining = new Set(nodes.filter(n => n !== startNode));
         while (remaining.size > 1) {
             // Find node with maximum connectivity to current set
-            var maxNode = '';
-            var maxConn = -1;
-            for (var _g = 0, _h = Array.from(remaining); _g < _h.length; _g++) {
-                var node = _h[_g];
-                var conn = 0;
-                for (var _j = 0, _k = Array.from(inSet); _j < _k.length; _j++) {
-                    var inNode = _k[_j];
-                    conn += ((_a = adj.get(node)) === null || _a === void 0 ? void 0 : _a.get(inNode)) || 0;
+            let maxNode = '';
+            let maxConn = -1;
+            for (const node of Array.from(remaining)) {
+                let conn = 0;
+                for (const inNode of Array.from(inSet)) {
+                    conn += adj.get(node)?.get(inNode) || 0;
                 }
                 if (conn > maxConn) {
                     maxConn = conn;
@@ -517,16 +396,15 @@ function fallbackMinCut(nodes, edges) {
             }
             if (!maxNode)
                 break;
-            remaining["delete"](maxNode);
+            remaining.delete(maxNode);
             inSet.add(maxNode);
         }
         if (remaining.size === 1) {
-            var lastNode = Array.from(remaining)[0];
-            var cutValue = 0;
-            var cutEdges = [];
-            for (var _l = 0, _m = Array.from(inSet); _l < _m.length; _l++) {
-                var inNode = _m[_l];
-                var weight = ((_b = adj.get(lastNode)) === null || _b === void 0 ? void 0 : _b.get(inNode)) || 0;
+            const lastNode = Array.from(remaining)[0];
+            let cutValue = 0;
+            const cutEdges = [];
+            for (const inNode of Array.from(inSet)) {
+                const weight = adj.get(lastNode)?.get(inNode) || 0;
                 if (weight > 0) {
                     cutValue += weight;
                     cutEdges.push([lastNode, inNode]);
@@ -539,21 +417,17 @@ function fallbackMinCut(nodes, edges) {
                 bestCutEdges = cutEdges;
             }
         }
-    };
-    for (var iter = 0; iter < iterations; iter++) {
-        _loop_1(iter);
     }
     // If we didn't find a good cut, split roughly in half
     if (bestCut === Infinity) {
-        var mid = Math.floor(nodes.length / 2);
+        const mid = Math.floor(nodes.length / 2);
         bestPartition1 = nodes.slice(0, mid);
         bestPartition2 = nodes.slice(mid);
         bestCut = 0;
         bestCutEdges = [];
-        for (var _e = 0, edges_3 = edges; _e < edges_3.length; _e++) {
-            var _f = edges_3[_e], u = _f[0], v = _f[1], w = _f[2];
-            var uIn1 = bestPartition1.includes(u);
-            var vIn1 = bestPartition1.includes(v);
+        for (const [u, v, w] of edges) {
+            const uIn1 = bestPartition1.includes(u);
+            const vIn1 = bestPartition1.includes(v);
             if (uIn1 !== vIn1) {
                 bestCut += w;
                 bestCutEdges.push([u, v]);
@@ -564,7 +438,7 @@ function fallbackMinCut(nodes, edges) {
         cutValue: bestCut,
         partition1: bestPartition1,
         partition2: bestPartition2,
-        cutEdges: bestCutEdges
+        cutEdges: bestCutEdges,
     };
 }
 // ============================================================================
@@ -579,14 +453,12 @@ function fallbackLouvain(nodes, edges) {
         return { communities: [], modularity: 0 };
     }
     // Build adjacency map
-    var adj = new Map();
-    for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
-        var node = nodes_2[_i];
+    const adj = new Map();
+    for (const node of nodes) {
         adj.set(node, new Map());
     }
-    var totalWeight = 0;
-    for (var _a = 0, edges_4 = edges; _a < edges_4.length; _a++) {
-        var _b = edges_4[_a], u = _b[0], v = _b[1], w = _b[2];
+    let totalWeight = 0;
+    for (const [u, v, w] of edges) {
         if (adj.has(u) && adj.has(v)) {
             adj.get(u).set(v, (adj.get(u).get(v) || 0) + w);
             adj.get(v).set(u, (adj.get(v).get(u) || 0) + w);
@@ -596,64 +468,57 @@ function fallbackLouvain(nodes, edges) {
     if (totalWeight === 0) {
         // No edges, each node is its own community
         return {
-            communities: nodes.map(function (n, i) { return ({ id: i, members: [n] }); }),
-            modularity: 0
+            communities: nodes.map((n, i) => ({ id: i, members: [n] })),
+            modularity: 0,
         };
     }
     // Initialize: each node in its own community
-    var community = new Map();
-    var nextCommunityId = 0;
-    for (var _c = 0, nodes_3 = nodes; _c < nodes_3.length; _c++) {
-        var node = nodes_3[_c];
+    const community = new Map();
+    let nextCommunityId = 0;
+    for (const node of nodes) {
         community.set(node, nextCommunityId++);
     }
     // Calculate node degree
-    var degree = new Map();
-    for (var _d = 0, nodes_4 = nodes; _d < nodes_4.length; _d++) {
-        var node = nodes_4[_d];
-        var d = 0;
-        for (var _e = 0, _f = Array.from(adj.get(node).entries()); _e < _f.length; _e++) {
-            var _g = _f[_e], w = _g[1];
+    const degree = new Map();
+    for (const node of nodes) {
+        let d = 0;
+        for (const [, w] of Array.from(adj.get(node).entries())) {
             d += w;
         }
         degree.set(node, d);
     }
     // Louvain phase 1: local moving
-    var improved = true;
-    var maxIterations = 10;
-    var iteration = 0;
+    let improved = true;
+    const maxIterations = 10;
+    let iteration = 0;
     while (improved && iteration < maxIterations) {
         improved = false;
         iteration++;
-        for (var _h = 0, nodes_5 = nodes; _h < nodes_5.length; _h++) {
-            var node = nodes_5[_h];
-            var currentCommunity = community.get(node);
-            var nodeAdj = adj.get(node);
-            var nodeDegree = degree.get(node);
+        for (const node of nodes) {
+            const currentCommunity = community.get(node);
+            const nodeAdj = adj.get(node);
+            const nodeDegree = degree.get(node);
             // Calculate modularity gain for moving to each neighbor's community
-            var communityWeights = new Map();
-            for (var _j = 0, _k = Array.from(nodeAdj.entries()); _j < _k.length; _j++) {
-                var _l = _k[_j], neighbor = _l[0], weight = _l[1];
-                var neighborCommunity = community.get(neighbor);
+            const communityWeights = new Map();
+            for (const [neighbor, weight] of Array.from(nodeAdj.entries())) {
+                const neighborCommunity = community.get(neighbor);
                 communityWeights.set(neighborCommunity, (communityWeights.get(neighborCommunity) || 0) + weight);
             }
             // Calculate community totals
-            var communityTotal = new Map();
-            for (var _m = 0, _o = Array.from(community.entries()); _m < _o.length; _m++) {
-                var _p = _o[_m], n = _p[0], c = _p[1];
+            const communityTotal = new Map();
+            for (const [n, c] of Array.from(community.entries())) {
                 communityTotal.set(c, (communityTotal.get(c) || 0) + (degree.get(n) || 0));
             }
-            var bestCommunity = currentCommunity;
-            var bestGain = 0;
-            for (var _q = 0, _r = Array.from(communityWeights.entries()); _q < _r.length; _q++) {
-                var _s = _r[_q], targetCommunity = _s[0], edgeWeight = _s[1];
+            let bestCommunity = currentCommunity;
+            let bestGain = 0;
+            for (const [targetCommunity, edgeWeight] of Array.from(communityWeights.entries())) {
                 if (targetCommunity === currentCommunity)
                     continue;
                 // Calculate modularity gain
-                var currentTotal = communityTotal.get(currentCommunity) || 0;
-                var targetTotal = communityTotal.get(targetCommunity) || 0;
-                var currentEdges = communityWeights.get(currentCommunity) || 0;
-                var gain = (edgeWeight - currentEdges) / totalWeight -
+                const currentTotal = communityTotal.get(currentCommunity) || 0;
+                const targetTotal = communityTotal.get(targetCommunity) || 0;
+                const currentEdges = communityWeights.get(currentCommunity) || 0;
+                const gain = (edgeWeight - currentEdges) / totalWeight -
                     (nodeDegree * (targetTotal - currentTotal + nodeDegree)) / (totalWeight * totalWeight);
                 if (gain > bestGain) {
                     bestGain = gain;
@@ -667,35 +532,32 @@ function fallbackLouvain(nodes, edges) {
         }
     }
     // Collect communities
-    var communityMembers = new Map();
-    for (var _t = 0, _u = Array.from(community.entries()); _t < _u.length; _t++) {
-        var _v = _u[_t], node = _v[0], comm = _v[1];
+    const communityMembers = new Map();
+    for (const [node, comm] of Array.from(community.entries())) {
         if (!communityMembers.has(comm)) {
             communityMembers.set(comm, []);
         }
         communityMembers.get(comm).push(node);
     }
     // Renumber communities
-    var communities = [];
-    var id = 0;
-    for (var _w = 0, _x = Array.from(communityMembers.values()); _w < _x.length; _w++) {
-        var members = _x[_w];
-        communities.push({ id: id++, members: members });
+    const communities = [];
+    let id = 0;
+    for (const members of Array.from(communityMembers.values())) {
+        communities.push({ id: id++, members });
     }
     // Calculate modularity
-    var modularity = 0;
-    for (var _y = 0, edges_5 = edges; _y < edges_5.length; _y++) {
-        var _z = edges_5[_y], u = _z[0], v = _z[1], w = _z[2];
-        var cu = community.get(u);
-        var cv = community.get(v);
+    let modularity = 0;
+    for (const [u, v, w] of edges) {
+        const cu = community.get(u);
+        const cv = community.get(v);
         if (cu === cv) {
-            var du = degree.get(u);
-            var dv = degree.get(v);
+            const du = degree.get(u);
+            const dv = degree.get(v);
             modularity += w - (du * dv) / totalWeight;
         }
     }
     modularity /= totalWeight;
-    return { communities: communities, modularity: modularity };
+    return { communities, modularity };
 }
 // ============================================================================
 // Circular Dependency Detection
@@ -704,19 +566,17 @@ function fallbackLouvain(nodes, edges) {
  * Detect circular dependencies using DFS
  */
 export function detectCircularDependencies(graph) {
-    var cycles = [];
-    var visited = new Set();
-    var recursionStack = new Set();
-    var path = [];
+    const cycles = [];
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
     // Build adjacency list
-    var adjList = new Map();
-    for (var _i = 0, _a = Array.from(graph.nodes.keys()); _i < _a.length; _i++) {
-        var node = _a[_i];
+    const adjList = new Map();
+    for (const node of Array.from(graph.nodes.keys())) {
         adjList.set(node, []);
     }
-    for (var _b = 0, _c = graph.edges; _b < _c.length; _b++) {
-        var edge = _c[_b];
-        var list = adjList.get(edge.source);
+    for (const edge of graph.edges) {
+        const list = adjList.get(edge.source);
         if (list) {
             list.push(edge.target);
         }
@@ -725,30 +585,28 @@ export function detectCircularDependencies(graph) {
         visited.add(node);
         recursionStack.add(node);
         path.push(node);
-        var neighbors = adjList.get(node) || [];
-        for (var _i = 0, neighbors_1 = neighbors; _i < neighbors_1.length; _i++) {
-            var neighbor = neighbors_1[_i];
+        const neighbors = adjList.get(node) || [];
+        for (const neighbor of neighbors) {
             if (!visited.has(neighbor)) {
                 dfs(neighbor);
             }
             else if (recursionStack.has(neighbor)) {
                 // Found cycle
-                var cycleStart = path.indexOf(neighbor);
-                var cycle = path.slice(cycleStart);
+                const cycleStart = path.indexOf(neighbor);
+                const cycle = path.slice(cycleStart);
                 cycle.push(neighbor); // Complete the cycle
-                var severity = getCycleSeverity(cycle, graph);
+                const severity = getCycleSeverity(cycle, graph);
                 cycles.push({
-                    cycle: cycle,
-                    severity: severity,
-                    suggestion: getCycleSuggestion(cycle, graph)
+                    cycle,
+                    severity,
+                    suggestion: getCycleSuggestion(cycle, graph),
                 });
             }
         }
-        recursionStack["delete"](node);
+        recursionStack.delete(node);
         path.pop();
     }
-    for (var _d = 0, _e = Array.from(graph.nodes.keys()); _d < _e.length; _d++) {
-        var node = _e[_d];
+    for (const node of Array.from(graph.nodes.keys())) {
         if (!visited.has(node)) {
             dfs(node);
         }
@@ -759,7 +617,7 @@ function getCycleSeverity(cycle, _graph) {
     // High severity if cycle involves many files or core modules
     if (cycle.length > 5)
         return 'high';
-    if (cycle.some(function (n) { return n.includes('index') || n.includes('core'); }))
+    if (cycle.some(n => n.includes('index') || n.includes('core')))
         return 'high';
     if (cycle.length > 3)
         return 'medium';
@@ -767,21 +625,21 @@ function getCycleSeverity(cycle, _graph) {
 }
 function getCycleSuggestion(cycle, graph) {
     if (cycle.length === 2) {
-        return "Consider extracting shared code into a separate module to break the cycle between " + cycle[0] + " and " + cycle[1];
+        return `Consider extracting shared code into a separate module to break the cycle between ${cycle[0]} and ${cycle[1]}`;
     }
     // Find the weakest link (least important edge)
-    var weakestEdge = '';
-    var minImports = Infinity;
-    for (var i = 0; i < cycle.length - 1; i++) {
-        var from = cycle[i];
-        var to = cycle[i + 1];
-        var fromNode = graph.nodes.get(from);
+    let weakestEdge = '';
+    let minImports = Infinity;
+    for (let i = 0; i < cycle.length - 1; i++) {
+        const from = cycle[i];
+        const to = cycle[i + 1];
+        const fromNode = graph.nodes.get(from);
         if (fromNode && fromNode.imports.length < minImports) {
             minImports = fromNode.imports.length;
-            weakestEdge = from + " -> " + to;
+            weakestEdge = `${from} -> ${to}`;
         }
     }
-    return "Break the cycle by refactoring the dependency: " + weakestEdge + ". Consider dependency injection or extracting interfaces.";
+    return `Break the cycle by refactoring the dependency: ${weakestEdge}. Consider dependency injection or extracting interfaces.`;
 }
 // ============================================================================
 // Main Analysis Functions
@@ -789,131 +647,103 @@ function getCycleSuggestion(cycle, graph) {
 /**
  * Analyze graph boundaries using MinCut algorithm
  */
-export function analyzeMinCutBoundaries(graph, numPartitions) {
-    if (numPartitions === void 0) { numPartitions = 2; }
-    return __awaiter(this, void 0, Promise, function () {
-        var nodes, edges, boundaries, ruVector, result, subEdges, subResult;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    nodes = Array.from(graph.nodes.keys());
-                    edges = graph.edges.map(function (e) { return [e.source, e.target, e.weight]; });
-                    boundaries = [];
-                    return [4 /*yield*/, loadRuVector()];
-                case 1:
-                    ruVector = _a.sent();
-                    if (ruVector) {
-                        result = ruVector.mincut(nodes, edges);
-                    }
-                    else {
-                        result = fallbackMinCut(nodes, edges);
-                    }
-                    boundaries.push({
-                        cutValue: result.cutValue,
-                        partition1: result.partition1,
-                        partition2: result.partition2,
-                        cutEdges: result.cutEdges.map(function (_a) {
-                            var s = _a[0], t = _a[1];
-                            var edge = graph.edges.find(function (e) { return e.source === s && e.target === t; });
-                            return edge || { source: s, target: t, type: 'import', weight: 1 };
-                        }),
-                        suggestion: generateBoundarySuggestion(result.partition1, result.partition2, graph)
-                    });
-                    // Recursively partition if needed
-                    if (numPartitions > 2 && result.partition1.length > 2) {
-                        subEdges = edges.filter(function (_a) {
-                            var u = _a[0], v = _a[1];
-                            return result.partition1.includes(u) && result.partition1.includes(v);
-                        });
-                        subResult = ruVector
-                            ? ruVector.mincut(result.partition1, subEdges)
-                            : fallbackMinCut(result.partition1, subEdges);
-                        if (subResult.cutValue > 0) {
-                            boundaries.push({
-                                cutValue: subResult.cutValue,
-                                partition1: subResult.partition1,
-                                partition2: subResult.partition2,
-                                cutEdges: subResult.cutEdges.map(function (_a) {
-                                    var s = _a[0], t = _a[1];
-                                    var edge = graph.edges.find(function (e) { return e.source === s && e.target === t; });
-                                    return edge || { source: s, target: t, type: 'import', weight: 1 };
-                                }),
-                                suggestion: generateBoundarySuggestion(subResult.partition1, subResult.partition2, graph)
-                            });
-                        }
-                    }
-                    return [2 /*return*/, boundaries];
-            }
-        });
+export async function analyzeMinCutBoundaries(graph, numPartitions = 2) {
+    const nodes = Array.from(graph.nodes.keys());
+    const edges = graph.edges.map(e => [e.source, e.target, e.weight]);
+    const boundaries = [];
+    // Try to use ruvector, fallback to built-in
+    const ruVector = await loadRuVector();
+    // Get initial partition
+    let result;
+    if (ruVector) {
+        result = ruVector.mincut(nodes, edges);
+    }
+    else {
+        result = fallbackMinCut(nodes, edges);
+    }
+    boundaries.push({
+        cutValue: result.cutValue,
+        partition1: result.partition1,
+        partition2: result.partition2,
+        cutEdges: result.cutEdges.map(([s, t]) => {
+            const edge = graph.edges.find(e => e.source === s && e.target === t);
+            return edge || { source: s, target: t, type: 'import', weight: 1 };
+        }),
+        suggestion: generateBoundarySuggestion(result.partition1, result.partition2, graph),
     });
+    // Recursively partition if needed
+    if (numPartitions > 2 && result.partition1.length > 2) {
+        const subEdges = edges.filter(([u, v]) => result.partition1.includes(u) && result.partition1.includes(v));
+        const subResult = ruVector
+            ? ruVector.mincut(result.partition1, subEdges)
+            : fallbackMinCut(result.partition1, subEdges);
+        if (subResult.cutValue > 0) {
+            boundaries.push({
+                cutValue: subResult.cutValue,
+                partition1: subResult.partition1,
+                partition2: subResult.partition2,
+                cutEdges: subResult.cutEdges.map(([s, t]) => {
+                    const edge = graph.edges.find(e => e.source === s && e.target === t);
+                    return edge || { source: s, target: t, type: 'import', weight: 1 };
+                }),
+                suggestion: generateBoundarySuggestion(subResult.partition1, subResult.partition2, graph),
+            });
+        }
+    }
+    return boundaries;
 }
 function generateBoundarySuggestion(partition1, partition2, _graph) {
     // Analyze the partitions to suggest organization
-    var p1Dirs = partition1.map(function (p) { return dirname(p); }).filter(function (d) { return d !== '.'; });
-    var p2Dirs = partition2.map(function (p) { return dirname(p); }).filter(function (d) { return d !== '.'; });
-    var p1DirsSet = new Set(p1Dirs);
-    var p2DirsSet = new Set(p2Dirs);
+    const p1Dirs = partition1.map(p => dirname(p)).filter(d => d !== '.');
+    const p2Dirs = partition2.map(p => dirname(p)).filter(d => d !== '.');
+    const p1DirsSet = new Set(p1Dirs);
+    const p2DirsSet = new Set(p2Dirs);
     if (p1DirsSet.size === 1 && p2DirsSet.size === 1) {
-        var dir1 = p1Dirs[0];
-        var dir2 = p2Dirs[0];
-        return "Natural boundary detected between " + dir1 + "/ and " + dir2 + "/. These could be separate packages.";
+        const dir1 = p1Dirs[0];
+        const dir2 = p2Dirs[0];
+        return `Natural boundary detected between ${dir1}/ and ${dir2}/. These could be separate packages.`;
     }
     if (partition1.length > partition2.length * 3) {
-        return "Consider extracting " + partition2.length + " files into a separate module. They have minimal coupling to the rest.";
+        return `Consider extracting ${partition2.length} files into a separate module. They have minimal coupling to the rest.`;
     }
-    return "Found " + partition1.length + " and " + partition2.length + " file groups with minimal coupling. Consider organizing into separate modules.";
+    return `Found ${partition1.length} and ${partition2.length} file groups with minimal coupling. Consider organizing into separate modules.`;
 }
 /**
  * Analyze module communities using Louvain algorithm
  */
-export function analyzeModuleCommunities(graph) {
-    return __awaiter(this, void 0, Promise, function () {
-        var nodes, edges, ruVector, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    nodes = Array.from(graph.nodes.keys());
-                    edges = graph.edges.map(function (e) { return [e.source, e.target, e.weight]; });
-                    return [4 /*yield*/, loadRuVector()];
-                case 1:
-                    ruVector = _a.sent();
-                    result = ruVector ? ruVector.louvain(nodes, edges) : fallbackLouvain(nodes, edges);
-                    return [2 /*return*/, result.communities.map(function (comm) {
-                            // Find the most connected node as central
-                            var maxConnections = 0;
-                            var centralNode = comm.members[0];
-                            var _loop_2 = function (member) {
-                                var connections = graph.edges.filter(function (e) {
-                                    return (e.source === member && comm.members.includes(e.target)) ||
-                                        (e.target === member && comm.members.includes(e.source));
-                                }).length;
-                                if (connections > maxConnections) {
-                                    maxConnections = connections;
-                                    centralNode = member;
-                                }
-                            };
-                            for (var _i = 0, _a = comm.members; _i < _a.length; _i++) {
-                                var member = _a[_i];
-                                _loop_2(member);
-                            }
-                            // Calculate cohesion (internal edges / total possible edges)
-                            var internalEdges = graph.edges.filter(function (e) { return comm.members.includes(e.source) && comm.members.includes(e.target); }).length;
-                            var possibleEdges = (comm.members.length * (comm.members.length - 1)) / 2;
-                            var cohesion = possibleEdges > 0 ? internalEdges / possibleEdges : 1;
-                            // Suggest name based on common directory
-                            var dirs = comm.members.map(function (m) { return dirname(m); });
-                            var commonDir = findCommonPrefix(dirs);
-                            var suggestedName = commonDir || basename(centralNode, extname(centralNode));
-                            return {
-                                id: comm.id,
-                                members: comm.members,
-                                cohesion: cohesion,
-                                centralNode: centralNode,
-                                suggestedName: suggestedName
-                            };
-                        })];
+export async function analyzeModuleCommunities(graph) {
+    const nodes = Array.from(graph.nodes.keys());
+    const edges = graph.edges.map(e => [e.source, e.target, e.weight]);
+    // Try to use ruvector, fallback to built-in
+    const ruVector = await loadRuVector();
+    const result = ruVector ? ruVector.louvain(nodes, edges) : fallbackLouvain(nodes, edges);
+    return result.communities.map(comm => {
+        // Find the most connected node as central
+        let maxConnections = 0;
+        let centralNode = comm.members[0];
+        for (const member of comm.members) {
+            const connections = graph.edges.filter(e => (e.source === member && comm.members.includes(e.target)) ||
+                (e.target === member && comm.members.includes(e.source))).length;
+            if (connections > maxConnections) {
+                maxConnections = connections;
+                centralNode = member;
             }
-        });
+        }
+        // Calculate cohesion (internal edges / total possible edges)
+        const internalEdges = graph.edges.filter(e => comm.members.includes(e.source) && comm.members.includes(e.target)).length;
+        const possibleEdges = (comm.members.length * (comm.members.length - 1)) / 2;
+        const cohesion = possibleEdges > 0 ? internalEdges / possibleEdges : 1;
+        // Suggest name based on common directory
+        const dirs = comm.members.map(m => dirname(m));
+        const commonDir = findCommonPrefix(dirs);
+        const suggestedName = commonDir || basename(centralNode, extname(centralNode));
+        return {
+            id: comm.id,
+            members: comm.members,
+            cohesion,
+            centralNode,
+            suggestedName,
+        };
     });
 }
 function findCommonPrefix(strings) {
@@ -921,108 +751,94 @@ function findCommonPrefix(strings) {
         return '';
     if (strings.length === 1)
         return strings[0];
-    var sorted = __spreadArray([], strings, true).sort();
-    var first = sorted[0];
-    var last = sorted[sorted.length - 1];
-    var i = 0;
+    const sorted = [...strings].sort();
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    let i = 0;
     while (i < first.length && first[i] === last[i]) {
         i++;
     }
-    var prefix = first.slice(0, i);
+    const prefix = first.slice(0, i);
     // Return the last complete directory segment
-    var lastSlash = prefix.lastIndexOf('/');
+    const lastSlash = prefix.lastIndexOf('/');
     return lastSlash > 0 ? prefix.slice(0, lastSlash) : '';
 }
 /**
  * Full graph analysis (with caching)
  */
-export function analyzeGraph(rootDir, options) {
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, Promise, function () {
-        function dfs(node) {
-            visited.add(node);
-            for (var _i = 0, _a = graph.edges; _i < _a.length; _i++) {
-                var edge = _a[_i];
-                if (edge.source === node && !visited.has(edge.target)) {
-                    dfs(edge.target);
-                }
-                if (edge.target === node && !visited.has(edge.source)) {
-                    dfs(edge.source);
-                }
-            }
+export async function analyzeGraph(rootDir, options = {}) {
+    // Check cache first
+    const cacheKey = `analysis:${rootDir}:${JSON.stringify(options)}`;
+    if (!options.skipCache) {
+        const cached = analysisResultCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < ANALYSIS_CACHE_TTL_MS) {
+            return cached.result;
         }
-        var cacheKey, cached, graph, nodeCount, edgeCount, degrees, _i, _a, node, _b, _c, edge, degreeValues, avgDegree, maxDegree, density, visited, componentCount, _d, _e, node, circularDependencies, boundaries, communities, result;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
-                case 0:
-                    cacheKey = "analysis:" + rootDir + ":" + JSON.stringify(options);
-                    if (!options.skipCache) {
-                        cached = analysisResultCache.get(cacheKey);
-                        if (cached && Date.now() - cached.timestamp < ANALYSIS_CACHE_TTL_MS) {
-                            return [2 /*return*/, cached.result];
-                        }
-                    }
-                    return [4 /*yield*/, buildDependencyGraph(rootDir, { skipCache: options.skipCache })];
-                case 1:
-                    graph = _f.sent();
-                    nodeCount = graph.nodes.size;
-                    edgeCount = graph.edges.length;
-                    degrees = new Map();
-                    for (_i = 0, _a = Array.from(graph.nodes.keys()); _i < _a.length; _i++) {
-                        node = _a[_i];
-                        degrees.set(node, 0);
-                    }
-                    for (_b = 0, _c = graph.edges; _b < _c.length; _b++) {
-                        edge = _c[_b];
-                        degrees.set(edge.source, (degrees.get(edge.source) || 0) + 1);
-                        degrees.set(edge.target, (degrees.get(edge.target) || 0) + 1);
-                    }
-                    degreeValues = Array.from(degrees.values());
-                    avgDegree = degreeValues.length > 0 ? degreeValues.reduce(function (a, b) { return a + b; }, 0) / degreeValues.length : 0;
-                    maxDegree = degreeValues.length > 0 ? Math.max.apply(Math, degreeValues) : 0;
-                    density = nodeCount > 1 ? (2 * edgeCount) / (nodeCount * (nodeCount - 1)) : 0;
-                    visited = new Set();
-                    componentCount = 0;
-                    for (_d = 0, _e = Array.from(graph.nodes.keys()); _d < _e.length; _d++) {
-                        node = _e[_d];
-                        if (!visited.has(node)) {
-                            componentCount++;
-                            dfs(node);
-                        }
-                    }
-                    circularDependencies = detectCircularDependencies(graph);
-                    if (!(options.includeBoundaries !== false)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, analyzeMinCutBoundaries(graph, options.numPartitions)];
-                case 2:
-                    boundaries = _f.sent();
-                    _f.label = 3;
-                case 3:
-                    if (!(options.includeModules !== false)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, analyzeModuleCommunities(graph)];
-                case 4:
-                    communities = _f.sent();
-                    _f.label = 5;
-                case 5:
-                    result = {
-                        graph: graph,
-                        boundaries: boundaries,
-                        communities: communities,
-                        circularDependencies: circularDependencies,
-                        statistics: {
-                            nodeCount: nodeCount,
-                            edgeCount: edgeCount,
-                            avgDegree: avgDegree,
-                            maxDegree: maxDegree,
-                            density: density,
-                            componentCount: componentCount
-                        }
-                    };
-                    // Cache the result
-                    analysisResultCache.set(cacheKey, { result: result, timestamp: Date.now() });
-                    return [2 /*return*/, result];
+    }
+    const graph = await buildDependencyGraph(rootDir, { skipCache: options.skipCache });
+    // Calculate statistics
+    const nodeCount = graph.nodes.size;
+    const edgeCount = graph.edges.length;
+    const degrees = new Map();
+    for (const node of Array.from(graph.nodes.keys())) {
+        degrees.set(node, 0);
+    }
+    for (const edge of graph.edges) {
+        degrees.set(edge.source, (degrees.get(edge.source) || 0) + 1);
+        degrees.set(edge.target, (degrees.get(edge.target) || 0) + 1);
+    }
+    const degreeValues = Array.from(degrees.values());
+    const avgDegree = degreeValues.length > 0 ? degreeValues.reduce((a, b) => a + b, 0) / degreeValues.length : 0;
+    const maxDegree = degreeValues.length > 0 ? Math.max(...degreeValues) : 0;
+    const density = nodeCount > 1 ? (2 * edgeCount) / (nodeCount * (nodeCount - 1)) : 0;
+    // Count connected components
+    const visited = new Set();
+    let componentCount = 0;
+    function dfs(node) {
+        visited.add(node);
+        for (const edge of graph.edges) {
+            if (edge.source === node && !visited.has(edge.target)) {
+                dfs(edge.target);
             }
-        });
-    });
+            if (edge.target === node && !visited.has(edge.source)) {
+                dfs(edge.source);
+            }
+        }
+    }
+    for (const node of Array.from(graph.nodes.keys())) {
+        if (!visited.has(node)) {
+            componentCount++;
+            dfs(node);
+        }
+    }
+    // Detect circular dependencies
+    const circularDependencies = detectCircularDependencies(graph);
+    // Analyze boundaries and communities if requested
+    let boundaries;
+    let communities;
+    if (options.includeBoundaries !== false) {
+        boundaries = await analyzeMinCutBoundaries(graph, options.numPartitions);
+    }
+    if (options.includeModules !== false) {
+        communities = await analyzeModuleCommunities(graph);
+    }
+    const result = {
+        graph,
+        boundaries,
+        communities,
+        circularDependencies,
+        statistics: {
+            nodeCount,
+            edgeCount,
+            avgDegree,
+            maxDegree,
+            density,
+            componentCount,
+        },
+    };
+    // Cache the result
+    analysisResultCache.set(cacheKey, { result, timestamp: Date.now() });
+    return result;
 }
 // ============================================================================
 // DOT Format Export
@@ -1030,62 +846,56 @@ export function analyzeGraph(rootDir, options) {
 /**
  * Export graph to DOT format for visualization
  */
-export function exportToDot(result, options) {
-    if (options === void 0) { options = {}; }
-    var graph = result.graph, communities = result.communities, circularDependencies = result.circularDependencies;
-    var lines = ['digraph DependencyGraph {'];
+export function exportToDot(result, options = {}) {
+    const { graph, communities, circularDependencies } = result;
+    const lines = ['digraph DependencyGraph {'];
     lines.push('  rankdir=LR;');
     lines.push('  node [shape=box, style=rounded];');
     lines.push('');
     // Generate colors for communities
-    var communityColors = new Map();
+    const communityColors = new Map();
     if (options.colorByCommunity && communities) {
-        var colors = [
+        const colors = [
             '#e6194b', '#3cb44b', '#ffe119', '#4363d8', '#f58231',
             '#911eb4', '#42d4f4', '#f032e6', '#bfef45', '#fabed4',
         ];
-        for (var _i = 0, communities_1 = communities; _i < communities_1.length; _i++) {
-            var comm = communities_1[_i];
-            var color = colors[comm.id % colors.length];
-            for (var _a = 0, _b = comm.members; _a < _b.length; _a++) {
-                var member = _b[_a];
+        for (const comm of communities) {
+            const color = colors[comm.id % colors.length];
+            for (const member of comm.members) {
                 communityColors.set(member, color);
             }
         }
     }
     // Find nodes in cycles
-    var nodesInCycles = new Set();
+    const nodesInCycles = new Set();
     if (options.highlightCycles && circularDependencies) {
-        for (var _c = 0, circularDependencies_1 = circularDependencies; _c < circularDependencies_1.length; _c++) {
-            var cycle = circularDependencies_1[_c];
-            for (var _d = 0, _e = cycle.cycle; _d < _e.length; _d++) {
-                var node = _e[_d];
+        for (const cycle of circularDependencies) {
+            for (const node of cycle.cycle) {
                 nodesInCycles.add(node);
             }
         }
     }
     // Output nodes
     lines.push('  // Nodes');
-    for (var _f = 0, _g = Array.from(graph.nodes.entries()); _f < _g.length; _f++) {
-        var _h = _g[_f], id = _h[0], node = _h[1];
-        var attrs = [];
+    for (const [id, node] of Array.from(graph.nodes.entries())) {
+        const attrs = [];
         if (options.includeLabels !== false) {
-            attrs.push("label=\"" + node.name + "\"");
+            attrs.push(`label="${node.name}"`);
         }
         if (communityColors.has(id)) {
-            attrs.push("fillcolor=\"" + communityColors.get(id) + "\"", 'style="filled,rounded"');
+            attrs.push(`fillcolor="${communityColors.get(id)}"`, 'style="filled,rounded"');
         }
         if (nodesInCycles.has(id)) {
             attrs.push('color=red', 'penwidth=2');
         }
-        var attrStr = attrs.length > 0 ? " [" + attrs.join(', ') + "]" : '';
-        lines.push("  \"" + id + "\"" + attrStr + ";");
+        const attrStr = attrs.length > 0 ? ` [${attrs.join(', ')}]` : '';
+        lines.push(`  "${id}"${attrStr};`);
     }
     lines.push('');
     // Output edges
     lines.push('  // Edges');
-    var _loop_3 = function (edge) {
-        var attrs = [];
+    for (const edge of graph.edges) {
+        const attrs = [];
         if (edge.type === 'dynamic') {
             attrs.push('style=dashed');
         }
@@ -1094,8 +904,8 @@ export function exportToDot(result, options) {
         }
         // Check if edge is part of a cycle
         if (options.highlightCycles) {
-            var isCycleEdge = circularDependencies.some(function (cd) {
-                for (var i = 0; i < cd.cycle.length - 1; i++) {
+            const isCycleEdge = circularDependencies.some(cd => {
+                for (let i = 0; i < cd.cycle.length - 1; i++) {
                     if (cd.cycle[i] === edge.source && cd.cycle[i + 1] === edge.target) {
                         return true;
                     }
@@ -1106,12 +916,8 @@ export function exportToDot(result, options) {
                 attrs.push('color=red', 'penwidth=2');
             }
         }
-        var attrStr = attrs.length > 0 ? " [" + attrs.join(', ') + "]" : '';
-        lines.push("  \"" + edge.source + "\" -> \"" + edge.target + "\"" + attrStr + ";");
-    };
-    for (var _j = 0, _k = graph.edges; _j < _k.length; _j++) {
-        var edge = _k[_j];
-        _loop_3(edge);
+        const attrStr = attrs.length > 0 ? ` [${attrs.join(', ')}]` : '';
+        lines.push(`  "${edge.source}" -> "${edge.target}"${attrStr};`);
     }
     lines.push('}');
     return lines.join('\n');