kynjal-cli 4.0.0 → 4.0.1

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

@@ -6,70 +6,14 @@
  * - 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)
  */
-var coverageDataCache = new Map();
-var COVERAGE_CACHE_TTL_MS = 60 * 1000; // 1 minute
+const coverageDataCache = new Map();
+const COVERAGE_CACHE_TTL_MS = 60 * 1000; // 1 minute
 /**
  * Clear coverage cache
  */
@@ -82,89 +26,74 @@ export function clearCoverageCache() {
 export function getCoverageCacheStats() {
     return { size: coverageDataCache.size };
 }
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     minCoverage: 70,
     targetCoverage: 85,
     incremental: true,
-    coverageTypes: ['line', 'branch', 'function', 'statement']
+    coverageTypes: ['line', 'branch', 'function', 'statement'],
 };
-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'; }
+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') {
         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);
         }
-    };
-    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 () {
+    }
+    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() {
         if (this.coverageHistory.length < 2)
             return { direction: 'stable', change: 0 };
-        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) {
+        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) {
         this.coverageHistory.push(report);
         if (this.coverageHistory.length > 10)
             this.coverageHistory.shift();
-    };
-    CoverageRouter.prototype.getStats = function () {
+    }
+    getStats() {
         return { useNative: this.useNative, historySize: this.coverageHistory.length, minCoverage: this.config.minCoverage, targetCoverage: this.config.targetCoverage };
-    };
-    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];
+    }
+    parseLcov(data) {
+        const files = [];
+        let currentFile = null;
+        const lines = data.split('\n');
+        for (const line of lines) {
             if (line.startsWith('SF:')) {
-                if (currentFile === null || currentFile === void 0 ? void 0 : currentFile.path)
+                if (currentFile?.path)
                     files.push(this.finalizeFileCoverage(currentFile));
                 currentFile = { path: line.substring(3), uncoveredLines: [], totalLines: 0, coveredLines: 0 };
             }
@@ -177,95 +106,88 @@ var CoverageRouter = /** @class */ (function () {
                     currentFile.coveredLines = parseInt(line.substring(3), 10);
             }
             else if (line.startsWith('DA:')) {
-                var _b = line.substring(3).split(',').map(Number), lineNum = _b[0], hits = _b[1];
+                const [lineNum, hits] = line.substring(3).split(',').map(Number);
                 if (currentFile && hits === 0)
-                    (_a = currentFile.uncoveredLines) === null || _a === void 0 ? void 0 : _a.push(lineNum);
+                    currentFile.uncoveredLines?.push(lineNum);
             }
             else if (line === 'end_of_record') {
-                if (currentFile === null || currentFile === void 0 ? void 0 : currentFile.path)
+                if (currentFile?.path)
                     files.push(this.finalizeFileCoverage(currentFile));
                 currentFile = null;
             }
         }
         return this.buildReport(files);
-    };
-    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;
+    }
+    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;
             files.push({
-                path: path,
-                lineCoverage: statementTotal > 0 ? (statementCovered / statementTotal) * 100 : 100,
+                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);
-    };
-    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];
+    }
+    parseCobertura(data) {
+        const files = [];
+        const classMatches = data.matchAll(/<class[^>]*filename="([^"]+)"[^>]*line-rate="([^"]+)"[^>]*branch-rate="([^"]+)"[^>]*>/g);
+        for (const match of classMatches) {
             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);
