kynjal-cli 3.1.3 → 4.0.0

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

@@ -1,174 +1,253 @@
 /**
  * Diff Classifier for Change Analysis
  */
-const DEFAULT_CONFIG = {
+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 = {
     maxDiffSize: 10000,
     classifyByImpact: true,
     detectRefactoring: true,
-    minConfidence: 0.5,
+    minConfidence: 0.5
 };
-const CLASSIFICATION_PATTERNS = {
+var 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/]
 };
-const IMPACT_KEYWORDS = {
+var 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
 };
-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\/(.+)/);
+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\/(.+)/);
             if (!pathMatch)
                 continue;
-            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 });
+            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 });
         }
         return files;
-    }
-    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),
+    };
+    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),
             filesChanged: files.length,
-            avgConfidence: files.length > 0 ? files.reduce((sum, f) => sum + f.classification.confidence, 0) / files.length : 0,
+            avgConfidence: files.length > 0 ? files.reduce(function (sum, f) { return sum + f.classification.confidence; }, 0) / files.length : 0
         };
-        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) {
+        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];
                 if (pattern.test(lowerMessage))
                     return type;
             }
         }
         return 'unknown';
-    }
-    getStats() {
+    };
+    DiffClassifier.prototype.getStats = function () {
         return { useNative: this.useNative, cacheSize: this.classificationCache.size };
-    }
-    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 });
+    };
+    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 });
         }
         return hunks;
-    }
-    parseChanges(content, startLine) {
-        const changes = [];
-        const lines = content.split('\n');
-        let lineNumber = startLine;
-        for (const line of lines) {
+    };
+    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];
             if (line.startsWith('+')) {
-                changes.push({ type: 'add', lineNumber, content: line.substring(1) });
+                changes.push({ type: 'add', lineNumber: 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, content: line.substring(1) || '' });
+                changes.push({ type: 'context', lineNumber: lineNumber, content: line.substring(1) || '' });
                 lineNumber++;
             }
         }
         return changes;
-    }
-    classifyFile(path, hunks) {
-        const cacheKey = this.getCacheKey(path, hunks);
-        const cached = this.classificationCache.get(cacheKey);
+    };
+    DiffClassifier.prototype.classifyFile = function (path, hunks) {
+        var cacheKey = this.getCacheKey(path, hunks);
+        var cached = this.classificationCache.get(cacheKey);
         if (cached)
             return cached;
-        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 };
+        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 };
         this.classificationCache.set(cacheKey, classification);
         return classification;
-    }
-    getCacheKey(path, hunks) {
-        const hunkSummary = hunks.map(h => h.oldStart + ':' + h.newStart).join(',');
+    };
+    DiffClassifier.prototype.getCacheKey = function (path, hunks) {
+        var hunkSummary = hunks.map(function (h) { return h.oldStart + ':' + h.newStart; }).join(',');
         return path + ':' + hunkSummary;
-    }
-    determinePrimaryClassification(path, hunks) {
-        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
-            for (const pattern of patterns) {
+    };
+    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];
                 if (pattern.test(path))
                     return type;
             }
         }
-        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))
+        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; }))
             return 'feature';
         if (/fix|bug|issue|error|exception/.test(allContent))
             return 'bugfix';
         if (this.config.detectRefactoring && this.isRefactoring(hunks))
             return 'refactor';
         return 'unknown';
-    }
-    isRefactoring(hunks) {
-        let totalAdds = 0, totalRemoves = 0;
-        for (const hunk of hunks) {
-            for (const change of hunk.changes) {
+    };
+    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];
                 if (change.type === 'add')
                     totalAdds++;
                 else if (change.type === 'remove')
                     totalRemoves++;
             }
         }
-        const ratio = totalAdds > 0 ? totalRemoves / totalAdds : 0;
+        var ratio = totalAdds > 0 ? totalRemoves / totalAdds : 0;
         return ratio > 0.7 && ratio < 1.4 && totalAdds > 5;
-    }
-    determineSecondaryClassifications(path, hunks, primary) {
-        const secondary = [];
-        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
+    };
+    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];
             if (type === primary)
                 continue;
-            for (const pattern of patterns) {
+            for (var _c = 0, patterns_3 = patterns; _c < patterns_3.length; _c++) {
+                var pattern = patterns_3[_c];
                 if (pattern.test(path)) {
                     secondary.push(type);
                     break;
@@ -176,18 +255,20 @@ export class DiffClassifier {
             }
         }
         return secondary.slice(0, 3);
-    }
-    calculateConfidence(path, hunks, primary) {
-        let confidence = 0.5;
-        for (const patterns of Object.values(CLASSIFICATION_PATTERNS)) {
-            for (const pattern of patterns) {
+    };
+    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];
                 if (pattern.test(path)) {
                     confidence += 0.2;
                     break;
                 }
             }
         }
