@yuaone/core 0.4.1 → 0.4.3

package/dist/impact-analyzer.js

@@ -8,7 +8,7 @@
  * Integrates with CodebaseContext, TestIntelligence, and CrossFileRefactor.
  */
 import { readFile } from "node:fs/promises";
-import { join, basename, dirname, extname, relative } from "node:path";
+import { join, basename, dirname, extname } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
@@ -30,6 +30,9 @@ const CONFIG_FILE_PATTERNS = [
 const DOC_FILE_PATTERNS = [/\.md$/, /\.mdx$/, /\.txt$/, /CHANGELOG/];
 const API_ENDPOINT_PATTERN = /\.(get|post|put|patch|delete|all|use)\s*\(\s*['"`]([^'"`]+)['"`]/g;
 const FUNCTION_SIGNATURE_PATTERN = /export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g;
+const TYPE_EXPORT_PATTERN = /export\s+(?:type|interface)\s+(\w+)/g;
+const SYMBOL_USAGE_PATTERN = /\b([A-Za-z_][A-Za-z0-9_]*)\b/g;
+const FUNCTION_CALL_PATTERN = /\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
 // ─── Helpers ───
 function classifyFile(filePath) {
     if (TEST_FILE_PATTERNS.some((p) => p.test(filePath)))
@@ -40,11 +43,23 @@ function classifyFile(filePath) {
         return "doc";
     return "source";
 }
+function extractTypeExports(content) {
+    const out = [];
+    const re = new RegExp(TYPE_EXPORT_PATTERN.source, "g");
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        out.push(m[1]);
+    }
+    return out;
+}
 function fileNameWithoutExt(filePath) {
     const base = basename(filePath);
     const ext = extname(base);
     return base.slice(0, -ext.length);
 }
+function resolveProjectPath(projectPath, filePath) {
+    return filePath.startsWith("/") ? filePath : join(projectPath, filePath);
+}
 function extractExports(content) {
     const exports = [];
     const re = new RegExp(EXPORT_PATTERN.source, "g");
@@ -54,6 +69,24 @@ function extractExports(content) {
     }
     return exports;
 }
+function extractSymbolUsage(content) {
+    const out = [];
+    const re = new RegExp(SYMBOL_USAGE_PATTERN.source, "g");
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        out.push(m[1]);
+    }
+    return out;
+}
+function extractFunctionCalls(content) {
+    const out = [];
+    const re = new RegExp(FUNCTION_CALL_PATTERN.source, "g");
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        out.push(m[1]);
+    }
+    return out;
+}
 function extractImportPaths(content) {
     const paths = [];
     const re = new RegExp(IMPORT_FROM_PATTERN.source, "g");
@@ -101,6 +134,8 @@ async function walkDir(dir, maxFiles = 5000) {
     const files = [];
     const queue = [dir];
     while (queue.length > 0 && files.length < maxFiles) {
+        if (queue.length > 20000)
+            break;
         const current = queue.shift();
         try {
             const entries = await readdir(current, { withFileTypes: true });
@@ -130,6 +165,7 @@ export class ImpactAnalyzer {
     includeTests;
     includeAPIs;
     strictMode;
+    symbolGraph;
     constructor(config) {
         this.projectPath = config.projectPath;
         this.maxDepth = config.maxDepth ?? 3;
@@ -142,24 +178,36 @@ export class ImpactAnalyzer {
      */
     async analyzeChanges(changedFiles) {
         try {
-            const [affectedFiles, affectedTests, affectedAPIs, breakingChanges] = await Promise.all([
+            const graph = await this.getGraph();
+            await graph.update(changedFiles.map((f) => resolveProjectPath(this.projectPath, f)));
+            const cycles = graph.detectCycles();
+            const [affectedFiles, affectedTests, affectedAPIs, breakingChanges, deadCodeCandidates, testCoverage, refactorPlan,] = await Promise.all([
                 this.collectAffectedFiles(changedFiles),
                 this.includeTests ? this.suggestTests(changedFiles) : Promise.resolve([]),
                 this.includeAPIs ? this.collectAffectedAPIs(changedFiles) : Promise.resolve([]),
                 this.detectBreaking(changedFiles),
+                this.detectDeadCode(changedFiles),
+                this.inferTestCoverage(changedFiles),
+                this.buildSafeRefactorPlan(changedFiles),
             ]);
             const riskLevel = this.estimateRisk({
                 files: changedFiles,
                 linesChanged: affectedFiles.length * 20, // rough estimate
             });
-            const summary = this.buildSummary(changedFiles, affectedFiles, affectedTests, breakingChanges, riskLevel);
-            const suggestedActions = this.buildSuggestedActions(affectedTests, breakingChanges, riskLevel);
+            let summary = this.buildSummary(changedFiles, affectedFiles, affectedTests, breakingChanges, riskLevel);
+            if (cycles.length > 0) {
+                summary += ` ${cycles.length} dependency cycle(s) detected.`;
+            }
+            const suggestedActions = this.buildSuggestedActions(affectedTests, breakingChanges, riskLevel, deadCodeCandidates, testCoverage);
             return {
                 changedFiles,
                 affectedFiles,
                 affectedTests,
                 affectedAPIs,
                 breakingChanges,
+                deadCodeCandidates,
+                testCoverage,
+                refactorPlan,
                 riskLevel,
                 summary,
                 suggestedActions,
@@ -171,6 +219,9 @@ export class ImpactAnalyzer {
                 affectedFiles: [],
                 affectedTests: [],
                 affectedAPIs: [],
+                deadCodeCandidates: [],
+                testCoverage: [],
+                refactorPlan: [],
                 breakingChanges: [],
                 riskLevel: "minimal",
                 summary: "Impact analysis could not be completed.",
@@ -183,38 +234,27 @@ export class ImpactAnalyzer {
      */
     async findAffectedFiles(filePath) {
         try {
-            const content = await readFileSafe(filePath);
+            const absoluteFilePath = resolveProjectPath(this.projectPath, filePath);
+            const content = await readFileSafe(absoluteFilePath);
             if (!content)
                 return [];
             const exports = extractExports(content);
-            const changedName = fileNameWithoutExt(filePath);
-            const projectFiles = await walkDir(this.projectPath);
+            const changedName = basename(absoluteFilePath).replace(/\.[jt]sx?$/, "");
+            const graph = await this.getGraph();
             const affected = [];
             const seen = new Set();
             // BFS through import graph
             const queue = [];
-            // Find direct importers
-            for (const pf of projectFiles) {
-                if (pf === filePath)
-                    continue;
-                const pfContent = await readFileSafe(pf);
-                if (!pfContent)
+            const importers = graph.reverseImports.get(changedName) ?? new Set();
+            for (const importer of importers) {
+                if (seen.has(importer) || importer === absoluteFilePath)
                     continue;
-                const importPaths = extractImportPaths(pfContent);
-                const importsChanged = importPaths.some((ip) => {
-                    const importBase = basename(ip).replace(/\.[jt]sx?$/, "");
-                    return (ip.includes(changedName) ||
-                        importBase === changedName ||
-                        ip.endsWith(relative(this.projectPath, filePath).replace(/\.[jt]sx?$/, "")));
+                queue.push({
+                    file: importer,
+                    depth: 1,
+                    reason: `imports changed module "${changedName}"`,
+                    confidence: 0.95,
                 });
-                if (importsChanged) {
-                    queue.push({
-                        file: pf,
-                        depth: 1,
-                        reason: `imports changed module "${changedName}"`,
-                        confidence: 0.95,
-                    });
-                }
             }
             // Process queue up to maxDepth
             while (queue.length > 0) {
@@ -230,38 +270,30 @@ export class ImpactAnalyzer {
                     type: fileType,
                 });
                 if (depth < this.maxDepth) {
-                    const transitiveName = fileNameWithoutExt(file);
-                    for (const pf of projectFiles) {
-                        if (seen.has(pf) || pf === file)
+                    const transitiveKey = basename(file).replace(/\.[jt]sx?$/, "");
+                    const nextImporters = graph.reverseImports.get(transitiveKey) ?? new Set();
+                    for (const pf of nextImporters) {
+                        if (seen.has(pf))
                             continue;
-                        const pfContent = await readFileSafe(pf);
-                        if (!pfContent)
-                            continue;
-                        const importPaths = extractImportPaths(pfContent);
-                        if (importPaths.some((ip) => ip.includes(transitiveName))) {
-                            queue.push({
-                                file: pf,
-                                depth: depth + 1,
-                                reason: `transitively affected via "${transitiveName}" (depth ${depth + 1})`,
-                                confidence: confidence * 0.7,
-                            });
-                        }
+                        queue.push({
+                            file: pf,
+                            depth: depth + 1,
+                            reason: `transitively affected via "${transitiveKey}"`,
+                            confidence: confidence * 0.7,
+                        });
                     }
                 }
             }
             // If an export is a function/class used in test files, flag those too
             if (this.includeTests) {
-                for (const pf of projectFiles) {
-                    if (seen.has(pf) || !TEST_FILE_PATTERNS.some((p) => p.test(pf)))
-                        continue;
-                    const pfContent = await readFileSafe(pf);
-                    if (!pfContent)
+                for (const [pf, pfContent] of graph.fileContents.entries()) {
+                    if (seen.has(pf) || pf === absoluteFilePath)
                         continue;
-                    const usesExport = exports.some((exp) => pfContent.includes(exp));
+                    const usesExport = exports.some((exp) => new RegExp(`\\b${exp}\\b`).test(pfContent));
                     if (usesExport) {
                         affected.push({
                             path: pf,
-                            reason: `test for changed file "${changedName}"`,
+                            reason: `test for changed module "${changedName}"`,
                             confidence: 0.8,
                             type: "test",
                         });
@@ -307,6 +339,7 @@ export class ImpactAnalyzer {
      */
     async suggestTests(changedFiles) {
         try {
+            const graph = await this.getGraph();
             const projectFiles = await walkDir(this.projectPath);
             const testFiles = projectFiles.filter((f) => TEST_FILE_PATTERNS.some((p) => p.test(f)));
             const tests = [];
@@ -343,7 +376,7 @@ export class ImpactAnalyzer {
                         continue;
                     }
                     // Test imports the changed module
-                    const tfContent = await readFileSafe(tf);
+                    const tfContent = graph.fileContents.get(tf) ?? await readFileSafe(tf);
                     if (!tfContent)
                         continue;
                     const importPaths = extractImportPaths(tfContent);
@@ -383,9 +416,11 @@ export class ImpactAnalyzer {
     async detectBreaking(changedFiles, diffs) {
         try {
             const breaking = [];
+            const renameMap = new Map();
             for (let i = 0; i < changedFiles.length; i++) {
                 const file = changedFiles[i];
-                const diff = diffs?.[i] ?? (await gitDiff(this.projectPath, file));
+                const resolvedFile = resolveProjectPath(this.projectPath, file);
+                const diff = diffs?.[i] ?? (await gitDiff(this.projectPath, resolvedFile));
                 if (!diff)
                     continue;
                 const lines = diff.split("\n");
@@ -471,6 +506,7 @@ export class ImpactAnalyzer {
                 if (removedExports.length > 0 && removedExports.length === addedExports.length) {
                     for (let j = 0; j < removedExports.length; j++) {
                         if (removedExports[j] !== addedExports[j]) {
+                            renameMap.set(removedExports[j], addedExports[j]);
                             // Already reported as removed? Skip duplication
                             if (!breaking.some((b) => b.description.includes(removedExports[j]))) {
                                 breaking.push({
@@ -483,6 +519,53 @@ export class ImpactAnalyzer {
                         }
                     }
                 }
+                if (renameMap.size > 0) {
+                    const renamedOldNames = new Set(renameMap.keys());
+                    for (let k = breaking.length - 1; k >= 0; k--) {
+                        const item = breaking[k];
+                        if (item.file === file &&
+                            item.severity === "critical") {
+                            const m = item.description.match(/^Removed export "(.+)"$/);
+                            if (m && renamedOldNames.has(m[1])) {
+                                breaking.splice(k, 1);
+                            }
+                        }
+                    }
+                }
+            }
+            // ─── rename impact propagation ───
+            if (renameMap.size > 0) {
+                const graph = await this.getGraph();
+                for (const [oldName, newName] of renameMap.entries()) {
+                    for (const [usageFile, usages] of graph.symbolUsage.entries()) {
+                        if (!usages.includes(oldName))
+                            continue;
+                        if (!breaking.some((b) => b.file === usageFile &&
+                            b.description === `Symbol "${oldName}" renamed to "${newName}"`)) {
+                            breaking.push({
+                                file: usageFile,
+                                description: `Symbol "${oldName}" renamed to "${newName}"`,
+                                severity: "high",
+                                suggestion: `Update import or usage to "${newName}".`,
+                            });
+                        }
+                    }
+                }
+                for (const [file, calls] of graph.callGraph.entries()) {
+                    for (const [oldName, newName] of renameMap.entries()) {
+                        if (!calls.includes(oldName))
+                            continue;
+                        if (!breaking.some((b) => b.file === file &&
+                            b.description === `Call to renamed function "${oldName}"`)) {
+                            breaking.push({
+                                file,
+                                description: `Call to renamed function "${oldName}"`,
+                                severity: "high",
+                                suggestion: `Update call to "${newName}".`,
+                            });
+                        }
+                    }
+                }
             }
             return breaking;
         }
@@ -558,12 +641,27 @@ export class ImpactAnalyzer {
     }
     async collectAffectedAPIs(changedFiles) {
         const apis = [];
+        const graph = await this.getGraph();
         for (const file of changedFiles) {
-            const content = await readFileSafe(file);
+            const resolvedFile = resolveProjectPath(this.projectPath, file);
+            const content = graph.fileContents.get(resolvedFile) ?? await readFileSafe(resolvedFile);
             if (!content)
                 continue;
             const fileAPIs = extractAPIs(content, file);
             apis.push(...fileAPIs);
+            const endpoints = graph.apiEndpoints.get(resolvedFile) ?? [];
+            for (const ep of endpoints) {
+                if (!ep)
+                    continue;
+                if (!apis.some((a) => a.endpoint === ep && a.file === file)) {
+                    apis.push({
+                        endpoint: ep,
+                        functionName: ep,
+                        file,
+                        changeType: "behavior",
+                    });
+                }
+            }
             // Also extract exported functions as potential API surface
             const exports = extractExports(content);
             for (const exp of exports) {
@@ -578,6 +676,12 @@ export class ImpactAnalyzer {
         }
         return apis;
     }
+    async getGraph() {
+        if (!this.symbolGraph) {
+            this.symbolGraph = await SymbolGraph.build(this.projectPath);
+        }
+        return this.symbolGraph;
+    }
     buildSummary(changedFiles, affectedFiles, affectedTests, breakingChanges, riskLevel) {
         const parts = [];
         parts.push(`${changedFiles.length} file(s) changed, affecting ${affectedFiles.length} other file(s).`);
@@ -592,7 +696,126 @@ export class ImpactAnalyzer {
         parts.push(`Risk level: ${riskLevel}.`);
         return parts.join(" ");
     }
-    buildSuggestedActions(affectedTests, breakingChanges, riskLevel) {
+    async detectDeadCode(changedFiles) {
+        const graph = await this.getGraph();
+        const out = [];
+        for (const file of changedFiles) {
+            const resolvedFile = resolveProjectPath(this.projectPath, file);
+            const exports = graph.exportsByFile.get(resolvedFile) ?? [];
+            const typeExports = graph.typeExportsByFile.get(resolvedFile) ?? [];
+            for (const symbol of exports) {
+                let used = false;
+                for (const [otherFile, usages] of graph.symbolUsage.entries()) {
+                    if (otherFile === resolvedFile)
+                        continue;
+                    if (usages.includes(symbol)) {
+                        used = true;
+                        break;
+                    }
+                }
+                if (!used) {
+                    out.push({
+                        file,
+                        symbol,
+                        kind: "export",
+                        confidence: 0.75,
+                    });
+                }
+            }
+            for (const symbol of typeExports) {
+                let used = false;
+                for (const [otherFile, usages] of graph.symbolUsage.entries()) {
+                    if (otherFile === resolvedFile)
+                        continue;
+                    if (usages.includes(symbol)) {
+                        used = true;
+                        break;
+                    }
+                }
+                if (!used) {
+                    out.push({
+                        file,
+                        symbol,
+                        kind: "type_export",
+                        confidence: 0.7,
+                    });
+                }
+            }
+        }
+        return out;
+    }
+    async inferTestCoverage(changedFiles) {
+        const tests = await this.suggestTests(changedFiles);
+        const out = [];
+        for (const file of changedFiles) {
+            const changedName = fileNameWithoutExt(file);
+            const direct = tests.some((t) => basename(t.path) === `${changedName}.test.ts` ||
+                basename(t.path) === `${changedName}.test.tsx` ||
+                basename(t.path) === `${changedName}.spec.ts` ||
+                basename(t.path) === `${changedName}.spec.tsx`);
+            const importerTests = tests.some((t) => t.reason.includes("imports changed module"));
+            let inferredCoverage = "unknown";
+            let reason = "No clear signals.";
+            if (direct) {
+                inferredCoverage = "high";
+                reason = "Direct test file exists.";
+            }
+            else if (importerTests) {
+                inferredCoverage = "medium";
+                reason = "Importer-based tests exist.";
+            }
+            else {
+                inferredCoverage = "low";
+                reason = "No direct or importer-linked tests found.";
+            }
+            out.push({
+                file,
+                hasDirectTest: direct,
+                hasImporterTests: importerTests,
+                inferredCoverage,
+                reason,
+            });
+        }
+        return out;
+    }
+    async buildSafeRefactorPlan(changedFiles) {
+        const graph = await this.getGraph();
+        const steps = [];
+        let step = 1;
+        for (const file of changedFiles) {
+            const resolvedFile = resolveProjectPath(this.projectPath, file);
+            const moduleKey = basename(resolvedFile).replace(/\.[jt]sx?$/, "");
+            const importers = [...(graph.reverseImports.get(moduleKey) ?? new Set())];
+            const exportedSymbols = graph.exportsByFile.get(resolvedFile) ?? [];
+            steps.push({
+                step: step++,
+                action: `Stabilize exports in ${file} with compatibility alias if needed.`,
+                files: [file],
+                risk: "low",
+            });
+            if (importers.length > 0) {
+                steps.push({
+                    step: step++,
+                    action: `Update importer references for ${file}.`,
+                    files: importers,
+                    risk: "medium",
+                });
+            }
+            const callSites = [...graph.callGraph.entries()]
+                .filter(([, calls]) => exportedSymbols.some((symbol) => calls.includes(symbol)))
+                .map(([callFile]) => callFile);
+            if (callSites.length > 0) {
+                steps.push({
+                    step: step++,
+                    action: `Review call sites potentially affected by refactor in ${file}.`,
+                    files: callSites,
+                    risk: "high",
+                });
+            }
+        }
+        return steps;
+    }
+    buildSuggestedActions(affectedTests, breakingChanges, riskLevel, deadCodeCandidates = [], testCoverage = []) {
         const actions = [];
         const mustRun = affectedTests.filter((t) => t.priority === "must_run");
         if (mustRun.length > 0) {
@@ -603,6 +826,12 @@ export class ImpactAnalyzer {
                 actions.push(bc.suggestion);
             }
         }
+        if (deadCodeCandidates.length > 0) {
+            actions.push(`Review ${deadCodeCandidates.length} dead code candidate(s) before deleting exports.`);
+        }
+        if (testCoverage.some((t) => t.inferredCoverage === "low")) {
+            actions.push("Add tests for changed modules with low inferred coverage.");
+        }
         if (riskLevel === "high" || riskLevel === "critical") {
             actions.push("Request a thorough code review before merging.");
         }
@@ -612,4 +841,137 @@ export class ImpactAnalyzer {
         return actions;
     }
 }
+// ─── Symbol Graph Cache ───
+class SymbolGraph {
+    fileContents = new Map();
+    exportsByFile = new Map();
+    typeExportsByFile = new Map();
+    importsByFile = new Map();
+    reverseImports = new Map();
+    apiEndpoints = new Map();
+    symbolUsage = new Map();
+    callGraph = new Map();
+    /**
+     * Incrementally update graph for changed files.
+     */
+    async update(files) {
+        for (const file of files) {
+            const content = await readFileSafe(file);
+            if (!content) {
+                this.removeFile(file);
+                continue;
+            }
+            const prevImports = this.importsByFile.get(file) ?? [];
+            // remove previous reverse edges
+            for (const imp of prevImports) {
+                const base = basename(imp).replace(/\.[jt]sx?$/, "");
+                const set = this.reverseImports.get(base);
+                if (set) {
+                    set.delete(file);
+                    if (set.size === 0)
+                        this.reverseImports.delete(base);
+                }
+            }
+            const exports = extractExports(content);
+            const typeExports = extractTypeExports(content);
+            const imports = extractImportPaths(content);
+            const apis = extractAPIs(content, file);
+            const symbols = extractSymbolUsage(content);
+            const calls = extractFunctionCalls(content);
+            this.fileContents.set(file, content);
+            this.exportsByFile.set(file, exports);
+            this.typeExportsByFile.set(file, typeExports);
+            this.importsByFile.set(file, imports);
+            this.symbolUsage.set(file, symbols);
+            this.callGraph.set(file, calls);
+            this.apiEndpoints.set(file, apis.map((a) => a.endpoint).filter((ep) => Boolean(ep)));
+            for (const imp of imports) {
+                const base = basename(imp).replace(/\.[jt]sx?$/, "");
+                if (!this.reverseImports.has(base)) {
+                    this.reverseImports.set(base, new Set());
+                }
+                this.reverseImports.get(base).add(file);
+            }
+        }
+    }
+    removeFile(file) {
+        const prevImports = this.importsByFile.get(file) ?? [];
+        for (const imp of prevImports) {
+            const base = basename(imp).replace(/\.[jt]sx?$/, "");
+            const set = this.reverseImports.get(base);
+            if (set) {
+                set.delete(file);
+                if (set.size === 0)
+                    this.reverseImports.delete(base);
+            }
+        }
+        this.fileContents.delete(file);
+        this.exportsByFile.delete(file);
+        this.typeExportsByFile.delete(file);
+        this.importsByFile.delete(file);
+        this.apiEndpoints.delete(file);
+        this.symbolUsage.delete(file);
+        this.callGraph.delete(file);
+    }
+    static async build(projectPath) {
+        const graph = new SymbolGraph();
+        const files = await walkDir(projectPath);
+        const contents = await Promise.all(files.map(async (f) => [f, await readFileSafe(f)]));
+        for (const [file, content] of contents) {
+            if (!content)
+                continue;
+            graph.fileContents.set(file, content);
+            const exports = extractExports(content);
+            const typeExports = extractTypeExports(content);
+            const imports = extractImportPaths(content);
+            const apis = extractAPIs(content, file);
+            const symbols = extractSymbolUsage(content);
+            const calls = extractFunctionCalls(content);
+            graph.exportsByFile.set(file, exports);
+            graph.typeExportsByFile.set(file, typeExports);
+            graph.importsByFile.set(file, imports);
+            graph.symbolUsage.set(file, symbols);
+            graph.callGraph.set(file, calls);
+            graph.apiEndpoints.set(file, apis.map((a) => a.endpoint).filter((ep) => Boolean(ep)));
+            for (const imp of imports) {
+                const base = basename(imp).replace(/\.[jt]sx?$/, "");
+                if (!graph.reverseImports.has(base)) {
+                    graph.reverseImports.set(base, new Set());
+                }
+                graph.reverseImports.get(base).add(file);
+            }
+        }
+        return graph;
+    }
+    detectCycles() {
+        const cycles = [];
+        const visited = new Set();
+        const stack = new Set();
+        const visit = (node, path) => {
+            if (stack.has(node)) {
+                const cycleStart = path.indexOf(node);
+                cycles.push(path.slice(cycleStart));
+                return;
+            }
+            if (visited.has(node))
+                return;
+            visited.add(node);
+            stack.add(node);
+            const imports = this.importsByFile.get(node) ?? [];
+            for (const imp of imports) {
+                const base = basename(imp).replace(/\.[jt]sx?$/, "");
+                for (const [file] of this.fileContents) {
+                    if (basename(file).replace(/\.[jt]sx?$/, "") === base) {
+                        visit(file, [...path, file]);
+                    }
+                }
+            }
+            stack.delete(node);
+        };
+        for (const file of this.fileContents.keys()) {
+            visit(file, [file]);
+        }
+        return cycles;
+    }
+}
 //# sourceMappingURL=impact-analyzer.js.map