kynjal-cli 3.1.3 → 4.0.0

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

@@ -11,6 +11,62 @@
  *
  * @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';
 // ============================================================================
@@ -19,13 +75,13 @@ import { join, relative, extname, dirname, basename } from 'path';
 /**
  * Cache for dependency graphs (5 minute TTL)
  */
-const graphCache = new Map();
-const GRAPH_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+var graphCache = new Map();
+var GRAPH_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 /**
  * Cache for analysis results (2 minute TTL)
  */
-const analysisResultCache = new Map();
-const ANALYSIS_CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
+var analysisResultCache = new Map();
+var ANALYSIS_CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
 /**
  * Clear all graph caches
  */
@@ -39,53 +95,64 @@ export function clearGraphCaches() {
 export function getGraphCacheStats() {
     return {
         graphCacheSize: graphCache.size,
-        analysisCacheSize: analysisResultCache.size,
+        analysisCacheSize: analysisResultCache.size
     };
 }
-let ruVectorGraph = null;
-let ruVectorLoadAttempted = false;
+var ruVectorGraph = null;
+var ruVectorLoadAttempted = false;
 /**
  * Attempt to load ruvector graph algorithms
  */
-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;
+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];
             }
-        }
-        catch {
-            // Fallback will be used
-        }
-    }
-    return null;
+        });
+    });
 }
 // ============================================================================
 // Import/Require Parser
@@ -94,30 +161,30 @@ async function loadRuVector() {
  * Extract imports from TypeScript/JavaScript file
  */
 function extractImports(content, _filePath) {
-    const imports = [];
+    var imports = [];
     // ES6 import statements
-    const esImportRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s*from\s*['"]([^'"]+)['"]/g;
-    let match;
+    var esImportRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*,?\s*)*\s*from\s*['"]([^'"]+)['"]/g;
+    var match;
     while ((match = esImportRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'import' });
     }
     // Side-effect imports: import 'module'
-    const sideEffectRegex = /import\s+['"]([^'"]+)['"]/g;
+    var sideEffectRegex = /import\s+['"]([^'"]+)['"]/g;
     while ((match = sideEffectRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'import' });
     }
     // CommonJS require
-    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    var requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
     while ((match = requireRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'require' });
     }
     // Dynamic imports
-    const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    var dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
     while ((match = dynamicImportRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 'dynamic' });
     }
     // Re-exports: export * from 'module'
-    const reExportRegex = /export\s+(?:\*|\{[^}]*\})\s+from\s*['"]([^'"]+)['"]/g;
+    var reExportRegex = /export\s+(?:\*|\{[^}]*\})\s+from\s*['"]([^'"]+)['"]/g;
     while ((match = reExportRegex.exec(content)) !== null) {
         imports.push({ path: match[1], type: 're-export' });
     }
@@ -127,18 +194,18 @@ function extractImports(content, _filePath) {
  * Extract exports from TypeScript/JavaScript file
  */
 function extractExports(content) {
-    const exports = [];
+    var exports = [];
     // Named exports
-    const namedExportRegex = /export\s+(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/g;
-    let match;
+    var namedExportRegex = /export\s+(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/g;
+    var match;
     while ((match = namedExportRegex.exec(content)) !== null) {
         exports.push(match[1]);
     }
     // Export list: export { a, b, c }
-    const exportListRegex = /export\s+\{([^}]+)\}/g;
+    var exportListRegex = /export\s+\{([^}]+)\}/g;
     while ((match = exportListRegex.exec(content)) !== null) {
-        const names = match[1].split(',').map(n => n.trim().split(/\s+as\s+/)[0].trim());
-        exports.push(...names.filter(n => n));
+        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; }));
     }
     // Default export
     if (/export\s+default/.test(content)) {
@@ -154,8 +221,8 @@ function resolveImportPath(importPath, fromFile, rootDir) {
     if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
         return null;
     }
-    const fromDir = dirname(fromFile);
-    let resolved;
+    var fromDir = dirname(fromFile);
+    var resolved;
     if (importPath.startsWith('/')) {
         resolved = join(rootDir, importPath);
     }
@@ -163,12 +230,13 @@ function resolveImportPath(importPath, fromFile, rootDir) {
         resolved = join(fromDir, importPath);
     }
     // Handle extension-less imports
-    const ext = extname(resolved);
+    var ext = extname(resolved);
     if (!ext) {
         // Try common extensions
-        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-        for (const tryExt of extensions) {
-            const tryPath = resolved + tryExt;
+        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;
             return tryPath; // Return normalized, existence check done later
         }
         // Could be index file
@@ -182,161 +250,209 @@ function resolveImportPath(importPath, fromFile, rootDir) {
 /**
  * Build dependency graph from source directory (with caching)
  */
-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;
-        }
-    }
-    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);
+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);
                 }