-    };
-    CoverageRouter.prototype.parseJson = function (data) {
+    }
+    parseJson(data) {
         if (Array.isArray(data))
             return this.buildReport(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;
+        const files = [];
+        for (const [path, coverage] of Object.entries(data)) {
+            const cov = coverage;
             files.push({
-                path: path,
-                lineCoverage: cov.lineCoverage || 0, branchCoverage: cov.branchCoverage || 0,
+                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);
-    };
-    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];
+    }
+    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) {
             if (file.lineCoverage < this.config.minCoverage) {
-                for (var _a = 0, criticalPatterns_1 = criticalPatterns; _a < criticalPatterns_1.length; _a++) {
-                    var pattern = criticalPatterns_1[_a];
+                for (const pattern of criticalPatterns) {
                     if (pattern.test(file.path)) {
                         critical.push(file.path);
                         break;
@@ -274,20 +196,19 @@ var CoverageRouter = /** @class */ (function () {
             }
         }
         return critical.slice(0, 10);
-    };
-    CoverageRouter.prototype.calculateGaps = function (coverage) {
-        var gaps = [];
-        for (var _i = 0, _a = coverage.byFile; _i < _a.length; _i++) {
-            var file = _a[_i];
+    }
+    calculateGaps(coverage) {
+        const gaps = [];
+        for (const file of coverage.byFile) {
             if (file.lineCoverage < this.config.targetCoverage) {
-                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) });
+                const gap = this.config.targetCoverage - file.lineCoverage;
+                gaps.push({ file: file.path, currentCoverage: file.lineCoverage, targetCoverage: this.config.targetCoverage, gap, suggestedTests: this.suggestTests(file) });
             }
         }
-        return gaps.sort(function (a, b) { return b.gap - a.gap; }).slice(0, 10);
-    };
-    CoverageRouter.prototype.suggestTests = function (file) {
-        var suggestions = [];
+        return gaps.sort((a, b) => b.gap - a.gap).slice(0, 10);
+    }
+    suggestTests(file) {
+        const suggestions = [];
         if (file.uncoveredLines.length > 10)
             suggestions.push('Add unit tests for uncovered code paths');
         if (file.branchCoverage < 50)
@@ -297,17 +218,16 @@ var CoverageRouter = /** @class */ (function () {
         if (/api|endpoint|route|handler/.test(file.path))
             suggestions.push('Add integration tests for API endpoints');
         return suggestions.slice(0, 3);
-    };
-    CoverageRouter.prototype.prioritizeFiles = function (coverage, changedFiles) {
-        var _this = this;
-        var targetFiles = coverage.lowestCoverage.map(function (f) { return f.path; });
+    }
+    prioritizeFiles(coverage, changedFiles) {
+        let targetFiles = coverage.lowestCoverage.map(f => f.path);
         if (changedFiles && changedFiles.length > 0) {
-            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);
+            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])];
         }
         return targetFiles.slice(0, 10);
-    };
-    CoverageRouter.prototype.determineAction = function (coverage, gaps) {
+    }
+    determineAction(coverage, gaps) {
         if (coverage.overall < this.config.minCoverage)
             return 'prioritize';
         if (gaps.length > 5)
@@ -315,10 +235,9 @@ var CoverageRouter = /** @class */ (function () {
         if (coverage.overall < this.config.targetCoverage)
             return 'review-coverage';
         return 'skip';
-    };
-    CoverageRouter.prototype.calculatePriority = function (coverage, changedFiles) {
-        var _this = this;
-        var priority = 5;
+    }
+    calculatePriority(coverage, changedFiles) {
+        let priority = 5;
         if (coverage.overall < 50)
             priority += 4;
         else if (coverage.overall < 70)
@@ -327,182 +246,144 @@ var CoverageRouter = /** @class */ (function () {
             priority += 1;
         priority += Math.min(3, coverage.uncoveredCritical.length);
         if (changedFiles && changedFiles.length > 0) {
-            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; });
+            const changedLowCoverage = coverage.byFile.filter(f => changedFiles.some(cf => f.path.includes(cf))).filter(f => f.lineCoverage < this.config.minCoverage);
             priority += Math.min(2, changedLowCoverage.length);
         }
         return Math.min(10, priority);
-    };
-    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];
+    }
+    recommendTestTypes(gaps) {
+        const types = new Set(['unit']);
+        for (const gap of gaps) {
             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);
-    };
-    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];
+    }
+    estimateEffort(gaps) {
+        let effort = 0;
+        for (const gap of gaps)
             effort += (gap.gap / 10) * 0.5;
-        }
         return Math.round(effort * 10) / 10;
-    };
-    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;
+    }
+    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;
         }, 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 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)];
-            }
-        });
+export async function coverageRoute(task, options = {}) {
+    const router = new CoverageRouter({
+        targetCoverage: options.threshold || 80,
     });
+    // 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 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 }];
-            }
-        });
-    });
+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 };
 }
 /**
  * List all coverage gaps with agent assignments
  */
-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"
-                        }];
+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] = [];
             }
-        });
-    });
+            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) {
-    var _a = require('path'), resolve = _a.resolve, normalize = _a.normalize, isAbsolute = _a.isAbsolute;
+    const { resolve, normalize, isAbsolute } = require('path');
     // Default to cwd if not provided
-    var basePath = inputPath || process.cwd();
+    const basePath = inputPath || process.cwd();
     // Normalize and resolve the path
-    var normalizedPath = normalize(basePath);
-    var resolvedPath = isAbsolute(normalizedPath) ? normalizedPath : resolve(process.cwd(), normalizedPath);
+    const normalizedPath = normalize(basePath);
+    const 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
@@ -522,82 +403,69 @@ function validateProjectPath(inputPath) {
 /**
  * Load project coverage data (async with caching)
  */
-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];
+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
+            }
+        }
+    }
+    return null;
 }
 /**
  * Calculate priority for a file based on path and coverage
  */
 function calculateFilePriority(path, coverage, threshold) {
-    var priority = 5;
+    let priority = 5;
     // Gap-based priority
-    var gap = threshold - coverage;
+    const gap = threshold - coverage;
     if (gap > 50)
         priority += 3;
     else if (gap > 30)
@@ -605,7 +473,7 @@ function calculateFilePriority(path, coverage, threshold) {
     else if (gap > 15)
         priority += 1;
     // Path-based priority
-    var lowerPath = path.toLowerCase();
+    const lowerPath = path.toLowerCase();
     if (/core|main|index/.test(lowerPath))
         priority += 2;
     if (/auth|security|payment/.test(lowerPath))
@@ -622,7 +490,7 @@ function calculateFilePriority(path, coverage, threshold) {
  * Suggest tests for a file based on its coverage
  */
 function suggestTestsForFile(file) {
-    var suggestions = [];
+    const suggestions = [];
     if (file.uncoveredLines.length > 10) {
         suggestions.push('Add unit tests for uncovered code paths');
     }
@@ -632,7 +500,7 @@ function suggestTestsForFile(file) {
     if (file.functionCoverage < 80) {
         suggestions.push('Add tests for untested functions');
     }
-    var lowerPath = file.path.toLowerCase();
+    const lowerPath = file.path.toLowerCase();
     if (/api|endpoint|route|handler/.test(lowerPath)) {
         suggestions.push('Add integration tests for API endpoints');
     }
@@ -645,7 +513,7 @@ function suggestTestsForFile(file) {
  * Suggest an agent type for a file
  */
 function suggestAgentForFile(path) {
-    var lowerPath = path.toLowerCase();
+    const lowerPath = path.toLowerCase();
     if (/api|endpoint|route|controller/.test(lowerPath))
         return 'api-tester';
     if (/component|view|ui|page/.test(lowerPath))