kynjal-cli 4.0.0 → 4.0.1

package/dist/src/ruvector/diff-classifier.js

@@ -1,253 +1,174 @@
 /**
  * Diff Classifier for Change Analysis
  */
-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));
-};
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     maxDiffSize: 10000,
     classifyByImpact: true,
     detectRefactoring: true,
-    minConfidence: 0.5
+    minConfidence: 0.5,
 };
-var CLASSIFICATION_PATTERNS = {
+const CLASSIFICATION_PATTERNS = {
     feature: [/^feat/, /add.*feature/, /implement/, /new.*functionality/i],
     bugfix: [/^fix/, /bug/, /patch/, /resolve.*issue/i, /hotfix/i],
     refactor: [/^refactor/, /restructure/, /reorganize/, /cleanup/i, /rename/i],
     docs: [/^docs?/, /documentation/, /readme/i, /comment/i, /\.md$/i],
     test: [/^test/, /spec/, /\.test\.[jt]sx?$/, /\.spec\.[jt]sx?$/, /__tests__/],
     config: [/^config/, /\.config\./, /package\.json/, /tsconfig/, /\.env/],
-    style: [/^style/, /format/, /lint/, /prettier/, /eslint/]
+    style: [/^style/, /format/, /lint/, /prettier/, /eslint/],
 };
-var IMPACT_KEYWORDS = {
+const IMPACT_KEYWORDS = {
     security: 3, auth: 3, payment: 3, database: 2, api: 2, core: 2,
-    util: 1, helper: 1, test: 0, mock: 0, fixture: 0
+    util: 1, helper: 1, test: 0, mock: 0, fixture: 0,
 };
-var DiffClassifier = /** @class */ (function () {
-    function DiffClassifier(config) {
-        if (config === void 0) { config = {}; }
-        this.ruvectorEngine = null;
-        this.useNative = false;
-        this.classificationCache = new Map();
-        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
-    }
-    DiffClassifier.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/diff')["catch"](function () { return null; })];
-                    case 1:
-                        ruvector = _d.sent();
-                        if (ruvector) {
-                            this.ruvectorEngine = (_b = (_a = ruvector).createDiffClassifier) === 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*/];
-                }
-            });
-        });
-    };
-    DiffClassifier.prototype.parseDiff = function (diffContent) {
-        var files = [];
-        var fileBlocks = diffContent.split(/^diff --git/m).filter(Boolean);
-        for (var _i = 0, fileBlocks_1 = fileBlocks; _i < fileBlocks_1.length; _i++) {
-            var block = fileBlocks_1[_i];
-            var pathMatch = block.match(/a\/(.+?)\s+b\/(.+)/);
+export class DiffClassifier {
+    config;
+    ruvectorEngine = null;
+    useNative = false;
+    classificationCache = new Map();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    async initialize() {
+        try {
+            // @ruvector/diff is optional - gracefully fallback if not installed
+            const ruvector = await import('@ruvector/diff').catch(() => null);
+            if (ruvector) {
+                this.ruvectorEngine = ruvector.createDiffClassifier?.(this.config);
+                this.useNative = !!this.ruvectorEngine;
+            }
+        }
+        catch {
+            this.useNative = false;
+        }
+    }
+    parseDiff(diffContent) {
+        const files = [];
+        const fileBlocks = diffContent.split(/^diff --git/m).filter(Boolean);
+        for (const block of fileBlocks) {
+            const pathMatch = block.match(/a\/(.+?)\s+b\/(.+)/);
             if (!pathMatch)
                 continue;
-            var path = pathMatch[2];
-            var hunks = this.parseHunks(block);
-            var additions = hunks.reduce(function (sum, h) { return sum + h.changes.filter(function (c) { return c.type === 'add'; }).length; }, 0);
-            var deletions = hunks.reduce(function (sum, h) { return sum + h.changes.filter(function (c) { return c.type === 'remove'; }).length; }, 0);
-            var classification = this.classifyFile(path, hunks);
-            files.push({ path: path, hunks: hunks, additions: additions, deletions: deletions, classification: classification });
+            const path = pathMatch[2];
+            const hunks = this.parseHunks(block);
+            const additions = hunks.reduce((sum, h) => sum + h.changes.filter(c => c.type === 'add').length, 0);
+            const deletions = hunks.reduce((sum, h) => sum + h.changes.filter(c => c.type === 'remove').length, 0);
+            const classification = this.classifyFile(path, hunks);
+            files.push({ path, hunks, additions, deletions, classification });
         }
         return files;
-    };
-    DiffClassifier.prototype.classify = function (files) {
-        var overall = this.computeOverallClassification(files);
-        var stats = {
-            totalAdditions: files.reduce(function (sum, f) { return sum + f.additions; }, 0),
-            totalDeletions: files.reduce(function (sum, f) { return sum + f.deletions; }, 0),
+    }
+    classify(files) {
+        const overall = this.computeOverallClassification(files);
+        const stats = {
+            totalAdditions: files.reduce((sum, f) => sum + f.additions, 0),
+            totalDeletions: files.reduce((sum, f) => sum + f.deletions, 0),
             filesChanged: files.length,
-            avgConfidence: files.length > 0 ? files.reduce(function (sum, f) { return sum + f.classification.confidence; }, 0) / files.length : 0
+            avgConfidence: files.length > 0 ? files.reduce((sum, f) => sum + f.classification.confidence, 0) / files.length : 0,
         };
-        return { files: files, overall: overall, stats: stats, timestamp: Date.now() };
-    };
-    DiffClassifier.prototype.classifyCommitMessage = function (message) {
-        var lowerMessage = message.toLowerCase();
-        for (var _i = 0, _a = Object.entries(CLASSIFICATION_PATTERNS); _i < _a.length; _i++) {
-            var _b = _a[_i], type = _b[0], patterns = _b[1];
-            for (var _c = 0, patterns_1 = patterns; _c < patterns_1.length; _c++) {
-                var pattern = patterns_1[_c];
+        return { files, overall, stats, timestamp: Date.now() };
+    }
+    classifyCommitMessage(message) {
+        const lowerMessage = message.toLowerCase();
+        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
+            for (const pattern of patterns) {
                 if (pattern.test(lowerMessage))
                     return type;
             }
         }
         return 'unknown';
-    };
-    DiffClassifier.prototype.getStats = function () {
+    }
+    getStats() {
         return { useNative: this.useNative, cacheSize: this.classificationCache.size };
-    };
-    DiffClassifier.prototype.clearCache = function () { this.classificationCache.clear(); };
-    DiffClassifier.prototype.parseHunks = function (block) {
-        var hunks = [];
-        var hunkMatches = block.matchAll(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@([^\n]*)\n([\s\S]*?)(?=@@|$)/g);
-        for (var _i = 0, hunkMatches_1 = hunkMatches; _i < hunkMatches_1.length; _i++) {
-            var match = hunkMatches_1[_i];
-            var oldStart = parseInt(match[1], 10);
-            var oldLines = parseInt(match[2] || '1', 10);
-            var newStart = parseInt(match[3], 10);
-            var newLines = parseInt(match[4] || '1', 10);
-            var content = match[6] || '';
-            var changes = this.parseChanges(content, newStart);
-            hunks.push({ oldStart: oldStart, oldLines: oldLines, newStart: newStart, newLines: newLines, content: content, changes: changes });
+    }
+    clearCache() { this.classificationCache.clear(); }
+    parseHunks(block) {
+        const hunks = [];
+        const hunkMatches = block.matchAll(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@([^\n]*)\n([\s\S]*?)(?=@@|$)/g);
+        for (const match of hunkMatches) {
+            const oldStart = parseInt(match[1], 10);
+            const oldLines = parseInt(match[2] || '1', 10);
+            const newStart = parseInt(match[3], 10);
+            const newLines = parseInt(match[4] || '1', 10);
+            const content = match[6] || '';
+            const changes = this.parseChanges(content, newStart);
+            hunks.push({ oldStart, oldLines, newStart, newLines, content, changes });
         }
         return hunks;
-    };
-    DiffClassifier.prototype.parseChanges = function (content, startLine) {
-        var changes = [];
-        var lines = content.split('\n');
-        var lineNumber = startLine;
-        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
-            var line = lines_1[_i];
+    }
+    parseChanges(content, startLine) {
+        const changes = [];
+        const lines = content.split('\n');
+        let lineNumber = startLine;
+        for (const line of lines) {
             if (line.startsWith('+')) {
-                changes.push({ type: 'add', lineNumber: lineNumber, content: line.substring(1) });
+                changes.push({ type: 'add', lineNumber, content: line.substring(1) });
                 lineNumber++;
             }
             else if (line.startsWith('-')) {
                 changes.push({ type: 'remove', lineNumber: -1, content: line.substring(1) });
             }
             else if (line.startsWith(' ') || line === '') {
-                changes.push({ type: 'context', lineNumber: lineNumber, content: line.substring(1) || '' });
+                changes.push({ type: 'context', lineNumber, content: line.substring(1) || '' });
                 lineNumber++;
             }
         }
         return changes;
-    };
-    DiffClassifier.prototype.classifyFile = function (path, hunks) {
-        var cacheKey = this.getCacheKey(path, hunks);
-        var cached = this.classificationCache.get(cacheKey);
+    }
+    classifyFile(path, hunks) {
+        const cacheKey = this.getCacheKey(path, hunks);
+        const cached = this.classificationCache.get(cacheKey);
         if (cached)
             return cached;
-        var primary = this.determinePrimaryClassification(path, hunks);
-        var secondary = this.determineSecondaryClassifications(path, hunks, primary);
-        var confidence = this.calculateConfidence(path, hunks, primary);
-        var impactLevel = this.determineImpactLevel(path, hunks);
-        var suggestedReviewers = this.suggestReviewers(path, primary, impactLevel);
-        var testingStrategy = this.determineTestingStrategy(path, primary, impactLevel);
-        var riskFactors = this.identifyRiskFactors(path, hunks, impactLevel);
-        var classification = { primary: primary, secondary: secondary, confidence: confidence, impactLevel: impactLevel, suggestedReviewers: suggestedReviewers, testingStrategy: testingStrategy, riskFactors: riskFactors };
+        const primary = this.determinePrimaryClassification(path, hunks);
+        const secondary = this.determineSecondaryClassifications(path, hunks, primary);
+        const confidence = this.calculateConfidence(path, hunks, primary);
+        const impactLevel = this.determineImpactLevel(path, hunks);
+        const suggestedReviewers = this.suggestReviewers(path, primary, impactLevel);
+        const testingStrategy = this.determineTestingStrategy(path, primary, impactLevel);
+        const riskFactors = this.identifyRiskFactors(path, hunks, impactLevel);
+        const classification = { primary, secondary, confidence, impactLevel, suggestedReviewers, testingStrategy, riskFactors };
         this.classificationCache.set(cacheKey, classification);
         return classification;
-    };
-    DiffClassifier.prototype.getCacheKey = function (path, hunks) {
-        var hunkSummary = hunks.map(function (h) { return h.oldStart + ':' + h.newStart; }).join(',');
+    }
+    getCacheKey(path, hunks) {
+        const hunkSummary = hunks.map(h => h.oldStart + ':' + h.newStart).join(',');
         return path + ':' + hunkSummary;
-    };
-    DiffClassifier.prototype.determinePrimaryClassification = function (path, hunks) {
-        for (var _i = 0, _a = Object.entries(CLASSIFICATION_PATTERNS); _i < _a.length; _i++) {
-            var _b = _a[_i], type = _b[0], patterns = _b[1];
-            for (var _c = 0, patterns_2 = patterns; _c < patterns_2.length; _c++) {
-                var pattern = patterns_2[_c];
+    }
+    determinePrimaryClassification(path, hunks) {
+        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
+            for (const pattern of patterns) {
                 if (pattern.test(path))
                     return type;
             }
         }
-        var allContent = hunks.flatMap(function (h) { return h.changes.map(function (c) { return c.content; }); }).join('\n').toLowerCase();
-        if (/function|class|interface|type\s+\w+/.test(allContent) && hunks.some(function (h) { return h.changes.filter(function (c) { return c.type === 'add'; }).length > 10; }))
+        const allContent = hunks.flatMap(h => h.changes.map(c => c.content)).join('\n').toLowerCase();
+        if (/function|class|interface|type\s+\w+/.test(allContent) && hunks.some(h => h.changes.filter(c => c.type === 'add').length > 10))
             return 'feature';
         if (/fix|bug|issue|error|exception/.test(allContent))
             return 'bugfix';
         if (this.config.detectRefactoring && this.isRefactoring(hunks))
             return 'refactor';
         return 'unknown';
-    };
-    DiffClassifier.prototype.isRefactoring = function (hunks) {
-        var totalAdds = 0, totalRemoves = 0;
-        for (var _i = 0, hunks_1 = hunks; _i < hunks_1.length; _i++) {
-            var hunk = hunks_1[_i];
-            for (var _a = 0, _b = hunk.changes; _a < _b.length; _a++) {
-                var change = _b[_a];
+    }
+    isRefactoring(hunks) {
+        let totalAdds = 0, totalRemoves = 0;
+        for (const hunk of hunks) {
+            for (const change of hunk.changes) {
                 if (change.type === 'add')
                     totalAdds++;
                 else if (change.type === 'remove')
                     totalRemoves++;
             }
         }
-        var ratio = totalAdds > 0 ? totalRemoves / totalAdds : 0;
+        const ratio = totalAdds > 0 ? totalRemoves / totalAdds : 0;
         return ratio > 0.7 && ratio < 1.4 && totalAdds > 5;
-    };
-    DiffClassifier.prototype.determineSecondaryClassifications = function (path, hunks, primary) {
-        var secondary = [];
-        for (var _i = 0, _a = Object.entries(CLASSIFICATION_PATTERNS); _i < _a.length; _i++) {
-            var _b = _a[_i], type = _b[0], patterns = _b[1];
+    }
+    determineSecondaryClassifications(path, hunks, primary) {
+        const secondary = [];
+        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
             if (type === primary)
                 continue;
-            for (var _c = 0, patterns_3 = patterns; _c < patterns_3.length; _c++) {
-                var pattern = patterns_3[_c];
+            for (const pattern of patterns) {
                 if (pattern.test(path)) {
                     secondary.push(type);
                     break;
@@ -255,20 +176,18 @@ var DiffClassifier = /** @class */ (function () {
             }
         }
         return secondary.slice(0, 3);
-    };
-    DiffClassifier.prototype.calculateConfidence = function (path, hunks, primary) {
-        var confidence = 0.5;
-        for (var _i = 0, _a = Object.values(CLASSIFICATION_PATTERNS); _i < _a.length; _i++) {
-            var patterns = _a[_i];
-            for (var _b = 0, patterns_4 = patterns; _b < patterns_4.length; _b++) {
-                var pattern = patterns_4[_b];
+    }
+    calculateConfidence(path, hunks, primary) {
+        let confidence = 0.5;
+        for (const patterns of Object.values(CLASSIFICATION_PATTERNS)) {
+            for (const pattern of patterns) {
                 if (pattern.test(path)) {
                     confidence += 0.2;
                     break;
                 }
             }
         }
-        var totalChanges = hunks.reduce(function (sum, h) { return sum + h.changes.length; }, 0);
+        const totalChanges = hunks.reduce((sum, h) => sum + h.changes.length, 0);
         if (totalChanges > 10)
             confidence += 0.1;
         if (totalChanges > 50)
@@ -276,16 +195,15 @@ var DiffClassifier = /** @class */ (function () {
         if (primary !== 'unknown')
             confidence += 0.1;
         return Math.min(1, confidence);
-    };
-    DiffClassifier.prototype.determineImpactLevel = function (path, hunks) {
-        var score = 0;
-        var lowerPath = path.toLowerCase();
-        for (var _i = 0, _a = Object.entries(IMPACT_KEYWORDS); _i < _a.length; _i++) {
-            var _b = _a[_i], keyword = _b[0], weight = _b[1];
+    }
+    determineImpactLevel(path, hunks) {
+        let score = 0;
+        const lowerPath = path.toLowerCase();
+        for (const [keyword, weight] of Object.entries(IMPACT_KEYWORDS)) {
             if (lowerPath.includes(keyword))
                 score = Math.max(score, weight);
         }
-        var totalChanges = hunks.reduce(function (sum, h) { return sum + h.changes.filter(function (c) { return c.type !== 'context'; }).length; }, 0);
+        const totalChanges = hunks.reduce((sum, h) => sum + h.changes.filter(c => c.type !== 'context').length, 0);
         if (totalChanges > 100)
             score = Math.max(score, 2);
         if (totalChanges > 300)
@@ -297,21 +215,21 @@ var DiffClassifier = /** @class */ (function () {
         if (score >= 1)
             return 'medium';
         return 'low';
-    };
-    DiffClassifier.prototype.suggestReviewers = function (path, primary, impact) {
-        var reviewers = [];
-        var typeReviewers = { feature: ['tech-lead', 'product-owner'], bugfix: ['qa-engineer', 'developer'], refactor: ['senior-developer', 'architect'], docs: ['tech-writer', 'developer'], test: ['qa-engineer', 'developer'], config: ['devops', 'tech-lead'], style: ['developer'], unknown: ['developer'] };
-        reviewers.push.apply(reviewers, (typeReviewers[primary] || typeReviewers.unknown));
+    }
+    suggestReviewers(path, primary, impact) {
+        const reviewers = [];
+        const typeReviewers = { feature: ['tech-lead', 'product-owner'], bugfix: ['qa-engineer', 'developer'], refactor: ['senior-developer', 'architect'], docs: ['tech-writer', 'developer'], test: ['qa-engineer', 'developer'], config: ['devops', 'tech-lead'], style: ['developer'], unknown: ['developer'] };
+        reviewers.push(...(typeReviewers[primary] || typeReviewers.unknown));
         if (impact === 'critical' || impact === 'high')
             reviewers.push('security-reviewer');
         if (/security|auth/.test(path))
             reviewers.push('security-team');
         if (/database|migration/.test(path))
             reviewers.push('dba');
-        return __spreadArray([], new Set(reviewers), true).slice(0, 4);
-    };
-    DiffClassifier.prototype.determineTestingStrategy = function (path, primary, impact) {
-        var strategies = [];
+        return [...new Set(reviewers)].slice(0, 4);
+    }
+    determineTestingStrategy(path, primary, impact) {
+        const strategies = [];
         if (primary !== 'test')
             strategies.push('unit-tests');
         if (primary === 'feature')
@@ -325,10 +243,10 @@ var DiffClassifier = /** @class */ (function () {
         if (/security|auth|crypto/.test(path))
             strategies.push('security-audit');
         return strategies.slice(0, 5);
-    };
-    DiffClassifier.prototype.identifyRiskFactors = function (path, hunks, impact) {
-        var risks = [];
-        var totalChanges = hunks.reduce(function (sum, h) { return sum + h.changes.length; }, 0);
+    }
+    identifyRiskFactors(path, hunks, impact) {
+        const risks = [];
+        const totalChanges = hunks.reduce((sum, h) => sum + h.changes.length, 0);
         if (totalChanges > 200)
             risks.push('Large change set - increased review time needed');
         if (impact === 'critical')
@@ -341,59 +259,49 @@ var DiffClassifier = /** @class */ (function () {
             risks.push('Database changes - ensure backup strategy');
         if (/config|env/.test(path))
             risks.push('Configuration changes - verify all environments');
-        var allContent = hunks.flatMap(function (h) { return h.changes.map(function (c) { return c.content; }); }).join('\n');
+        const allContent = hunks.flatMap(h => h.changes.map(c => c.content)).join('\n');
         if (/TODO|FIXME|HACK/.test(allContent))
             risks.push('Contains TODO/FIXME comments');
         if (/password|secret|key|token/i.test(allContent))
             risks.push('Potential secrets in code');
         return risks.slice(0, 5);
-    };
-    DiffClassifier.prototype.computeOverallClassification = function (files) {
+    }
+    computeOverallClassification(files) {
         if (files.length === 0)
             return { primary: 'unknown', secondary: [], confidence: 0, impactLevel: 'low', suggestedReviewers: [], testingStrategy: [], riskFactors: [] };
-        var primaryCounts = {};
-        for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
-            var file = files_1[_i];
-            var p = file.classification.primary;
+        const primaryCounts = {};
+        for (const file of files) {
+            const p = file.classification.primary;
             primaryCounts[p] = (primaryCounts[p] || 0) + 1;
         }
-        var primary = 'unknown';
-        var maxCount = 0;
-        for (var _a = 0, _b = Object.entries(primaryCounts); _a < _b.length; _a++) {
-            var _c = _b[_a], type = _c[0], count = _c[1];
+        let primary = 'unknown';
+        let maxCount = 0;
+        for (const [type, count] of Object.entries(primaryCounts)) {
             if (count > maxCount) {
                 maxCount = count;
                 primary = type;
             }
         }
-        var secondaryCounts = {};
-        for (var _d = 0, files_2 = files; _d < files_2.length; _d++) {
-            var file = files_2[_d];
-            for (var _e = 0, _f = file.classification.secondary; _e < _f.length; _e++) {
-                var s = _f[_e];
+        const secondaryCounts = {};
+        for (const file of files) {
+            for (const s of file.classification.secondary) {
                 secondaryCounts[s] = (secondaryCounts[s] || 0) + 1;
             }
         }
-        var secondary = Object.entries(secondaryCounts).sort(function (a, b) { return b[1] - a[1]; }).slice(0, 3).map(function (_a) {
-            var type = _a[0];
-            return type;
-        });
-        var confidence = files.reduce(function (sum, f) { return sum + f.classification.confidence; }, 0) / files.length;
-        var impactOrder = ['low', 'medium', 'high', 'critical'];
-        var impactLevel = 'low';
-        for (var _g = 0, files_3 = files; _g < files_3.length; _g++) {
-            var file = files_3[_g];
+        const secondary = Object.entries(secondaryCounts).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([type]) => type);
+        const confidence = files.reduce((sum, f) => sum + f.classification.confidence, 0) / files.length;
+        const impactOrder = ['low', 'medium', 'high', 'critical'];
+        let impactLevel = 'low';
+        for (const file of files) {
             if (impactOrder.indexOf(file.classification.impactLevel) > impactOrder.indexOf(impactLevel))
                 impactLevel = file.classification.impactLevel;
         }
-        var reviewers = __spreadArray([], new Set(files.flatMap(function (f) { return f.classification.suggestedReviewers; })), true).slice(0, 5);
-        var testingStrategy = __spreadArray([], new Set(files.flatMap(function (f) { return f.classification.testingStrategy; })), true).slice(0, 5);
-        var riskFactors = __spreadArray([], new Set(files.flatMap(function (f) { return f.classification.riskFactors; })), true).slice(0, 5);
-        return { primary: primary, secondary: secondary, confidence: confidence, impactLevel: impactLevel, suggestedReviewers: reviewers, testingStrategy: testingStrategy, riskFactors: riskFactors };
-    };
-    return DiffClassifier;
-}());
-export { DiffClassifier };
+        const reviewers = [...new Set(files.flatMap(f => f.classification.suggestedReviewers))].slice(0, 5);
+        const testingStrategy = [...new Set(files.flatMap(f => f.classification.testingStrategy))].slice(0, 5);
+        const riskFactors = [...new Set(files.flatMap(f => f.classification.riskFactors))].slice(0, 5);
+        return { primary, secondary, confidence, impactLevel, suggestedReviewers: reviewers, testingStrategy, riskFactors };
+    }
+}
 export function createDiffClassifier(config) {
     return new DiffClassifier(config);
 }
@@ -401,8 +309,8 @@ export function createDiffClassifier(config) {
 // Optimized Git Diff Functions
 // ============================================================================
 // Cache for diff results (TTL-based)
-var diffCache = new Map();
-var CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequently
+const diffCache = new Map();
+const CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequently
 /**
  * Validate git ref to prevent command injection
  * Only allows safe characters: alphanumeric, -, _, /, ., ~, ^
@@ -410,73 +318,70 @@ var CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequently
 function validateGitRef(ref) {
     // Block shell metacharacters and dangerous patterns
     if (!/^[a-zA-Z0-9_\-./~^@]+$/.test(ref)) {
-        throw new Error("Invalid git ref: contains unsafe characters");
+        throw new Error(`Invalid git ref: contains unsafe characters`);
     }
     // Block multiple dots (path traversal)
     if (ref.includes('..') && !ref.match(/^[a-zA-Z0-9_\-]+\.\.\.?[a-zA-Z0-9_\-]+$/)) {
         if (!/^\w+\.\.[.\w]+$/.test(ref)) {
-            throw new Error("Invalid git ref: suspicious pattern");
+            throw new Error(`Invalid git ref: suspicious pattern`);
         }
     }
     // Max length check
     if (ref.length > 256) {
-        throw new Error("Invalid git ref: too long");
+        throw new Error(`Invalid git ref: too long`);
     }
 }
 /**
  * Get git diff statistics using SINGLE combined command (optimized)
  * Replaces two separate git commands with one
  */
-export function getGitDiffNumstat(ref) {
-    if (ref === void 0) { ref = 'HEAD'; }
+export function getGitDiffNumstat(ref = 'HEAD') {
     // SECURITY: Validate git ref to prevent command injection
     validateGitRef(ref);
     // Check cache first
-    var cacheKey = "numstat:" + ref;
-    var cached = diffCache.get(cacheKey);
+    const cacheKey = `numstat:${ref}`;
+    const cached = diffCache.get(cacheKey);
     if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
         return cached.files;
     }
-    var execFileSync = require('child_process').execFileSync;
+    const { execFileSync } = require('child_process');
     try {
         // SECURITY: Use execFileSync with args array instead of shell string
         // This prevents command injection via the ref parameter
-        var numstatOutput = execFileSync('git', [
+        const numstatOutput = execFileSync('git', [
             'diff', '--numstat', '--diff-filter=ACDMRTUXB', ref
         ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        var statusOutput = execFileSync('git', [
+        const statusOutput = execFileSync('git', [
             'diff', '--name-status', ref
         ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        var output = numstatOutput + '---STATUS---' + statusOutput;
-        var _a = output.split('---STATUS---'), numstatPart = _a[0], statusPart = _a[1];
+        const output = numstatOutput + '---STATUS---' + statusOutput;
+        const [numstatPart, statusPart] = output.split('---STATUS---');
         // Parse status (usually smaller, parse first)
-        var statusMap = new Map();
+        const statusMap = new Map();
         if (statusPart) {
-            for (var _i = 0, _b = statusPart.trim().split('\n'); _i < _b.length; _i++) {
-                var line = _b[_i];
+            for (const line of statusPart.trim().split('\n')) {
                 if (!line)
                     continue;
-                var _c = line.split('\t'), status = _c[0], pathParts = _c.slice(1);
-                var path = pathParts[pathParts.length - 1] || pathParts[0];
+                const [status, ...pathParts] = line.split('\t');
+                const path = pathParts[pathParts.length - 1] || pathParts[0];
                 if (path)
                     statusMap.set(path, status.charAt(0));
             }
         }
         // Parse numstat
-        var files = [];
+        const files = [];
         if (numstatPart) {
-            for (var _d = 0, _e = numstatPart.trim().split('\n'); _d < _e.length; _d++) {
-                var line = _e[_d];
+            for (const line of numstatPart.trim().split('\n')) {
                 if (!line)
                     continue;
-                var _f = line.split('\t'), addStr = _f[0], delStr = _f[1], path = _f[2];
+                const [addStr, delStr, path] = line.split('\t');
                 if (!path)
                     continue;
-                var additions = addStr === '-' ? 0 : parseInt(addStr, 10) || 0;
-                var deletions = delStr === '-' ? 0 : parseInt(delStr, 10) || 0;
-                var binary = addStr === '-' && delStr === '-';
-                var statusChar = statusMap.get(path) || 'M';
-                var status = 'modified';
+                const additions = addStr === '-' ? 0 : parseInt(addStr, 10) || 0;
+                const deletions = delStr === '-' ? 0 : parseInt(delStr, 10) || 0;
+                const binary = addStr === '-' && delStr === '-';
+                const statusChar = statusMap.get(path) || 'M';
+                let status = 'modified';
                 switch (statusChar) {
                     case 'A':
                         status = 'added';
@@ -489,102 +394,87 @@ export function getGitDiffNumstat(ref) {
                         break;
                     default: status = 'modified';
                 }
-                files.push({ path: path, status: status, additions: additions, deletions: deletions, hunks: 1, binary: binary });
+                files.push({ path, status, additions, deletions, hunks: 1, binary });
             }
         }
         // Cache the result
-        diffCache.set(cacheKey, { files: files, timestamp: Date.now() });
+        diffCache.set(cacheKey, { files, timestamp: Date.now() });
         return files;
     }
-    catch (_g) {
+    catch {
         return [];
     }
 }
 /**
  * Async version of getGitDiffNumstat for non-blocking operation
  */
-export function getGitDiffNumstatAsync(ref) {
-    if (ref === void 0) { ref = 'HEAD'; }
-    return __awaiter(this, void 0, Promise, function () {
-        var cacheKey, cached, execFile, promisify, execFileAsync, numstatOutput, statusOutput, stdout, _a, numstatPart, statusPart, statusMap, _i, _b, line, _c, status, pathParts, path, files, _d, _e, line, _f, addStr, delStr, path, additions, deletions, binary, statusChar, status, _g;
-        return __generator(this, function (_h) {
-            switch (_h.label) {
-                case 0:
-                    // SECURITY: Validate git ref to prevent command injection
-                    validateGitRef(ref);
-                    cacheKey = "numstat:" + ref;
-                    cached = diffCache.get(cacheKey);
-                    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-                        return [2 /*return*/, cached.files];
-                    }
-                    execFile = require('child_process').execFile;
-                    promisify = require('util').promisify;
-                    execFileAsync = promisify(execFile);
-                    _h.label = 1;
-                case 1:
-                    _h.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, execFileAsync('git', [
-                            'diff', '--numstat', '--diff-filter=ACDMRTUXB', ref
-                        ], { maxBuffer: 10 * 1024 * 1024 })];
-                case 2:
-                    numstatOutput = (_h.sent()).stdout;
-                    return [4 /*yield*/, execFileAsync('git', [
-                            'diff', '--name-status', ref
-                        ], { maxBuffer: 10 * 1024 * 1024 })];
-                case 3:
-                    statusOutput = (_h.sent()).stdout;
-                    stdout = numstatOutput + '---STATUS---' + statusOutput;
-                    _a = stdout.split('---STATUS---'), numstatPart = _a[0], statusPart = _a[1];
-                    statusMap = new Map();
-                    if (statusPart) {
-                        for (_i = 0, _b = statusPart.trim().split('\n'); _i < _b.length; _i++) {
-                            line = _b[_i];
-                            if (!line)
-                                continue;
-                            _c = line.split('\t'), status = _c[0], pathParts = _c.slice(1);
-                            path = pathParts[pathParts.length - 1] || pathParts[0];
-                            if (path)
-                                statusMap.set(path, status.charAt(0));
-                        }
-                    }
-                    files = [];
-                    if (numstatPart) {
-                        for (_d = 0, _e = numstatPart.trim().split('\n'); _d < _e.length; _d++) {
-                            line = _e[_d];
-                            if (!line)
-                                continue;
-                            _f = line.split('\t'), addStr = _f[0], delStr = _f[1], path = _f[2];
-                            if (!path)
-                                continue;
-                            additions = addStr === '-' ? 0 : parseInt(addStr, 10) || 0;
-                            deletions = delStr === '-' ? 0 : parseInt(delStr, 10) || 0;
-                            binary = addStr === '-' && delStr === '-';
-                            statusChar = statusMap.get(path) || 'M';
-                            status = 'modified';
-                            switch (statusChar) {
-                                case 'A':
-                                    status = 'added';
-                                    break;
-                                case 'D':
-                                    status = 'deleted';
-                                    break;
-                                case 'R':
-                                    status = 'renamed';
-                                    break;
-                                default: status = 'modified';
-                            }
-                            files.push({ path: path, status: status, additions: additions, deletions: deletions, hunks: 1, binary: binary });
-                        }
-                    }
-                    diffCache.set(cacheKey, { files: files, timestamp: Date.now() });
-                    return [2 /*return*/, files];
-                case 4:
-                    _g = _h.sent();
-                    return [2 /*return*/, []];
-                case 5: return [2 /*return*/];
+export async function getGitDiffNumstatAsync(ref = 'HEAD') {
+    // SECURITY: Validate git ref to prevent command injection
+    validateGitRef(ref);
+    // Check cache first
+    const cacheKey = `numstat:${ref}`;
+    const cached = diffCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+        return cached.files;
+    }
+    const { execFile } = require('child_process');
+    const { promisify } = require('util');
+    const execFileAsync = promisify(execFile);
+    try {
+        // SECURITY: Use execFile with args array instead of shell string
+        const { stdout: numstatOutput } = await execFileAsync('git', [
+            'diff', '--numstat', '--diff-filter=ACDMRTUXB', ref
+        ], { maxBuffer: 10 * 1024 * 1024 });
+        const { stdout: statusOutput } = await execFileAsync('git', [
+            'diff', '--name-status', ref
+        ], { maxBuffer: 10 * 1024 * 1024 });
+        const stdout = numstatOutput + '---STATUS---' + statusOutput;
+        const [numstatPart, statusPart] = stdout.split('---STATUS---');
+        const statusMap = new Map();
+        if (statusPart) {
+            for (const line of statusPart.trim().split('\n')) {
+                if (!line)
+                    continue;
+                const [status, ...pathParts] = line.split('\t');
+                const path = pathParts[pathParts.length - 1] || pathParts[0];
+                if (path)
+                    statusMap.set(path, status.charAt(0));
+            }
+        }
+        const files = [];
+        if (numstatPart) {
+            for (const line of numstatPart.trim().split('\n')) {
+                if (!line)
+                    continue;
+                const [addStr, delStr, path] = line.split('\t');
+                if (!path)
+                    continue;
+                const additions = addStr === '-' ? 0 : parseInt(addStr, 10) || 0;
+                const deletions = delStr === '-' ? 0 : parseInt(delStr, 10) || 0;
+                const binary = addStr === '-' && delStr === '-';
+                const statusChar = statusMap.get(path) || 'M';
+                let status = 'modified';
+                switch (statusChar) {
+                    case 'A':
+                        status = 'added';
+                        break;
+                    case 'D':
+                        status = 'deleted';
+                        break;
+                    case 'R':
+                        status = 'renamed';
+                        break;
+                    default: status = 'modified';
+                }
+                files.push({ path, status, additions, deletions, hunks: 1, binary });
             }
-        });
-    });
+        }
+        diffCache.set(cacheKey, { files, timestamp: Date.now() });
+        return files;
+    }
+    catch {
+        return [];
+    }
 }
 /**
  * Clear the diff cache (call when git state changes)
@@ -596,10 +486,10 @@ export function clearDiffCache() {
  * Assess risk for a single file
  */
 export function assessFileRisk(file) {
-    var reasons = [];
-    var score = 0;
+    const reasons = [];
+    let score = 0;
     // Size-based risk
-    var totalChanges = file.additions + file.deletions;
+    const totalChanges = file.additions + file.deletions;
     if (totalChanges > 300) {
         score += 30;
         reasons.push('Large change size (>300 lines)');
@@ -609,7 +499,7 @@ export function assessFileRisk(file) {
         reasons.push('Medium change size (>100 lines)');
     }
     // Path-based risk
-    var lowerPath = file.path.toLowerCase();
+    const lowerPath = file.path.toLowerCase();
     if (/security|auth|crypto|password/.test(lowerPath)) {
         score += 40;
         reasons.push('Security-sensitive file');
@@ -640,40 +530,39 @@ export function assessFileRisk(file) {
         score += 5;
         reasons.push('Binary file');
     }
-    var risk = 'low';
+    let risk = 'low';
     if (score >= 60)
         risk = 'critical';
     else if (score >= 40)
         risk = 'high';
     else if (score >= 20)
         risk = 'medium';
-    return { file: file.path, risk: risk, score: Math.min(100, score), reasons: reasons };
+    return { file: file.path, risk, score: Math.min(100, score), reasons };
 }
 /**
  * Assess overall risk from files and file risks
  */
 export function assessOverallRisk(files, fileRisks) {
-    var breakdown = { low: 0, medium: 0, high: 0, critical: 0 };
-    var totalScore = 0;
-    for (var _i = 0, fileRisks_1 = fileRisks; _i < fileRisks_1.length; _i++) {
-        var fr = fileRisks_1[_i];
+    const breakdown = { low: 0, medium: 0, high: 0, critical: 0 };
+    let totalScore = 0;
+    for (const fr of fileRisks) {
         breakdown[fr.risk]++;
         totalScore += fr.score;
     }
-    var avgScore = fileRisks.length > 0 ? totalScore / fileRisks.length : 0;
+    const avgScore = fileRisks.length > 0 ? totalScore / fileRisks.length : 0;
     // Weight more heavily towards high/critical files
-    var weightedScore = avgScore + (breakdown.critical * 15) + (breakdown.high * 10);
-    var overall = 'low';
+    const weightedScore = avgScore + (breakdown.critical * 15) + (breakdown.high * 10);
+    let overall = 'low';
     if (weightedScore >= 60 || breakdown.critical > 0)
         overall = 'critical';
     else if (weightedScore >= 40 || breakdown.high > 1)
         overall = 'high';
     else if (weightedScore >= 20 || breakdown.medium > 2)
         overall = 'medium';
-    return { overall: overall, score: Math.min(100, Math.round(weightedScore)), breakdown: breakdown };
+    return { overall, score: Math.min(100, Math.round(weightedScore)), breakdown };
 }
 // Singleton classifier instance for reuse
-var classifierInstance = null;
+let classifierInstance = null;
 function getClassifier() {
     if (!classifierInstance) {
         classifierInstance = new DiffClassifier();
@@ -684,24 +573,23 @@ function getClassifier() {
  * Classify a diff based on files (uses singleton classifier)
  */
 export function classifyDiff(files) {
-    var classifier = getClassifier();
-    var fileDiffs = files.map(function (f) { return ({
+    const classifier = getClassifier();
+    const fileDiffs = files.map(f => ({
         path: f.path,
         hunks: [],
         additions: f.additions,
         deletions: f.deletions,
-        classification: classifier['classifyFile'](f.path, [])
-    }); });
+        classification: classifier['classifyFile'](f.path, []),
+    }));
     return classifier['computeOverallClassification'](fileDiffs);
 }
 /**
  * Suggest reviewers based on files and risks
  */
 export function suggestReviewers(files, fileRisks) {
-    var reviewers = new Set();
-    for (var _i = 0, files_4 = files; _i < files_4.length; _i++) {
-        var file = files_4[_i];
-        var lowerPath = file.path.toLowerCase();
+    const reviewers = new Set();
+    for (const file of files) {
+        const lowerPath = file.path.toLowerCase();
         if (/security|auth|crypto/.test(lowerPath))
             reviewers.add('security-team');
         if (/database|migration/.test(lowerPath))
@@ -718,7 +606,7 @@ export function suggestReviewers(files, fileRisks) {
             reviewers.add('backend-lead');
     }
     // Add based on risk
-    var hasHighRisk = fileRisks.some(function (fr) { return fr.risk === 'high' || fr.risk === 'critical'; });
+    const hasHighRisk = fileRisks.some(fr => fr.risk === 'high' || fr.risk === 'critical');
     if (hasHighRisk) {
         reviewers.add('tech-lead');
         reviewers.add('senior-developer');
@@ -730,88 +618,73 @@ export function suggestReviewers(files, fileRisks) {
     return Array.from(reviewers).slice(0, 5);
 }
 // Analysis result cache
-var analysisCache = new Map();
-var ANALYSIS_CACHE_TTL_MS = 3000; // 3 seconds
+const analysisCache = new Map();
+const ANALYSIS_CACHE_TTL_MS = 3000; // 3 seconds
 /**
  * Analyze a diff with full analysis (optimized with caching)
  */
-export function analyzeDiff(options) {
-    return __awaiter(this, void 0, Promise, function () {
-        var ref, cached, files, fileRisks, _a, risk, classification, recommendedReviewers, totalAdditions, totalDeletions, result;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    ref = options.ref || 'HEAD';
-                    // Check analysis cache (unless skipCache is true)
-                    if (!options.skipCache) {
-                        cached = analysisCache.get(ref);
-                        if (cached && Date.now() - cached.timestamp < ANALYSIS_CACHE_TTL_MS) {
-                            return [2 /*return*/, cached.result];
-                        }
-                    }
-                    return [4 /*yield*/, getGitDiffNumstatAsync(ref)];
-                case 1:
-                    files = _b.sent();
-                    if (!(files.length > 20)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, Promise.all(files.map(function (f) { return Promise.resolve(assessFileRisk(f)); }))];
-                case 2:
-                    _a = _b.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    _a = files.map(assessFileRisk);
-                    _b.label = 4;
-                case 4:
-                    fileRisks = _a;
-                    risk = assessOverallRisk(files, fileRisks);
-                    classification = classifyDiff(files);
-                    recommendedReviewers = suggestReviewers(files, fileRisks);
-                    totalAdditions = files.reduce(function (sum, f) { return sum + f.additions; }, 0);
-                    totalDeletions = files.reduce(function (sum, f) { return sum + f.deletions; }, 0);
-                    result = {
-                        ref: ref,
-                        timestamp: Date.now(),
-                        files: files,
-                        risk: risk,
-                        classification: classification,
-                        summary: files.length + " files changed (+" + totalAdditions + "/-" + totalDeletions + "), " + risk.overall + " risk",
-                        fileRisks: fileRisks,
-                        recommendedReviewers: recommendedReviewers
-                    };
-                    // Cache the result
-                    analysisCache.set(ref, { result: result, timestamp: Date.now() });
-                    return [2 /*return*/, result];
-            }
-        });
-    });
+export async function analyzeDiff(options) {
+    const ref = options.ref || 'HEAD';
+    // Check analysis cache (unless skipCache is true)
+    if (!options.skipCache) {
+        const cached = analysisCache.get(ref);
+        if (cached && Date.now() - cached.timestamp < ANALYSIS_CACHE_TTL_MS) {
+            return cached.result;
+        }
+    }
+    // Use async git diff for non-blocking operation
+    const files = await getGitDiffNumstatAsync(ref);
+    // Parallel file risk assessment for large diffs
+    const fileRisks = files.length > 20
+        ? await Promise.all(files.map(f => Promise.resolve(assessFileRisk(f))))
+        : files.map(assessFileRisk);
+    const risk = assessOverallRisk(files, fileRisks);
+    const classification = classifyDiff(files);
+    const recommendedReviewers = suggestReviewers(files, fileRisks);
+    const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
+    const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
+    const result = {
+        ref,
+        timestamp: Date.now(),
+        files,
+        risk,
+        classification,
+        summary: `${files.length} files changed (+${totalAdditions}/-${totalDeletions}), ${risk.overall} risk`,
+        fileRisks,
+        recommendedReviewers,
+    };
+    // Cache the result
+    analysisCache.set(ref, { result, timestamp: Date.now() });
+    return result;
 }
 /**
  * Synchronous version of analyzeDiff for backward compatibility
  */
 export function analyzeDiffSync(options) {
-    var ref = options.ref || 'HEAD';
+    const ref = options.ref || 'HEAD';
     // Check analysis cache
-    var cached = analysisCache.get(ref);
+    const cached = analysisCache.get(ref);
     if (cached && Date.now() - cached.timestamp < ANALYSIS_CACHE_TTL_MS) {
         return cached.result;
     }
-    var files = getGitDiffNumstat(ref);
-    var fileRisks = files.map(assessFileRisk);
-    var risk = assessOverallRisk(files, fileRisks);
-    var classification = classifyDiff(files);
-    var recommendedReviewers = suggestReviewers(files, fileRisks);
-    var totalAdditions = files.reduce(function (sum, f) { return sum + f.additions; }, 0);
-    var totalDeletions = files.reduce(function (sum, f) { return sum + f.deletions; }, 0);
-    var result = {
-        ref: ref,
+    const files = getGitDiffNumstat(ref);
+    const fileRisks = files.map(assessFileRisk);
+    const risk = assessOverallRisk(files, fileRisks);
+    const classification = classifyDiff(files);
+    const recommendedReviewers = suggestReviewers(files, fileRisks);
+    const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
+    const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
+    const result = {
+        ref,
         timestamp: Date.now(),
-        files: files,
-        risk: risk,
-        classification: classification,
-        summary: files.length + " files changed (+" + totalAdditions + "/-" + totalDeletions + "), " + risk.overall + " risk",
-        fileRisks: fileRisks,
-        recommendedReviewers: recommendedReviewers
+        files,
+        risk,
+        classification,
+        summary: `${files.length} files changed (+${totalAdditions}/-${totalDeletions}), ${risk.overall} risk`,
+        fileRisks,
+        recommendedReviewers,
     };
-    analysisCache.set(ref, { result: result, timestamp: Date.now() });
+    analysisCache.set(ref, { result, timestamp: Date.now() });
     return result;
 }
 /**
@@ -820,6 +693,6 @@ export function analyzeDiffSync(options) {
 export function clearAllDiffCaches() {
     diffCache.clear();
     analysisCache.clear();
-    classifierInstance === null || classifierInstance === void 0 ? void 0 : classifierInstance.clearCache();
+    classifierInstance?.clearCache();
 }
 //# sourceMappingURL=diff-classifier.js.map