-                else if (entry.isFile()) {
-                    const ext = extname(entry.name);
-                    if (include.includes(ext)) {
-                        await processFile(fullPath, relPath);
-                    }
-                }
-            }
-        }
-        catch {
-            // Directory not readable, skip
+                return name === pattern || path.includes("/" + pattern + "/");
+            });
         }
-    }
-    /**
-     * 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,
-                    });
-                }
-            }
+        /**
+         * 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*/];
+                    }
+                });
+            });
         }
-        catch {
-            // File not readable, skip
+        /**
+         * 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*/];
+                    }
+                });
+            });
         }
-    }
-    // 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;
-                }
+        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];
             }
-        }
-        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) {
-    let complexity = 1;
+    var complexity = 1;
     // Count branching statements
-    const patterns = [
+    var patterns = [
         /\bif\s*\(/g,
         /\belse\s+if\s*\(/g,
         /\bfor\s*\(/g,
         /\bwhile\s*\(/g,
         /\bcase\s+/g,
         /\bcatch\s*\(/g,
-        /\?\s*[^:]+:/g, // Ternary operator
+        /\?\s*[^:]+:/g,
         /&&/g,
         /\|\|/g,
     ];
-    for (const pattern of patterns) {
-        const matches = content.match(pattern);
+    for (var _i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
+        var pattern = patterns_1[_i];
+        var matches = content.match(pattern);
         if (matches)
             complexity += matches.length;
     }
@@ -350,44 +466,49 @@ 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
-    const adj = new Map();
-    for (const node of nodes) {
+    var adj = new Map();
+    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+        var node = nodes_1[_i];
         adj.set(node, new Map());
     }
-    for (const [u, v, w] of edges) {
+    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];
         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);
         }
     }
-    let bestCut = Infinity;
-    let bestPartition1 = [];
-    let bestPartition2 = [];
-    let bestCutEdges = [];
+    var bestCut = Infinity;
+    var bestPartition1 = [];
+    var bestPartition2 = [];
+    var bestCutEdges = [];
     // Run multiple iterations for better results
-    const iterations = Math.min(nodes.length * 2, 20);
-    for (let iter = 0; iter < iterations; iter++) {
+    var iterations = Math.min(nodes.length * 2, 20);
+    var _loop_1 = function (iter) {
         // Start from different nodes
-        const startNode = nodes[iter % nodes.length];
-        const inSet = new Set([startNode]);
-        const remaining = new Set(nodes.filter(n => n !== startNode));
+        var startNode = nodes[iter % nodes.length];
+        var inSet = new Set([startNode]);
+        var remaining = new Set(nodes.filter(function (n) { return n !== startNode; }));
         while (remaining.size > 1) {
             // Find node with maximum connectivity to current set
-            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;
+            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;
                 }
                 if (conn > maxConn) {
                     maxConn = conn;
@@ -396,15 +517,16 @@ function fallbackMinCut(nodes, edges) {
             }
             if (!maxNode)
                 break;
-            remaining.delete(maxNode);
+            remaining["delete"](maxNode);
             inSet.add(maxNode);
         }
         if (remaining.size === 1) {
-            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;
+            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;
                 if (weight > 0) {
                     cutValue += weight;
                     cutEdges.push([lastNode, inNode]);
@@ -417,17 +539,21 @@ 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) {
-        const mid = Math.floor(nodes.length / 2);
+        var mid = Math.floor(nodes.length / 2);
         bestPartition1 = nodes.slice(0, mid);
         bestPartition2 = nodes.slice(mid);
         bestCut = 0;
         bestCutEdges = [];
-        for (const [u, v, w] of edges) {
-            const uIn1 = bestPartition1.includes(u);
-            const vIn1 = bestPartition1.includes(v);
+        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);
             if (uIn1 !== vIn1) {
                 bestCut += w;
                 bestCutEdges.push([u, v]);
@@ -438,7 +564,7 @@ function fallbackMinCut(nodes, edges) {
         cutValue: bestCut,
         partition1: bestPartition1,
         partition2: bestPartition2,
-        cutEdges: bestCutEdges,
+        cutEdges: bestCutEdges
     };
 }
 // ============================================================================
@@ -453,12 +579,14 @@ function fallbackLouvain(nodes, edges) {
         return { communities: [], modularity: 0 };
     }
     // Build adjacency map
-    const adj = new Map();
-    for (const node of nodes) {
+    var adj = new Map();
+    for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+        var node = nodes_2[_i];
         adj.set(node, new Map());
     }
-    let totalWeight = 0;
-    for (const [u, v, w] of edges) {
+    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];
         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);
@@ -468,57 +596,64 @@ function fallbackLouvain(nodes, edges) {
     if (totalWeight === 0) {
         // No edges, each node is its own community
         return {
-            communities: nodes.map((n, i) => ({ id: i, members: [n] })),
-            modularity: 0,
+            communities: nodes.map(function (n, i) { return ({ id: i, members: [n] }); }),
+            modularity: 0
         };
     }
     // Initialize: each node in its own community
-    const community = new Map();
-    let nextCommunityId = 0;
-    for (const node of nodes) {
+    var community = new Map();
+    var nextCommunityId = 0;
+    for (var _c = 0, nodes_3 = nodes; _c < nodes_3.length; _c++) {
+        var node = nodes_3[_c];
         community.set(node, nextCommunityId++);
     }
     // Calculate node degree
-    const degree = new Map();
-    for (const node of nodes) {
-        let d = 0;
-        for (const [, w] of Array.from(adj.get(node).entries())) {
+    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];
             d += w;
         }
         degree.set(node, d);
     }
     // Louvain phase 1: local moving
-    let improved = true;
-    const maxIterations = 10;
-    let iteration = 0;
+    var improved = true;
+    var maxIterations = 10;
+    var iteration = 0;
     while (improved && iteration < maxIterations) {
         improved = false;
         iteration++;
-        for (const node of nodes) {
-            const currentCommunity = community.get(node);
-            const nodeAdj = adj.get(node);
-            const nodeDegree = degree.get(node);
+        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);
             // Calculate modularity gain for moving to each neighbor's community
-            const communityWeights = new Map();
-            for (const [neighbor, weight] of Array.from(nodeAdj.entries())) {
-                const neighborCommunity = community.get(neighbor);
+            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);
                 communityWeights.set(neighborCommunity, (communityWeights.get(neighborCommunity) || 0) + weight);
             }
             // Calculate community totals
-            const communityTotal = new Map();
-            for (const [n, c] of Array.from(community.entries())) {
+            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];
                 communityTotal.set(c, (communityTotal.get(c) || 0) + (degree.get(n) || 0));
             }
-            let bestCommunity = currentCommunity;
-            let bestGain = 0;
-            for (const [targetCommunity, edgeWeight] of Array.from(communityWeights.entries())) {
+            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];
                 if (targetCommunity === currentCommunity)
                     continue;
                 // Calculate modularity gain
-                const currentTotal = communityTotal.get(currentCommunity) || 0;
-                const targetTotal = communityTotal.get(targetCommunity) || 0;
-                const currentEdges = communityWeights.get(currentCommunity) || 0;
-                const gain = (edgeWeight - currentEdges) / totalWeight -
+                var currentTotal = communityTotal.get(currentCommunity) || 0;
+                var targetTotal = communityTotal.get(targetCommunity) || 0;
+                var currentEdges = communityWeights.get(currentCommunity) || 0;
+                var gain = (edgeWeight - currentEdges) / totalWeight -
                     (nodeDegree * (targetTotal - currentTotal + nodeDegree)) / (totalWeight * totalWeight);
                 if (gain > bestGain) {
                     bestGain = gain;
@@ -532,32 +667,35 @@ function fallbackLouvain(nodes, edges) {
         }
     }
     // Collect communities
-    const communityMembers = new Map();
-    for (const [node, comm] of Array.from(community.entries())) {
+    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];
         if (!communityMembers.has(comm)) {
             communityMembers.set(comm, []);
         }
         communityMembers.get(comm).push(node);
     }
     // Renumber communities
-    const communities = [];
-    let id = 0;
-    for (const members of Array.from(communityMembers.values())) {
-        communities.push({ id: id++, members });
+    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 });
     }
     // Calculate modularity
-    let modularity = 0;
-    for (const [u, v, w] of edges) {
-        const cu = community.get(u);
-        const cv = community.get(v);
+    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);
         if (cu === cv) {
-            const du = degree.get(u);
-            const dv = degree.get(v);
+            var du = degree.get(u);
+            var dv = degree.get(v);
             modularity += w - (du * dv) / totalWeight;
         }
     }
     modularity /= totalWeight;
-    return { communities, modularity };
+    return { communities: communities, modularity: modularity };
 }
 // ============================================================================
 // Circular Dependency Detection
@@ -566,17 +704,19 @@ function fallbackLouvain(nodes, edges) {
  * Detect circular dependencies using DFS
  */
 export function detectCircularDependencies(graph) {
-    const cycles = [];
-    const visited = new Set();
-    const recursionStack = new Set();
-    const path = [];
+    var cycles = [];
+    var visited = new Set();
+    var recursionStack = new Set();
+    var path = [];
     // Build adjacency list
-    const adjList = new Map();
-    for (const node of Array.from(graph.nodes.keys())) {
+    var adjList = new Map();
+    for (var _i = 0, _a = Array.from(graph.nodes.keys()); _i < _a.length; _i++) {
+        var node = _a[_i];
         adjList.set(node, []);
     }
-    for (const edge of graph.edges) {
-        const list = adjList.get(edge.source);
+    for (var _b = 0, _c = graph.edges; _b < _c.length; _b++) {
+        var edge = _c[_b];
+        var list = adjList.get(edge.source);
         if (list) {
             list.push(edge.target);
         }
@@ -585,28 +725,30 @@ export function detectCircularDependencies(graph) {
         visited.add(node);
         recursionStack.add(node);
         path.push(node);
-        const neighbors = adjList.get(node) || [];
-        for (const neighbor of neighbors) {
+        var neighbors = adjList.get(node) || [];
+        for (var _i = 0, neighbors_1 = neighbors; _i < neighbors_1.length; _i++) {
+            var neighbor = neighbors_1[_i];
             if (!visited.has(neighbor)) {
                 dfs(neighbor);
             }
             else if (recursionStack.has(neighbor)) {
                 // Found cycle
-                const cycleStart = path.indexOf(neighbor);
-                const cycle = path.slice(cycleStart);
+                var cycleStart = path.indexOf(neighbor);
+                var cycle = path.slice(cycleStart);
                 cycle.push(neighbor); // Complete the cycle
-                const severity = getCycleSeverity(cycle, graph);
+                var severity = getCycleSeverity(cycle, graph);
                 cycles.push({
-                    cycle,
-                    severity,
-                    suggestion: getCycleSuggestion(cycle, graph),
+                    cycle: cycle,
+                    severity: severity,
+                    suggestion: getCycleSuggestion(cycle, graph)
                 });
             }
         }
-        recursionStack.delete(node);
+        recursionStack["delete"](node);
         path.pop();
     }
-    for (const node of Array.from(graph.nodes.keys())) {
+    for (var _d = 0, _e = Array.from(graph.nodes.keys()); _d < _e.length; _d++) {
+        var node = _e[_d];
         if (!visited.has(node)) {
             dfs(node);
         }
@@ -617,7 +759,7 @@ function getCycleSeverity(cycle, _graph) {
     // High severity if cycle involves many files or core modules
     if (cycle.length > 5)
         return 'high';
-    if (cycle.some(n => n.includes('index') || n.includes('core')))
+    if (cycle.some(function (n) { return n.includes('index') || n.includes('core'); }))
         return 'high';
     if (cycle.length > 3)
         return 'medium';
@@ -625,21 +767,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)
-    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);
+    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);
         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
@@ -647,103 +789,131 @@ function getCycleSuggestion(cycle, graph) {
 /**
  * Analyze graph boundaries using MinCut algorithm
  */
-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),
+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];
+            }
+        });
     });
-    // 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
-    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);
+    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);
     if (p1DirsSet.size === 1 && p2DirsSet.size === 1) {
-        const dir1 = p1Dirs[0];
-        const dir2 = p2Dirs[0];
-        return `Natural boundary detected between ${dir1}/ and ${dir2}/. These could be separate packages.`;
+        var dir1 = p1Dirs[0];
+        var 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 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;
+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
+                            };
+                        })];
             }
