kynjal-cli 3.1.3 → 4.0.0

package/dist/src/ruvector/coverage-router.js

@@ -6,14 +6,70 @@
  * - TTL-based caching of coverage data
  * - Singleton router instance
  */
+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));
+};
 // ============================================================================
 // Caching for Performance
 // ============================================================================
 /**
  * Cache for coverage data (1 minute TTL)
  */
-const coverageDataCache = new Map();
-const COVERAGE_CACHE_TTL_MS = 60 * 1000; // 1 minute
+var coverageDataCache = new Map();
+var COVERAGE_CACHE_TTL_MS = 60 * 1000; // 1 minute
 /**
  * Clear coverage cache
  */
@@ -26,74 +82,89 @@ export function clearCoverageCache() {
 export function getCoverageCacheStats() {
     return { size: coverageDataCache.size };
 }
-const DEFAULT_CONFIG = {
+var DEFAULT_CONFIG = {
     minCoverage: 70,
     targetCoverage: 85,
     incremental: true,
-    coverageTypes: ['line', 'branch', 'function', 'statement'],
+    coverageTypes: ['line', 'branch', 'function', 'statement']
 };
-export class CoverageRouter {
-    config;
-    ruvectorEngine = null;
-    useNative = false;
-    coverageHistory = [];
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    async initialize() {
-        try {
-            // @ruvector/coverage is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/coverage').catch(() => null);
-            if (ruvector) {
-                this.ruvectorEngine = ruvector.createCoverageRouter?.(this.config);
-                this.useNative = !!this.ruvectorEngine;
-            }
-        }
-        catch {
-            this.useNative = false;
-        }
-    }
-    parseCoverage(data, format = 'json') {
+var CoverageRouter = /** @class */ (function () {
+    function CoverageRouter(config) {
+        if (config === void 0) { config = {}; }
+        this.ruvectorEngine = null;
+        this.useNative = false;
+        this.coverageHistory = [];
+        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
+    }
+    CoverageRouter.prototype.initialize = function () {
+        var _a, _b;
+        return __awaiter(this, void 0, Promise, function () {
+            var ruvector, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, import('@ruvector/coverage')["catch"](function () { return null; })];
+                    case 1:
+                        ruvector = _d.sent();
+                        if (ruvector) {
+                            this.ruvectorEngine = (_b = (_a = ruvector).createCoverageRouter) === null || _b === void 0 ? void 0 : _b.call(_a, this.config);
+                            this.useNative = !!this.ruvectorEngine;
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _c = _d.sent();
+                        this.useNative = false;
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CoverageRouter.prototype.parseCoverage = function (data, format) {
+        if (format === void 0) { format = 'json'; }
         switch (format) {
             case 'lcov': return this.parseLcov(data);
             case 'istanbul': return this.parseIstanbul(data);
             case 'cobertura': return this.parseCobertura(data);
             default: return this.parseJson(data);
         }
-    }
-    route(coverage, changedFiles) {
-        const gaps = this.calculateGaps(coverage);
-        const targetFiles = this.prioritizeFiles(coverage, changedFiles);
-        const action = this.determineAction(coverage, gaps);
-        const priority = this.calculatePriority(coverage, changedFiles);
-        const testTypes = this.recommendTestTypes(gaps);
-        const estimatedEffort = this.estimateEffort(gaps);
-        const impactScore = this.calculateImpact(coverage, targetFiles);
-        return { action, priority, targetFiles, testTypes, gaps, estimatedEffort, impactScore };
-    }
-    getTrend() {
+    };
+    CoverageRouter.prototype.route = function (coverage, changedFiles) {
+        var gaps = this.calculateGaps(coverage);
+        var targetFiles = this.prioritizeFiles(coverage, changedFiles);
+        var action = this.determineAction(coverage, gaps);
+        var priority = this.calculatePriority(coverage, changedFiles);
+        var testTypes = this.recommendTestTypes(gaps);
+        var estimatedEffort = this.estimateEffort(gaps);
+        var impactScore = this.calculateImpact(coverage, targetFiles);
+        return { action: action, priority: priority, targetFiles: targetFiles, testTypes: testTypes, gaps: gaps, estimatedEffort: estimatedEffort, impactScore: impactScore };
+    };
+    CoverageRouter.prototype.getTrend = function () {
         if (this.coverageHistory.length < 2)
             return { direction: 'stable', change: 0 };
-        const recent = this.coverageHistory[this.coverageHistory.length - 1];
-        const previous = this.coverageHistory[this.coverageHistory.length - 2];
-        const change = recent.overall - previous.overall;
-        return { direction: change > 0.5 ? 'up' : change < -0.5 ? 'down' : 'stable', change };
-    }
-    addToHistory(report) {
+        var recent = this.coverageHistory[this.coverageHistory.length - 1];
+        var previous = this.coverageHistory[this.coverageHistory.length - 2];
+        var change = recent.overall - previous.overall;
+        return { direction: change > 0.5 ? 'up' : change < -0.5 ? 'down' : 'stable', change: change };
+    };
+    CoverageRouter.prototype.addToHistory = function (report) {
         this.coverageHistory.push(report);
         if (this.coverageHistory.length > 10)
             this.coverageHistory.shift();
-    }
-    getStats() {
+    };
+    CoverageRouter.prototype.getStats = function () {
         return { useNative: this.useNative, historySize: this.coverageHistory.length, minCoverage: this.config.minCoverage, targetCoverage: this.config.targetCoverage };
-    }
-    parseLcov(data) {
-        const files = [];
-        let currentFile = null;
-        const lines = data.split('\n');
-        for (const line of lines) {
+    };
+    CoverageRouter.prototype.parseLcov = function (data) {
+        var _a;
+        var files = [];
+        var currentFile = null;
+        var lines = data.split('\n');
+        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+            var line = lines_1[_i];
             if (line.startsWith('SF:')) {
-                if (currentFile?.path)
+                if (currentFile === null || currentFile === void 0 ? void 0 : currentFile.path)
                     files.push(this.finalizeFileCoverage(currentFile));
                 currentFile = { path: line.substring(3), uncoveredLines: [], totalLines: 0, coveredLines: 0 };
             }
@@ -106,88 +177,95 @@ export class CoverageRouter {
                     currentFile.coveredLines = parseInt(line.substring(3), 10);
             }
             else if (line.startsWith('DA:')) {
-                const [lineNum, hits] = line.substring(3).split(',').map(Number);
+                var _b = line.substring(3).split(',').map(Number), lineNum = _b[0], hits = _b[1];
                 if (currentFile && hits === 0)
-                    currentFile.uncoveredLines?.push(lineNum);
+                    (_a = currentFile.uncoveredLines) === null || _a === void 0 ? void 0 : _a.push(lineNum);
             }
             else if (line === 'end_of_record') {
-                if (currentFile?.path)
+                if (currentFile === null || currentFile === void 0 ? void 0 : currentFile.path)
                     files.push(this.finalizeFileCoverage(currentFile));
                 currentFile = null;
             }
         }
         return this.buildReport(files);
-    }
-    parseIstanbul(data) {
-        const files = [];
-        for (const [path, coverage] of Object.entries(data)) {
-            const cov = coverage;
-            const statements = cov.s;
-            const functions = cov.f;
-            const branches = cov.b;
-            const statementCovered = Object.values(statements).filter(v => v > 0).length;
-            const statementTotal = Object.values(statements).length;
-            const functionCovered = Object.values(functions).filter(v => v > 0).length;
-            const functionTotal = Object.values(functions).length;
-            const branchCovered = Object.values(branches).flat().filter(v => v > 0).length;
-            const branchTotal = Object.values(branches).flat().length;
+    };
+    CoverageRouter.prototype.parseIstanbul = function (data) {
+        var files = [];
+        for (var _i = 0, _a = Object.entries(data); _i < _a.length; _i++) {
+            var _b = _a[_i], path = _b[0], coverage = _b[1];
+            var cov = coverage;
+            var statements = cov.s;
+            var functions = cov.f;
+            var branches = cov.b;
+            var statementCovered = Object.values(statements).filter(function (v) { return v > 0; }).length;
+            var statementTotal = Object.values(statements).length;
+            var functionCovered = Object.values(functions).filter(function (v) { return v > 0; }).length;
+            var functionTotal = Object.values(functions).length;
+            var branchCovered = Object.values(branches).flat().filter(function (v) { return v > 0; }).length;
+            var branchTotal = Object.values(branches).flat().length;
             files.push({
-                path, lineCoverage: statementTotal > 0 ? (statementCovered / statementTotal) * 100 : 100,
+                path: path,
+                lineCoverage: statementTotal > 0 ? (statementCovered / statementTotal) * 100 : 100,
                 branchCoverage: branchTotal > 0 ? (branchCovered / branchTotal) * 100 : 100,
                 functionCoverage: functionTotal > 0 ? (functionCovered / functionTotal) * 100 : 100,
                 statementCoverage: statementTotal > 0 ? (statementCovered / statementTotal) * 100 : 100,
-                uncoveredLines: [], totalLines: statementTotal, coveredLines: statementCovered,
+                uncoveredLines: [], totalLines: statementTotal, coveredLines: statementCovered
             });
         }
         return this.buildReport(files);
-    }
-    parseCobertura(data) {
-        const files = [];
-        const classMatches = data.matchAll(/<class[^>]*filename="([^"]+)"[^>]*line-rate="([^"]+)"[^>]*branch-rate="([^"]+)"[^>]*>/g);
-        for (const match of classMatches) {
+    };
+    CoverageRouter.prototype.parseCobertura = function (data) {
+        var files = [];
+        var classMatches = data.matchAll(/<class[^>]*filename="([^"]+)"[^>]*line-rate="([^"]+)"[^>]*branch-rate="([^"]+)"[^>]*>/g);
+        for (var _i = 0, classMatches_1 = classMatches; _i < classMatches_1.length; _i++) {
+            var match = classMatches_1[_i];
             files.push({
                 path: match[1], lineCoverage: parseFloat(match[2]) * 100, branchCoverage: parseFloat(match[3]) * 100,
                 functionCoverage: parseFloat(match[2]) * 100, statementCoverage: parseFloat(match[2]) * 100,
-                uncoveredLines: [], totalLines: 0, coveredLines: 0,
+                uncoveredLines: [], totalLines: 0, coveredLines: 0
             });
         }
         return this.buildReport(files);
-    }
-    parseJson(data) {
+    };
+    CoverageRouter.prototype.parseJson = function (data) {
         if (Array.isArray(data))
             return this.buildReport(data);
-        const files = [];
-        for (const [path, coverage] of Object.entries(data)) {
-            const cov = coverage;
+        var files = [];
+        for (var _i = 0, _a = Object.entries(data); _i < _a.length; _i++) {
+            var _b = _a[_i], path = _b[0], coverage = _b[1];
+            var cov = coverage;
             files.push({
-                path, lineCoverage: cov.lineCoverage || 0, branchCoverage: cov.branchCoverage || 0,
+                path: path,
+                lineCoverage: cov.lineCoverage || 0, branchCoverage: cov.branchCoverage || 0,
                 functionCoverage: cov.functionCoverage || 0, statementCoverage: cov.statementCoverage || 0,
-                uncoveredLines: cov.uncoveredLines || [], totalLines: cov.totalLines || 0, coveredLines: cov.coveredLines || 0,
+                uncoveredLines: cov.uncoveredLines || [], totalLines: cov.totalLines || 0, coveredLines: cov.coveredLines || 0
             });
         }
         return this.buildReport(files);
-    }
-    finalizeFileCoverage(partial) {
-        const lineCoverage = partial.totalLines && partial.totalLines > 0 ? (partial.coveredLines || 0) / partial.totalLines * 100 : 100;
-        return { path: partial.path || 'unknown', lineCoverage, branchCoverage: lineCoverage, functionCoverage: lineCoverage, statementCoverage: lineCoverage, uncoveredLines: partial.uncoveredLines || [], totalLines: partial.totalLines || 0, coveredLines: partial.coveredLines || 0 };
-    }
-    buildReport(files) {
-        const totalLines = files.reduce((sum, f) => sum + f.totalLines, 0);
-        const coveredLines = files.reduce((sum, f) => sum + f.coveredLines, 0);
-        const overall = totalLines > 0 ? (coveredLines / totalLines) * 100 : 100;
-        const avgLine = files.length > 0 ? files.reduce((sum, f) => sum + f.lineCoverage, 0) / files.length : 100;
-        const avgBranch = files.length > 0 ? files.reduce((sum, f) => sum + f.branchCoverage, 0) / files.length : 100;
-        const avgFunction = files.length > 0 ? files.reduce((sum, f) => sum + f.functionCoverage, 0) / files.length : 100;
-        const avgStatement = files.length > 0 ? files.reduce((sum, f) => sum + f.statementCoverage, 0) / files.length : 100;
-        const sortedByLine = [...files].sort((a, b) => a.lineCoverage - b.lineCoverage);
-        return { overall, byType: { line: avgLine, branch: avgBranch, function: avgFunction, statement: avgStatement }, byFile: files, lowestCoverage: sortedByLine.slice(0, 5), highestCoverage: sortedByLine.slice(-5).reverse(), uncoveredCritical: this.findCriticalUncovered(files), timestamp: Date.now() };
-    }
-    findCriticalUncovered(files) {
-        const critical = [];
-        const criticalPatterns = [/auth/, /security/, /payment/, /core/, /main/, /index/];
-        for (const file of files) {
+    };
+    CoverageRouter.prototype.finalizeFileCoverage = function (partial) {
+        var lineCoverage = partial.totalLines && partial.totalLines > 0 ? (partial.coveredLines || 0) / partial.totalLines * 100 : 100;
+        return { path: partial.path || 'unknown', lineCoverage: lineCoverage, branchCoverage: lineCoverage, functionCoverage: lineCoverage, statementCoverage: lineCoverage, uncoveredLines: partial.uncoveredLines || [], totalLines: partial.totalLines || 0, coveredLines: partial.coveredLines || 0 };
+    };
+    CoverageRouter.prototype.buildReport = function (files) {
+        var totalLines = files.reduce(function (sum, f) { return sum + f.totalLines; }, 0);
+        var coveredLines = files.reduce(function (sum, f) { return sum + f.coveredLines; }, 0);
+        var overall = totalLines > 0 ? (coveredLines / totalLines) * 100 : 100;
+        var avgLine = files.length > 0 ? files.reduce(function (sum, f) { return sum + f.lineCoverage; }, 0) / files.length : 100;
+        var avgBranch = files.length > 0 ? files.reduce(function (sum, f) { return sum + f.branchCoverage; }, 0) / files.length : 100;
+        var avgFunction = files.length > 0 ? files.reduce(function (sum, f) { return sum + f.functionCoverage; }, 0) / files.length : 100;
+        var avgStatement = files.length > 0 ? files.reduce(function (sum, f) { return sum + f.statementCoverage; }, 0) / files.length : 100;
+        var sortedByLine = __spreadArray([], files, true).sort(function (a, b) { return a.lineCoverage - b.lineCoverage; });
+        return { overall: overall, byType: { line: avgLine, branch: avgBranch, "function": avgFunction, statement: avgStatement }, byFile: files, lowestCoverage: sortedByLine.slice(0, 5), highestCoverage: sortedByLine.slice(-5).reverse(), uncoveredCritical: this.findCriticalUncovered(files), timestamp: Date.now() };
+    };
+    CoverageRouter.prototype.findCriticalUncovered = function (files) {
+        var critical = [];
+        var criticalPatterns = [/auth/, /security/, /payment/, /core/, /main/, /index/];
+        for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+            var file = files_1[_i];
             if (file.lineCoverage < this.config.minCoverage) {
-                for (const pattern of criticalPatterns) {
+                for (var _a = 0, criticalPatterns_1 = criticalPatterns; _a < criticalPatterns_1.length; _a++) {
+                    var pattern = criticalPatterns_1[_a];
                     if (pattern.test(file.path)) {
                         critical.push(file.path);
                         break;
@@ -196,19 +274,20 @@ export class CoverageRouter {
             }
         }
         return critical.slice(0, 10);
-    }
-    calculateGaps(coverage) {
-        const gaps = [];
-        for (const file of coverage.byFile) {
+    };
+    CoverageRouter.prototype.calculateGaps = function (coverage) {
+        var gaps = [];
+        for (var _i = 0, _a = coverage.byFile; _i < _a.length; _i++) {
+            var file = _a[_i];
             if (file.lineCoverage < this.config.targetCoverage) {
-                const gap = this.config.targetCoverage - file.lineCoverage;
-                gaps.push({ file: file.path, currentCoverage: file.lineCoverage, targetCoverage: this.config.targetCoverage, gap, suggestedTests: this.suggestTests(file) });
+                var gap = this.config.targetCoverage - file.lineCoverage;
+                gaps.push({ file: file.path, currentCoverage: file.lineCoverage, targetCoverage: this.config.targetCoverage, gap: gap, suggestedTests: this.suggestTests(file) });
             }
         }
-        return gaps.sort((a, b) => b.gap - a.gap).slice(0, 10);
-    }
-    suggestTests(file) {
-        const suggestions = [];
+        return gaps.sort(function (a, b) { return b.gap - a.gap; }).slice(0, 10);
+    };
+    CoverageRouter.prototype.suggestTests = function (file) {
+        var suggestions = [];
         if (file.uncoveredLines.length > 10)
             suggestions.push('Add unit tests for uncovered code paths');
         if (file.branchCoverage < 50)
@@ -218,16 +297,17 @@ export class CoverageRouter {
         if (/api|endpoint|route|handler/.test(file.path))
             suggestions.push('Add integration tests for API endpoints');
         return suggestions.slice(0, 3);
-    }
-    prioritizeFiles(coverage, changedFiles) {
-        let targetFiles = coverage.lowestCoverage.map(f => f.path);
+    };
+    CoverageRouter.prototype.prioritizeFiles = function (coverage, changedFiles) {
+        var _this = this;
+        var targetFiles = coverage.lowestCoverage.map(function (f) { return f.path; });
         if (changedFiles && changedFiles.length > 0) {
-            const changedWithLowCoverage = coverage.byFile.filter(f => changedFiles.some(cf => f.path.includes(cf))).filter(f => f.lineCoverage < this.config.targetCoverage).map(f => f.path);
-            targetFiles = [...new Set([...changedWithLowCoverage, ...targetFiles])];
+            var changedWithLowCoverage = coverage.byFile.filter(function (f) { return changedFiles.some(function (cf) { return f.path.includes(cf); }); }).filter(function (f) { return f.lineCoverage < _this.config.targetCoverage; }).map(function (f) { return f.path; });
+            targetFiles = __spreadArray([], new Set(__spreadArray(__spreadArray([], changedWithLowCoverage, true), targetFiles, true)), true);
         }
         return targetFiles.slice(0, 10);
-    }
-    determineAction(coverage, gaps) {
+    };
+    CoverageRouter.prototype.determineAction = function (coverage, gaps) {
         if (coverage.overall < this.config.minCoverage)
             return 'prioritize';
         if (gaps.length > 5)
@@ -235,9 +315,10 @@ export class CoverageRouter {
         if (coverage.overall < this.config.targetCoverage)
             return 'review-coverage';
         return 'skip';
-    }
-    calculatePriority(coverage, changedFiles) {
-        let priority = 5;
+    };
+    CoverageRouter.prototype.calculatePriority = function (coverage, changedFiles) {
+        var _this = this;
+        var priority = 5;
         if (coverage.overall < 50)
             priority += 4;
         else if (coverage.overall < 70)
@@ -246,144 +327,182 @@ export class CoverageRouter {
             priority += 1;
         priority += Math.min(3, coverage.uncoveredCritical.length);
         if (changedFiles && changedFiles.length > 0) {
-            const changedLowCoverage = coverage.byFile.filter(f => changedFiles.some(cf => f.path.includes(cf))).filter(f => f.lineCoverage < this.config.minCoverage);
+            var changedLowCoverage = coverage.byFile.filter(function (f) { return changedFiles.some(function (cf) { return f.path.includes(cf); }); }).filter(function (f) { return f.lineCoverage < _this.config.minCoverage; });
             priority += Math.min(2, changedLowCoverage.length);
         }
         return Math.min(10, priority);
-    }
-    recommendTestTypes(gaps) {
-        const types = new Set(['unit']);
-        for (const gap of gaps) {
+    };
+    CoverageRouter.prototype.recommendTestTypes = function (gaps) {
+        var types = new Set(['unit']);
+        for (var _i = 0, gaps_1 = gaps; _i < gaps_1.length; _i++) {
+            var gap = gaps_1[_i];
             if (/api|endpoint|route|handler|service/.test(gap.file))
                 types.add('integration');
             if (/page|component|view|ui/.test(gap.file))
                 types.add('e2e');
         }
         return Array.from(types);
-    }
-    estimateEffort(gaps) {
-        let effort = 0;
-        for (const gap of gaps)
+    };
+    CoverageRouter.prototype.estimateEffort = function (gaps) {
+        var effort = 0;
+        for (var _i = 0, gaps_2 = gaps; _i < gaps_2.length; _i++) {
+            var gap = gaps_2[_i];
             effort += (gap.gap / 10) * 0.5;
+        }
         return Math.round(effort * 10) / 10;
-    }
-    calculateImpact(coverage, targetFiles) {
-        const potentialGain = targetFiles.reduce((sum, file) => {
-            const fileCov = coverage.byFile.find(f => f.path === file);
-            return fileCov ? sum + (this.config.targetCoverage - fileCov.lineCoverage) : sum;
+    };
+    CoverageRouter.prototype.calculateImpact = function (coverage, targetFiles) {
+        var _this = this;
+        var potentialGain = targetFiles.reduce(function (sum, file) {
+            var fileCov = coverage.byFile.find(function (f) { return f.path === file; });
+            return fileCov ? sum + (_this.config.targetCoverage - fileCov.lineCoverage) : sum;
         }, 0);
         return Math.min(100, Math.round(potentialGain / targetFiles.length || 0));
-    }
-}
+    };
+    return CoverageRouter;
+}());
+export { CoverageRouter };
 export function createCoverageRouter(config) {
     return new CoverageRouter(config);
 }
 /**
  * Route a task based on coverage analysis
  */
-export async function coverageRoute(task, options = {}) {
-    const router = new CoverageRouter({
-        targetCoverage: options.threshold || 80,
+export function coverageRoute(task, options) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var router, coverage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    router = new CoverageRouter({
+                        targetCoverage: options.threshold || 80
+                    });
+                    return [4 /*yield*/, loadProjectCoverage(options.projectRoot)];
+                case 1:
+                    coverage = _a.sent();
+                    if (!coverage) {
+                        return [2 /*return*/, {
+                                action: 'skip',
+                                priority: 1,
+                                targetFiles: [],
+                                testTypes: ['unit'],
+                                gaps: [],
+                                estimatedEffort: 0,
+                                impactScore: 0
+                            }];
+                    }
+                    return [2 /*return*/, router.route(coverage)];
+            }
+        });
     });
-    // Try to load coverage data
-    const coverage = await loadProjectCoverage(options.projectRoot);
-    if (!coverage) {
-        return {
-            action: 'skip',
-            priority: 1,
-            targetFiles: [],
-            testTypes: ['unit'],
-            gaps: [],
-            estimatedEffort: 0,
-            impactScore: 0,
-        };
-    }
-    return router.route(coverage);
 }
 /**
  * Suggest coverage improvements for a path
  */
-export async function coverageSuggest(path, options = {}) {
-    const limit = options.limit || 20;
-    const threshold = options.threshold || 80;
-    const coverage = await loadProjectCoverage(options.projectRoot);
-    if (!coverage) {
-        return {
-            path,
-            suggestions: [],
-            totalGap: 0,
-            estimatedEffort: 0,
-        };
-    }
-    // Filter files matching the path
-    const matchingFiles = coverage.byFile.filter(f => f.path.includes(path));
-    const belowThreshold = matchingFiles.filter(f => f.lineCoverage < threshold);
-    const suggestions = belowThreshold
-        .map(f => ({
-        file: f.path,
-        currentCoverage: f.lineCoverage,
-        targetCoverage: threshold,
-        gap: threshold - f.lineCoverage,
-        priority: calculateFilePriority(f.path, f.lineCoverage, threshold),
-        suggestedTests: suggestTestsForFile(f),
-    }))
-        .sort((a, b) => b.priority - a.priority)
-        .slice(0, limit);
-    const totalGap = suggestions.reduce((sum, s) => sum + s.gap, 0);
-    const estimatedEffort = totalGap * 0.1; // Rough estimate: 0.1 hours per % gap
-    return { path, suggestions, totalGap, estimatedEffort };
+export function coverageSuggest(path, options) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var limit, threshold, coverage, matchingFiles, belowThreshold, suggestions, totalGap, estimatedEffort;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    limit = options.limit || 20;
+                    threshold = options.threshold || 80;
+                    return [4 /*yield*/, loadProjectCoverage(options.projectRoot)];
+                case 1:
+                    coverage = _a.sent();
+                    if (!coverage) {
+                        return [2 /*return*/, {
+                                path: path,
+                                suggestions: [],
+                                totalGap: 0,
+                                estimatedEffort: 0
+                            }];
+                    }
+                    matchingFiles = coverage.byFile.filter(function (f) { return f.path.includes(path); });
+                    belowThreshold = matchingFiles.filter(function (f) { return f.lineCoverage < threshold; });
+                    suggestions = belowThreshold
+                        .map(function (f) { return ({
+                        file: f.path,
+                        currentCoverage: f.lineCoverage,
+                        targetCoverage: threshold,
+                        gap: threshold - f.lineCoverage,
+                        priority: calculateFilePriority(f.path, f.lineCoverage, threshold),
+                        suggestedTests: suggestTestsForFile(f)
+                    }); })
+                        .sort(function (a, b) { return b.priority - a.priority; })
+                        .slice(0, limit);
+                    totalGap = suggestions.reduce(function (sum, s) { return sum + s.gap; }, 0);
+                    estimatedEffort = totalGap * 0.1;
+                    return [2 /*return*/, { path: path, suggestions: suggestions, totalGap: totalGap, estimatedEffort: estimatedEffort }];
+            }
+        });
+    });
 }
 /**
  * List all coverage gaps with agent assignments
  */
-export async function coverageGaps(options = {}) {
-    const threshold = options.threshold || 80;
-    const groupByAgent = options.groupByAgent !== false;
-    const coverage = await loadProjectCoverage(options.projectRoot);
-    if (!coverage) {
-        return {
-            totalGaps: 0,
-            gaps: [],
-            byAgent: {},
-            summary: 'No coverage data found',
-        };
-    }
-    const belowThreshold = coverage.byFile.filter(f => f.lineCoverage < threshold);
-    const gaps = belowThreshold.map(f => ({
-        file: f.path,
-        currentCoverage: f.lineCoverage,
-        targetCoverage: threshold,
-        gap: threshold - f.lineCoverage,
-        priority: calculateFilePriority(f.path, f.lineCoverage, threshold),
-        suggestedAgent: suggestAgentForFile(f.path),
-    }));
-    const byAgent = {};
-    if (groupByAgent) {
-        for (const gap of gaps) {
-            if (!byAgent[gap.suggestedAgent]) {
-                byAgent[gap.suggestedAgent] = [];
+export function coverageGaps(options) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var threshold, groupByAgent, coverage, belowThreshold, gaps, byAgent, _i, gaps_3, gap;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    threshold = options.threshold || 80;
+                    groupByAgent = options.groupByAgent !== false;
+                    return [4 /*yield*/, loadProjectCoverage(options.projectRoot)];
+                case 1:
+                    coverage = _a.sent();
+                    if (!coverage) {
+                        return [2 /*return*/, {
+                                totalGaps: 0,
+                                gaps: [],
+                                byAgent: {},
+                                summary: 'No coverage data found'
+                            }];
+                    }
+                    belowThreshold = coverage.byFile.filter(function (f) { return f.lineCoverage < threshold; });
+                    gaps = belowThreshold.map(function (f) { return ({
+                        file: f.path,
+                        currentCoverage: f.lineCoverage,
+                        targetCoverage: threshold,
+                        gap: threshold - f.lineCoverage,
+                        priority: calculateFilePriority(f.path, f.lineCoverage, threshold),
+                        suggestedAgent: suggestAgentForFile(f.path)
+                    }); });
+                    byAgent = {};
+                    if (groupByAgent) {
+                        for (_i = 0, gaps_3 = gaps; _i < gaps_3.length; _i++) {
+                            gap = gaps_3[_i];
+                            if (!byAgent[gap.suggestedAgent]) {
+                                byAgent[gap.suggestedAgent] = [];
+                            }
+                            byAgent[gap.suggestedAgent].push(gap.file);
+                        }
+                    }
+                    return [2 /*return*/, {
+                            totalGaps: gaps.length,
+                            gaps: gaps,
+                            byAgent: byAgent,
+                            summary: gaps.length + " files below " + threshold + "% coverage threshold"
+                        }];
             }
-            byAgent[gap.suggestedAgent].push(gap.file);
-        }
-    }
-    return {
-        totalGaps: gaps.length,
-        gaps,
-        byAgent,
-        summary: `${gaps.length} files below ${threshold}% coverage threshold`,
-    };
+        });
+    });
 }
 /**
  * Validate and normalize path to prevent directory traversal
  * Returns null if path is invalid or attempts traversal
  */
 function validateProjectPath(inputPath) {
-    const { resolve, normalize, isAbsolute } = require('path');
+    var _a = require('path'), resolve = _a.resolve, normalize = _a.normalize, isAbsolute = _a.isAbsolute;
     // Default to cwd if not provided
-    const basePath = inputPath || process.cwd();
+    var basePath = inputPath || process.cwd();
     // Normalize and resolve the path
-    const normalizedPath = normalize(basePath);
-    const resolvedPath = isAbsolute(normalizedPath) ? normalizedPath : resolve(process.cwd(), normalizedPath);
+    var normalizedPath = normalize(basePath);
+    var resolvedPath = isAbsolute(normalizedPath) ? normalizedPath : resolve(process.cwd(), normalizedPath);
     // Check for path traversal attempts
     if (normalizedPath.includes('..') && !resolvedPath.startsWith(process.cwd())) {
         // Only allow .. if it resolves within or above cwd
@@ -403,69 +522,82 @@ function validateProjectPath(inputPath) {
 /**
  * Load project coverage data (async with caching)
  */
-async function loadProjectCoverage(projectRoot, skipCache) {
-    // Validate and normalize the project root path
-    const root = validateProjectPath(projectRoot);
-    if (!root) {
-        // Invalid path detected, return null safely
-        return null;
-    }
-    // Check cache first
-    if (!skipCache) {
-        const cached = coverageDataCache.get(root);
-        if (cached && Date.now() - cached.timestamp < COVERAGE_CACHE_TTL_MS) {
-            return cached.report;
-        }
-    }
-    const { existsSync } = require('fs');
-    const { readFile } = require('fs/promises');
-    const { join, normalize } = require('path');
-    // Try common coverage locations (all relative to validated root)
-    const coverageLocations = [
-        ['coverage', 'coverage-final.json'],
-        ['coverage', 'lcov.info'],
-        ['.nyc_output', 'coverage.json'],
-        ['coverage.json'],
-    ];
-    for (const pathParts of coverageLocations) {
-        // Join and normalize to prevent traversal in coverage paths
-        const coveragePath = normalize(join(root, ...pathParts));
-        // Ensure the coverage path is still within or under root
-        if (!coveragePath.startsWith(root)) {
-            continue;
-        }
-        if (existsSync(coveragePath)) {
-            try {
-                // Use async file read for non-blocking I/O
-                const content = await readFile(coveragePath, 'utf-8');
-                const router = new CoverageRouter();
-                let report = null;
-                if (coveragePath.endsWith('.json')) {
-                    report = router.parseCoverage(JSON.parse(content), 'istanbul');
-                }
-                else if (coveragePath.endsWith('.info')) {
-                    report = router.parseCoverage(content, 'lcov');
-                }
-                // Cache the result
-                if (report) {
-                    coverageDataCache.set(root, { report, timestamp: Date.now() });
-                    return report;
-                }
-            }
-            catch {
-                // Continue to next path
+function loadProjectCoverage(projectRoot, skipCache) {
+    return __awaiter(this, void 0, Promise, function () {
+        var root, cached, existsSync, readFile, _a, join, normalize, coverageLocations, _i, coverageLocations_1, pathParts, coveragePath, content, router, report, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    root = validateProjectPath(projectRoot);
+                    if (!root) {
+                        // Invalid path detected, return null safely
+                        return [2 /*return*/, null];
+                    }
+                    // Check cache first
+                    if (!skipCache) {
+                        cached = coverageDataCache.get(root);
+                        if (cached && Date.now() - cached.timestamp < COVERAGE_CACHE_TTL_MS) {
+                            return [2 /*return*/, cached.report];
+                        }
+                    }
+                    existsSync = require('fs').existsSync;
+                    readFile = require('fs/promises').readFile;
+                    _a = require('path'), join = _a.join, normalize = _a.normalize;
+                    coverageLocations = [
+                        ['coverage', 'coverage-final.json'],
+                        ['coverage', 'lcov.info'],
+                        ['.nyc_output', 'coverage.json'],
+                        ['coverage.json'],
+                    ];
+                    _i = 0, coverageLocations_1 = coverageLocations;
+                    _c.label = 1;
+                case 1:
+                    if (!(_i < coverageLocations_1.length)) return [3 /*break*/, 6];
+                    pathParts = coverageLocations_1[_i];
+                    coveragePath = normalize(join.apply(void 0, __spreadArray([root], pathParts, false)));
+                    // Ensure the coverage path is still within or under root
+                    if (!coveragePath.startsWith(root)) {
+                        return [3 /*break*/, 5];
+                    }
+                    if (!existsSync(coveragePath)) return [3 /*break*/, 5];
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, readFile(coveragePath, 'utf-8')];
+                case 3:
+                    content = _c.sent();
+                    router = new CoverageRouter();
+                    report = null;
+                    if (coveragePath.endsWith('.json')) {
+                        report = router.parseCoverage(JSON.parse(content), 'istanbul');
+                    }
+                    else if (coveragePath.endsWith('.info')) {
+                        report = router.parseCoverage(content, 'lcov');
+                    }
+                    // Cache the result
+                    if (report) {
+                        coverageDataCache.set(root, { report: report, timestamp: Date.now() });
+                        return [2 /*return*/, report];
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    _b = _c.sent();
+                    return [3 /*break*/, 5];
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 6: return [2 /*return*/, null];
             }
-        }
-    }
-    return null;
+        });
+    });
 }
 /**
  * Calculate priority for a file based on path and coverage
  */
 function calculateFilePriority(path, coverage, threshold) {
-    let priority = 5;
+    var priority = 5;
     // Gap-based priority
-    const gap = threshold - coverage;
+    var gap = threshold - coverage;
     if (gap > 50)
         priority += 3;
     else if (gap > 30)
@@ -473,7 +605,7 @@ function calculateFilePriority(path, coverage, threshold) {
     else if (gap > 15)
         priority += 1;
     // Path-based priority
-    const lowerPath = path.toLowerCase();
+    var lowerPath = path.toLowerCase();
     if (/core|main|index/.test(lowerPath))
         priority += 2;
     if (/auth|security|payment/.test(lowerPath))
@@ -490,7 +622,7 @@ function calculateFilePriority(path, coverage, threshold) {
  * Suggest tests for a file based on its coverage
  */
 function suggestTestsForFile(file) {
-    const suggestions = [];
+    var suggestions = [];
     if (file.uncoveredLines.length > 10) {
         suggestions.push('Add unit tests for uncovered code paths');
     }
@@ -500,7 +632,7 @@ function suggestTestsForFile(file) {
     if (file.functionCoverage < 80) {
         suggestions.push('Add tests for untested functions');
     }
-    const lowerPath = file.path.toLowerCase();
+    var lowerPath = file.path.toLowerCase();
     if (/api|endpoint|route|handler/.test(lowerPath)) {
         suggestions.push('Add integration tests for API endpoints');
     }
@@ -513,7 +645,7 @@ function suggestTestsForFile(file) {
  * Suggest an agent type for a file
  */
 function suggestAgentForFile(path) {
-    const lowerPath = path.toLowerCase();
+    var lowerPath = path.toLowerCase();
     if (/api|endpoint|route|controller/.test(lowerPath))
         return 'api-tester';
     if (/component|view|ui|page/.test(lowerPath))