-        const totalChanges = hunks.reduce((sum, h) => sum + h.changes.length, 0);
+        var totalChanges = hunks.reduce(function (sum, h) { return sum + h.changes.length; }, 0);
         if (totalChanges > 10)
             confidence += 0.1;
         if (totalChanges > 50)
@@ -195,15 +276,16 @@ export class DiffClassifier {
         if (primary !== 'unknown')
             confidence += 0.1;
         return Math.min(1, confidence);
-    }
-    determineImpactLevel(path, hunks) {
-        let score = 0;
-        const lowerPath = path.toLowerCase();
-        for (const [keyword, weight] of Object.entries(IMPACT_KEYWORDS)) {
+    };
+    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];
             if (lowerPath.includes(keyword))
                 score = Math.max(score, weight);
         }
-        const totalChanges = hunks.reduce((sum, h) => sum + h.changes.filter(c => c.type !== 'context').length, 0);
+        var totalChanges = hunks.reduce(function (sum, h) { return sum + h.changes.filter(function (c) { return c.type !== 'context'; }).length; }, 0);
         if (totalChanges > 100)
             score = Math.max(score, 2);
         if (totalChanges > 300)
@@ -215,21 +297,21 @@ export class DiffClassifier {
         if (score >= 1)
             return 'medium';
         return 'low';
-    }
-    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));
+    };
+    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));
         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 [...new Set(reviewers)].slice(0, 4);
-    }
-    determineTestingStrategy(path, primary, impact) {
-        const strategies = [];
+        return __spreadArray([], new Set(reviewers), true).slice(0, 4);
+    };
+    DiffClassifier.prototype.determineTestingStrategy = function (path, primary, impact) {
+        var strategies = [];
         if (primary !== 'test')
             strategies.push('unit-tests');
         if (primary === 'feature')
@@ -243,10 +325,10 @@ export class DiffClassifier {
         if (/security|auth|crypto/.test(path))
             strategies.push('security-audit');
         return strategies.slice(0, 5);
-    }
-    identifyRiskFactors(path, hunks, impact) {
-        const risks = [];
-        const totalChanges = hunks.reduce((sum, h) => sum + h.changes.length, 0);
+    };
+    DiffClassifier.prototype.identifyRiskFactors = function (path, hunks, impact) {
+        var risks = [];
+        var totalChanges = hunks.reduce(function (sum, h) { return sum + h.changes.length; }, 0);
         if (totalChanges > 200)
             risks.push('Large change set - increased review time needed');
         if (impact === 'critical')
@@ -259,49 +341,59 @@ export class DiffClassifier {
             risks.push('Database changes - ensure backup strategy');
         if (/config|env/.test(path))
             risks.push('Configuration changes - verify all environments');
-        const allContent = hunks.flatMap(h => h.changes.map(c => c.content)).join('\n');
+        var allContent = hunks.flatMap(function (h) { return h.changes.map(function (c) { return 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);
-    }
-    computeOverallClassification(files) {
+    };
+    DiffClassifier.prototype.computeOverallClassification = function (files) {
         if (files.length === 0)
             return { primary: 'unknown', secondary: [], confidence: 0, impactLevel: 'low', suggestedReviewers: [], testingStrategy: [], riskFactors: [] };
-        const primaryCounts = {};
-        for (const file of files) {
-            const p = file.classification.primary;
+        var primaryCounts = {};
+        for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+            var file = files_1[_i];
+            var p = file.classification.primary;
             primaryCounts[p] = (primaryCounts[p] || 0) + 1;
         }
-        let primary = 'unknown';
-        let maxCount = 0;
-        for (const [type, count] of Object.entries(primaryCounts)) {
+        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];
             if (count > maxCount) {
                 maxCount = count;
                 primary = type;
             }
         }
-        const secondaryCounts = {};
-        for (const file of files) {
-            for (const s of file.classification.secondary) {
+        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];
                 secondaryCounts[s] = (secondaryCounts[s] || 0) + 1;
             }
         }
-        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) {
+        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];
             if (impactOrder.indexOf(file.classification.impactLevel) > impactOrder.indexOf(impactLevel))
                 impactLevel = file.classification.impactLevel;
         }
-        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 };
-    }
-}
+        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 };
 export function createDiffClassifier(config) {
     return new DiffClassifier(config);
 }