-        }
-        // 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) {
@@ -751,94 +921,108 @@ function findCommonPrefix(strings) {
         return '';
     if (strings.length === 1)
         return strings[0];
-    const sorted = [...strings].sort();
-    const first = sorted[0];
-    const last = sorted[sorted.length - 1];
-    let i = 0;
+    var sorted = __spreadArray([], strings, true).sort();
+    var first = sorted[0];
+    var last = sorted[sorted.length - 1];
+    var i = 0;
     while (i < first.length && first[i] === last[i]) {
         i++;
     }
-    const prefix = first.slice(0, i);
+    var prefix = first.slice(0, i);
     // Return the last complete directory segment
-    const lastSlash = prefix.lastIndexOf('/');
+    var lastSlash = prefix.lastIndexOf('/');
     return lastSlash > 0 ? prefix.slice(0, lastSlash) : '';
 }
 /**
  * Full graph analysis (with caching)
  */
-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;
-        }
-    }
-    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);
+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);
+                }
             }
         }
-    }
-    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;
+        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];
+            }
+        });
+    });
 }
 // ============================================================================
 // DOT Format Export
@@ -846,56 +1030,62 @@ export async function analyzeGraph(rootDir, options = {}) {
 /**
  * Export graph to DOT format for visualization
  */
-export function exportToDot(result, options = {}) {
-    const { graph, communities, circularDependencies } = result;
-    const lines = ['digraph DependencyGraph {'];
+export function exportToDot(result, options) {
+    if (options === void 0) { options = {}; }
+    var graph = result.graph, communities = result.communities, circularDependencies = result.circularDependencies;
+    var lines = ['digraph DependencyGraph {'];
     lines.push('  rankdir=LR;');
     lines.push('  node [shape=box, style=rounded];');
     lines.push('');
     // Generate colors for communities
-    const communityColors = new Map();
+    var communityColors = new Map();
     if (options.colorByCommunity && communities) {
-        const colors = [
+        var colors = [
             '#e6194b', '#3cb44b', '#ffe119', '#4363d8', '#f58231',
             '#911eb4', '#42d4f4', '#f032e6', '#bfef45', '#fabed4',
         ];
-        for (const comm of communities) {
-            const color = colors[comm.id % colors.length];
-            for (const member of comm.members) {
+        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];
                 communityColors.set(member, color);
             }
         }
     }
     // Find nodes in cycles
-    const nodesInCycles = new Set();
+    var nodesInCycles = new Set();
     if (options.highlightCycles && circularDependencies) {
-        for (const cycle of circularDependencies) {
-            for (const node of cycle.cycle) {
+        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];
                 nodesInCycles.add(node);
             }
         }
     }
     // Output nodes
     lines.push('  // Nodes');
-    for (const [id, node] of Array.from(graph.nodes.entries())) {
-        const attrs = [];
+    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 = [];
         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');
         }
-        const attrStr = attrs.length > 0 ? ` [${attrs.join(', ')}]` : '';
-        lines.push(`  "${id}"${attrStr};`);
+        var attrStr = attrs.length > 0 ? " [" + attrs.join(', ') + "]" : '';
+        lines.push("  \"" + id + "\"" + attrStr + ";");
     }
     lines.push('');
     // Output edges
     lines.push('  // Edges');
-    for (const edge of graph.edges) {
-        const attrs = [];
+    var _loop_3 = function (edge) {
+        var attrs = [];
         if (edge.type === 'dynamic') {
             attrs.push('style=dashed');
         }
@@ -904,8 +1094,8 @@ export function exportToDot(result, options = {}) {
         }
         // Check if edge is part of a cycle
         if (options.highlightCycles) {
-            const isCycleEdge = circularDependencies.some(cd => {
-                for (let i = 0; i < cd.cycle.length - 1; i++) {
+            var isCycleEdge = circularDependencies.some(function (cd) {
+                for (var i = 0; i < cd.cycle.length - 1; i++) {
                     if (cd.cycle[i] === edge.source && cd.cycle[i + 1] === edge.target) {
                         return true;
                     }
@@ -916,8 +1106,12 @@ export function exportToDot(result, options = {}) {
                 attrs.push('color=red', 'penwidth=2');
             }
         }
-        const attrStr = attrs.length > 0 ? ` [${attrs.join(', ')}]` : '';
-        lines.push(`  "${edge.source}" -> "${edge.target}"${attrStr};`);
+        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);
     }
     lines.push('}');
     return lines.join('\n');