mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
289 lines • 12 kB
JavaScript
/**
* Unified Scoring System for MIRA Analyzers
*
* Provides consistent scoring methodology across all analyzers
* with weighted metrics, risk assessment, and normalized outputs.
*/
export class UnifiedScoringSystem {
static DEFAULT_WEIGHTS = {
// Component weights (must sum to 1.0)
security: 0.30,
performance: 0.25,
quality: 0.25,
maintainability: 0.15,
documentation: 0.05,
// Issue severity weights
critical: 20,
high: 10,
medium: 5,
low: 1,
// Confidence multipliers
highConfidence: 1.0,
mediumConfidence: 0.7,
lowConfidence: 0.3
};
static VERSION = '1.0.0';
/**
* Calculate unified score across multiple analyzer results
*/
static calculateUnifiedScore(results, weights = {}) {
const finalWeights = { ...this.DEFAULT_WEIGHTS, ...weights };
// Extract component scores
const componentScores = {
security: results.security?.score || 100,
performance: results.performance?.score || 100,
quality: results.quality?.score || 100,
maintainability: results.maintainability?.score || 100,
documentation: results.documentation?.score || 100
};
// Calculate weighted overall score
const overall = Math.round(componentScores.security * finalWeights.security +
componentScores.performance * finalWeights.performance +
componentScores.quality * finalWeights.quality +
componentScores.maintainability * finalWeights.maintainability +
componentScores.documentation * finalWeights.documentation);
// Aggregate all issues
const allIssues = Object.values(results).flatMap(result => result.issues || []);
// Calculate scoring metrics
const metrics = this.calculateScoringMetrics(allIssues, results);
// Assess risk
const risk = this.assessRisk(componentScores, allIssues, overall);
return {
overall: Math.max(0, Math.min(100, overall)),
...componentScores,
risk,
metrics,
weights: finalWeights,
version: this.VERSION,
timestamp: new Date()
};
}
/**
* Calculate individual analyzer score with normalized methodology
*/
static calculateAnalyzerScore(issues, baseScore = 100, bonusPoints = 0, totalItems = 0) {
let score = baseScore + bonusPoints;
// Deduct points based on issue severity and confidence
for (const issue of issues) {
const severityWeight = this.getSeverityWeight(issue.severity);
const confidenceMultiplier = this.getConfidenceMultiplier(issue.confidence);
const impactMultiplier = this.getImpactMultiplier(issue.impact);
const deduction = severityWeight * confidenceMultiplier * impactMultiplier;
score -= deduction;
}
// Apply scaling factor based on analysis scope
if (totalItems > 0) {
const issueRatio = issues.length / totalItems;
if (issueRatio > 0.5) {
score *= 0.8; // Significant penalty for high issue ratio
}
else if (issueRatio > 0.3) {
score *= 0.9; // Moderate penalty
}
}
return Math.max(0, Math.min(100, Math.round(score)));
}
/**
* Normalize scores from different analyzer types to unified scale
*/
static normalizeScore(rawScore, analyzerType, analyzerVersion) {
// Apply analyzer-specific normalization factors
const normalizationFactors = {
security: 1.0,
performance: 1.0,
quality: 1.0,
documentation: 1.2, // Documentation tends to score lower
dependencies: 0.9, // Dependencies tend to score higher
unused: 0.95,
crossPlatform: 1.1
};
const factor = normalizationFactors[analyzerType] || 1.0;
const normalizedScore = rawScore * factor;
return Math.max(0, Math.min(100, Math.round(normalizedScore)));
}
/**
* Generate risk assessment based on scores and issues
*/
static assessRisk(scores, issues, overallScore) {
const criticalIssues = issues.filter(i => i.severity === 'critical').length;
const highIssues = issues.filter(i => i.severity === 'high').length;
// Determine risk level
let level;
let timeToAddress;
if (criticalIssues > 0 || overallScore < 30) {
level = 'critical';
timeToAddress = 'Immediate action required';
}
else if (highIssues > 3 || overallScore < 50) {
level = 'high';
timeToAddress = '1-2 weeks';
}
else if (overallScore < 70) {
level = 'medium';
timeToAddress = '1-2 months';
}
else if (overallScore < 85) {
level = 'low';
timeToAddress = '3-6 months';
}
else {
level = 'minimal';
timeToAddress = 'Maintenance schedule';
}
// Calculate risk factors
const factors = this.calculateRiskFactors(scores, issues);
// Generate recommendations
const recommendations = this.generateRiskRecommendations(level, factors, issues);
return {
level,
score: overallScore,
confidence: this.calculateRiskConfidence(issues),
factors,
recommendations,
timeToAddress
};
}
static calculateScoringMetrics(issues, results) {
const criticalIssues = issues.filter(i => i.severity === 'critical').length;
const highIssues = issues.filter(i => i.severity === 'high').length;
const mediumIssues = issues.filter(i => i.severity === 'medium').length;
const lowIssues = issues.filter(i => i.severity === 'low').length;
// Calculate confidence score based on issue confidence levels
const highConfidenceIssues = issues.filter(i => i.confidence === 'high').length;
const totalIssues = issues.length;
const confidenceScore = totalIssues > 0
? Math.round((highConfidenceIssues / totalIssues) * 100)
: 100;
return {
baseScore: 100,
confidenceScore,
severityScore: this.calculateSeverityScore(issues),
criticalIssues,
highIssues,
mediumIssues,
lowIssues,
bonusPoints: 0,
penaltyPoints: criticalIssues * 20 + highIssues * 10,
totalItems: Object.keys(results).length,
itemsAnalyzed: Object.values(results).filter(r => r.score !== undefined).length,
analysisDepth: 'comprehensive'
};
}
static calculateSeverityScore(issues) {
if (issues.length === 0)
return 100;
const totalWeight = issues.reduce((sum, issue) => {
return sum + this.getSeverityWeight(issue.severity);
}, 0);
const avgSeverity = totalWeight / issues.length;
return Math.max(0, 100 - avgSeverity * 2);
}
static getSeverityWeight(severity) {
switch (severity) {
case 'critical': return this.DEFAULT_WEIGHTS.critical;
case 'high': return this.DEFAULT_WEIGHTS.high;
case 'medium': return this.DEFAULT_WEIGHTS.medium;
case 'low': return this.DEFAULT_WEIGHTS.low;
default: return 1;
}
}
static getConfidenceMultiplier(confidence) {
switch (confidence) {
case 'high': return this.DEFAULT_WEIGHTS.highConfidence;
case 'medium': return this.DEFAULT_WEIGHTS.mediumConfidence;
case 'low': return this.DEFAULT_WEIGHTS.lowConfidence;
default: return 0.5;
}
}
static getImpactMultiplier(impact) {
switch (impact) {
case 'major': return 1.5;
case 'moderate': return 1.0;
case 'minor': return 0.5;
default: return 1.0;
}
}
static calculateRiskFactors(scores, issues) {
const factors = [];
// Security risk factors
if (scores.security < 70) {
factors.push({
type: 'security',
severity: scores.security < 30 ? 'critical' : scores.security < 50 ? 'high' : 'medium',
impact: 'major',
likelihood: 'high',
description: 'Security vulnerabilities detected that could expose the system to threats',
mitigation: 'Address security issues immediately and implement security review process'
});
}
// Performance risk factors
if (scores.performance < 60) {
factors.push({
type: 'performance',
severity: scores.performance < 40 ? 'high' : 'medium',
impact: 'moderate',
likelihood: 'medium',
description: 'Performance bottlenecks may impact user experience and system scalability',
mitigation: 'Optimize critical performance paths and implement monitoring'
});
}
// Maintainability risk factors
if (scores.maintainability < 50) {
factors.push({
type: 'maintainability',
severity: 'medium',
impact: 'moderate',
likelihood: 'high',
description: 'Code maintainability issues will increase development costs over time',
mitigation: 'Refactor complex code and establish coding standards'
});
}
return factors;
}
static generateRiskRecommendations(level, factors, issues) {
const recommendations = [];
if (level === 'critical') {
recommendations.push('🚨 Immediate action required - system is at critical risk');
recommendations.push('📋 Establish incident response plan');
recommendations.push('🔒 Review all security vulnerabilities immediately');
}
if (level === 'high') {
recommendations.push('⚡ Schedule urgent remediation within 1-2 weeks');
recommendations.push('👥 Assign dedicated team to address high-priority issues');
}
// Factor-specific recommendations
for (const factor of factors) {
if (factor.type === 'security' && factor.severity === 'critical') {
recommendations.push('🔐 Implement security patches and updates immediately');
}
if (factor.type === 'performance' && factor.severity === 'high') {
recommendations.push('⚡ Profile and optimize performance bottlenecks');
}
}
return recommendations;
}
static calculateRiskConfidence(issues) {
if (issues.length === 0)
return 100;
const highConfidenceIssues = issues.filter(i => i.confidence === 'high').length;
return Math.round((highConfidenceIssues / issues.length) * 100);
}
/**
* Create scoring summary for reporting
*/
static createScoringSummary(unifiedScore) {
const { overall, risk, metrics } = unifiedScore;
let summary = `Overall Score: ${overall}/100 (${risk.level.toUpperCase()} risk)\\n`;
summary += `Critical Issues: ${metrics.criticalIssues}\\n`;
summary += `High Priority Issues: ${metrics.highIssues}\\n`;
summary += `Time to Address: ${risk.timeToAddress}\\n`;
if (risk.recommendations.length > 0) {
summary += `\\nKey Recommendations:\\n`;
risk.recommendations.slice(0, 3).forEach(rec => {
summary += `• ${rec}\\n`;
});
}
return summary;
}
}
//# sourceMappingURL=UnifiedScoring.js.map