@@ -309,8 +401,8 @@ export function createDiffClassifier(config) {
 // Optimized Git Diff Functions
 // ============================================================================
 // Cache for diff results (TTL-based)
-const diffCache = new Map();
-const CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequently
+var diffCache = new Map();
+var CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequently
 /**
  * Validate git ref to prevent command injection
  * Only allows safe characters: alphanumeric, -, _, /, ., ~, ^
@@ -318,70 +410,73 @@ const CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequentl
 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 = 'HEAD') {
+export function getGitDiffNumstat(ref) {
+    if (ref === void 0) { ref = 'HEAD'; }
     // SECURITY: Validate git ref to prevent command injection
     validateGitRef(ref);
     // Check cache first
-    const cacheKey = `numstat:${ref}`;
-    const cached = diffCache.get(cacheKey);
+    var cacheKey = "numstat:" + ref;
+    var cached = diffCache.get(cacheKey);
     if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
         return cached.files;
     }
-    const { execFileSync } = require('child_process');
+    var execFileSync = require('child_process').execFileSync;
     try {
         // SECURITY: Use execFileSync with args array instead of shell string
         // This prevents command injection via the ref parameter
-        const numstatOutput = execFileSync('git', [
+        var numstatOutput = execFileSync('git', [
             'diff', '--numstat', '--diff-filter=ACDMRTUXB', ref
         ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        const statusOutput = execFileSync('git', [
+        var statusOutput = execFileSync('git', [
             'diff', '--name-status', ref
         ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        const output = numstatOutput + '---STATUS---' + statusOutput;
-        const [numstatPart, statusPart] = output.split('---STATUS---');
+        var output = numstatOutput + '---STATUS---' + statusOutput;
+        var _a = output.split('---STATUS---'), numstatPart = _a[0], statusPart = _a[1];
         // Parse status (usually smaller, parse first)
-        const statusMap = new Map();
+        var statusMap = new Map();
         if (statusPart) {
-            for (const line of statusPart.trim().split('\n')) {
+            for (var _i = 0, _b = statusPart.trim().split('\n'); _i < _b.length; _i++) {
+                var line = _b[_i];
                 if (!line)
                     continue;
-                const [status, ...pathParts] = line.split('\t');
-                const path = pathParts[pathParts.length - 1] || pathParts[0];
+                var _c = line.split('\t'), status = _c[0], pathParts = _c.slice(1);
+                var path = pathParts[pathParts.length - 1] || pathParts[0];
                 if (path)
                     statusMap.set(path, status.charAt(0));
             }
         }
         // Parse numstat
-        const files = [];
+        var files = [];
         if (numstatPart) {
-            for (const line of numstatPart.trim().split('\n')) {
+            for (var _d = 0, _e = numstatPart.trim().split('\n'); _d < _e.length; _d++) {
+                var line = _e[_d];
                 if (!line)
                     continue;
-                const [addStr, delStr, path] = line.split('\t');
+                var _f = line.split('\t'), addStr = _f[0], delStr = _f[1], path = _f[2];
                 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';
+                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';
                 switch (statusChar) {
                     case 'A':
                         status = 'added';
@@ -394,87 +489,102 @@ export function getGitDiffNumstat(ref = 'HEAD') {
                         break;
                     default: status = 'modified';
                 }
-                files.push({ path, status, additions, deletions, hunks: 1, binary });
+                files.push({ path: path, status: status, additions: additions, deletions: deletions, hunks: 1, binary: binary });
             }
         }
         // Cache the result
-        diffCache.set(cacheKey, { files, timestamp: Date.now() });
+        diffCache.set(cacheKey, { files: files, timestamp: Date.now() });
         return files;
     }
-    catch {
+    catch (_g) {
         return [];
     }
 }
 /**
  * Async version of getGitDiffNumstat for non-blocking operation
  */
-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 });
+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*/];
             }
-        }
-        diffCache.set(cacheKey, { files, timestamp: Date.now() });
-        return files;
-    }
-    catch {
-        return [];
-    }
+        });
+    });
 }
 /**
  * Clear the diff cache (call when git state changes)
@@ -486,10 +596,10 @@ export function clearDiffCache() {
  * Assess risk for a single file
  */
 export function assessFileRisk(file) {
-    const reasons = [];
-    let score = 0;
+    var reasons = [];
+    var score = 0;
     // Size-based risk
-    const totalChanges = file.additions + file.deletions;
+    var totalChanges = file.additions + file.deletions;
     if (totalChanges > 300) {
         score += 30;
         reasons.push('Large change size (>300 lines)');
@@ -499,7 +609,7 @@ export function assessFileRisk(file) {
         reasons.push('Medium change size (>100 lines)');
     }
     // Path-based risk
-    const lowerPath = file.path.toLowerCase();
+    var lowerPath = file.path.toLowerCase();
     if (/security|auth|crypto|password/.test(lowerPath)) {
         score += 40;
         reasons.push('Security-sensitive file');
@@ -530,39 +640,40 @@ export function assessFileRisk(file) {
         score += 5;
         reasons.push('Binary file');
     }
-    let risk = 'low';
+    var risk = 'low';
     if (score >= 60)
         risk = 'critical';
     else if (score >= 40)
         risk = 'high';
     else if (score >= 20)
         risk = 'medium';
-    return { file: file.path, risk, score: Math.min(100, score), reasons };
+    return { file: file.path, risk: risk, score: Math.min(100, score), reasons: reasons };
 }
 /**
  * Assess overall risk from files and file risks
  */
 export function assessOverallRisk(files, fileRisks) {
-    const breakdown = { low: 0, medium: 0, high: 0, critical: 0 };
-    let totalScore = 0;
-    for (const fr of 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];
         breakdown[fr.risk]++;
         totalScore += fr.score;
     }
-    const avgScore = fileRisks.length > 0 ? totalScore / fileRisks.length : 0;
+    var avgScore = fileRisks.length > 0 ? totalScore / fileRisks.length : 0;
     // Weight more heavily towards high/critical files
-    const weightedScore = avgScore + (breakdown.critical * 15) + (breakdown.high * 10);
-    let overall = 'low';
+    var weightedScore = avgScore + (breakdown.critical * 15) + (breakdown.high * 10);
+    var 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, score: Math.min(100, Math.round(weightedScore)), breakdown };
+    return { overall: overall, score: Math.min(100, Math.round(weightedScore)), breakdown: breakdown };
 }
 // Singleton classifier instance for reuse
-let classifierInstance = null;
+var classifierInstance = null;
 function getClassifier() {
     if (!classifierInstance) {
         classifierInstance = new DiffClassifier();
@@ -573,23 +684,24 @@ function getClassifier() {
  * Classify a diff based on files (uses singleton classifier)
  */
 export function classifyDiff(files) {
-    const classifier = getClassifier();
-    const fileDiffs = files.map(f => ({
+    var classifier = getClassifier();
+    var fileDiffs = files.map(function (f) { return ({
         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) {
-    const reviewers = new Set();
-    for (const file of files) {
-        const lowerPath = file.path.toLowerCase();
+    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();
         if (/security|auth|crypto/.test(lowerPath))
             reviewers.add('security-team');
         if (/database|migration/.test(lowerPath))
@@ -606,7 +718,7 @@ export function suggestReviewers(files, fileRisks) {
             reviewers.add('backend-lead');
     }
     // Add based on risk
-    const hasHighRisk = fileRisks.some(fr => fr.risk === 'high' || fr.risk === 'critical');
+    var hasHighRisk = fileRisks.some(function (fr) { return fr.risk === 'high' || fr.risk === 'critical'; });
     if (hasHighRisk) {
         reviewers.add('tech-lead');
         reviewers.add('senior-developer');
@@ -618,73 +730,88 @@ export function suggestReviewers(files, fileRisks) {
     return Array.from(reviewers).slice(0, 5);
 }
 // Analysis result cache
-const analysisCache = new Map();
-const ANALYSIS_CACHE_TTL_MS = 3000; // 3 seconds
+var analysisCache = new Map();
+var ANALYSIS_CACHE_TTL_MS = 3000; // 3 seconds
 /**
  * Analyze a diff with full analysis (optimized with caching)
  */
-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;
+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];
+            }
+        });
+    });
 }
 /**
  * Synchronous version of analyzeDiff for backward compatibility
  */
 export function analyzeDiffSync(options) {
-    const ref = options.ref || 'HEAD';
+    var ref = options.ref || 'HEAD';
     // Check analysis cache
-    const cached = analysisCache.get(ref);
+    var cached = analysisCache.get(ref);
     if (cached && Date.now() - cached.timestamp < ANALYSIS_CACHE_TTL_MS) {
         return cached.result;
     }
-    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,
+    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,
         timestamp: Date.now(),
-        files,
-        risk,
-        classification,
-        summary: `${files.length} files changed (+${totalAdditions}/-${totalDeletions}), ${risk.overall} risk`,
-        fileRisks,
-        recommendedReviewers,
+        files: files,
+        risk: risk,
+        classification: classification,
+        summary: files.length + " files changed (+" + totalAdditions + "/-" + totalDeletions + "), " + risk.overall + " risk",
+        fileRisks: fileRisks,
+        recommendedReviewers: recommendedReviewers
     };
-    analysisCache.set(ref, { result, timestamp: Date.now() });
+    analysisCache.set(ref, { result: result, timestamp: Date.now() });
     return result;
 }
 /**
@@ -693,6 +820,6 @@ export function analyzeDiffSync(options) {
 export function clearAllDiffCaches() {
     diffCache.clear();
     analysisCache.clear();
-    classifierInstance?.clearCache();
+    classifierInstance === null || classifierInstance === void 0 ? void 0 : classifierInstance.clearCache();
 }
 //# sourceMappingURL=diff-classifier.js.map