@sun-asterisk/sunlint 1.3.32 → 1.3.34

package/core/output-service.js

@@ -115,6 +115,74 @@ class OutputService {
     if (!options.quiet && options.format !== 'json') {
       console.log(report.summary);
     }
+
+    // Output architecture results if available
+    if (results.architecture && !options.quiet) {
+      this.outputArchitectureResults(results.architecture, options);
+    }
+  }
+
+  /**
+   * Output architecture analysis results
+   * @param {Object} archResults - Architecture analysis results
+   * @param {Object} options - Output options
+   */
+  outputArchitectureResults(archResults, options) {
+    if (!archResults || !archResults.summary) {
+      return;
+    }
+
+    const summary = archResults.summary;
+
+    console.log(chalk.blue('\n🏛️ Architecture Analysis:'));
+    console.log('━'.repeat(50));
+
+    // Primary pattern
+    const confidence = Math.round(summary.primaryConfidence * 100);
+    console.log(`• Pattern: ${chalk.cyan(summary.primaryPattern)} (${confidence}% confidence)`);
+
+    // Secondary patterns
+    if (summary.secondaryPatterns && summary.secondaryPatterns.length > 0) {
+      const secondary = summary.secondaryPatterns
+        .map(p => `${p.pattern} (${Math.round(p.confidence * 100)}%)`)
+        .join(', ');
+      console.log(`• Secondary: ${chalk.gray(secondary)}`);
+    }
+
+    // Health score
+    const healthScore = Math.round(summary.healthScore);
+    const healthColor = healthScore >= 80 ? chalk.green :
+                        healthScore >= 60 ? chalk.yellow : chalk.red;
+    console.log(`• Health Score: ${healthColor(healthScore + '/100')}`);
+
+    // Violations
+    if (summary.violationCount > 0) {
+      console.log(`• Violations: ${chalk.red(summary.violationCount)}`);
+
+      // Show first 5 violations
+      if (archResults.violations && archResults.violations.length > 0) {
+        console.log(chalk.gray('\nTop Architecture Violations:'));
+        archResults.violations.slice(0, 5).forEach((v, i) => {
+          const severity = v.severity === 'error' ? chalk.red('✗') : chalk.yellow('⚠');
+          console.log(`  ${severity} ${v.message}`);
+          if (v.file) {
+            console.log(chalk.gray(`    → ${v.file}:${v.line || 1}`));
+          }
+        });
+        if (archResults.violations.length > 5) {
+          console.log(chalk.gray(`  ... and ${archResults.violations.length - 5} more`));
+        }
+      }
+    } else {
+      console.log(`• Violations: ${chalk.green('None')}`);
+    }
+
+    // Report file info
+    if (archResults.markdownReport && options.archReport) {
+      console.log(chalk.gray('\n📄 Full architecture report saved'));
+    }
+
+    console.log();
   }
 
   generateAndSaveSummaryReport(violations, results, options, metadata) {
@@ -265,7 +333,7 @@ class OutputService {
 
   formatViolations(violations) {
     if (violations.length === 0) {
-      return chalk.green('✅ No violations found!');
+      return ''; // Summary already shown by orchestrator
     }
 
     let output = '';
@@ -330,22 +398,23 @@ class OutputService {
   }
 
   generateSummary(violations, filesAnalyzed, metadata) {
-    const duration = metadata.duration || 0;
+    // Summary is now minimal - main info shown by orchestrator
+    if (violations.length === 0) {
+      return ''; // Clean output when no issues
+    }
+
     const errorCount = violations.filter(v => v.severity === 'error').length;
     const warningCount = violations.filter(v => v.severity === 'warning').length;
 
-    let summary = chalk.blue('\n📊 Sun Lint Summary:\n');
-    summary += `Analysis completed in ${duration}ms\n`;
-    summary += `Files: ${filesAnalyzed} | Total: ${violations.length}\n`;
-    
-    if (errorCount > 0) {
-      summary += chalk.red(`Errors: ${errorCount} `);
-    }
-    if (warningCount > 0) {
-      summary += chalk.yellow(`Warnings: ${warningCount} `);
-    }
-    if (violations.length === 0) {
-      summary += chalk.green('All checks passed! ✅');
+    let summary = '\n';
+    if (errorCount > 0 || warningCount > 0) {
+      summary += chalk.gray('  ') + chalk.dim(`${filesAnalyzed} files · `);
+      if (errorCount > 0) {
+        summary += chalk.red(`${errorCount} errors `);
+      }
+      if (warningCount > 0) {
+        summary += chalk.yellow(`${warningCount} warnings`);
+      }
     }
 
     return summary;
@@ -463,35 +532,30 @@ class OutputService {
       });
 
       if (uploadResult.success) {
-        if (!options.quiet) {
-          console.log(chalk.green(`✅ Report successfully uploaded to: ${apiUrl}`));
-          if (uploadResult.statusCode) {
-            console.log(chalk.green(`📡 HTTP Status: ${uploadResult.statusCode}`));
-          }
-          if (uploadResult.response) {
-            try {
-              const responseData = JSON.parse(uploadResult.response);
-              if (responseData.message) {
-                console.log(chalk.blue(`💬 Server response: ${responseData.message}`));
-              }
-              if (responseData.report_id) {
-                console.log(chalk.blue(`📝 Report ID: ${responseData.report_id}`));
-              }
-              if (responseData.repository) {
-                console.log(chalk.blue(`🏠 Repository: ${responseData.repository}`));
-              }
-              if (responseData.actor) {
-                console.log(chalk.blue(`👤 Submitted by: ${responseData.actor}`));
-              }
-            } catch (parseError) {
-              // If response is not JSON, show raw response
+        if (!options.quiet && uploadResult.response) {
+          try {
+            const responseData = JSON.parse(uploadResult.response);
+            if (responseData.message) {
+              console.log(chalk.blue(`💬 Server response: ${responseData.message}`));
+            }
+            if (responseData.report_id) {
+              console.log(chalk.blue(`📝 Report ID: ${responseData.report_id}`));
+            }
+            if (responseData.repository) {
+              console.log(chalk.blue(`🏠 Repository: ${responseData.repository}`));
+            }
+            if (responseData.actor) {
+              console.log(chalk.blue(`👤 Submitted by: ${responseData.actor}`));
+            }
+          } catch (parseError) {
+            // If response is not JSON, show raw response if verbose
+            if (options.verbose) {
               console.log(chalk.gray(`📄 Response: ${uploadResult.response.substring(0, 200)}...`));
             }
           }
         }
       } else {
-        console.warn(chalk.yellow(`⚠️  Failed to upload report: ${uploadResult.error}`));
-        
+        // Error already logged in upload-service.js
         if (options.verbose && uploadResult.errorContext) {
           console.warn('Upload error details:', uploadResult.errorContext);
         }

package/core/rule-selection-service.js

@@ -2,6 +2,7 @@
  * Rule Selection Service
  * Following Rule C005: Single responsibility - only handle rule selection
  * REFACTORED: Now uses SunlintRuleAdapter instead of direct registry access
+ * UPDATED: Load rules from released-rules.json for consistency
  */
 
 const chalk = require('chalk');
@@ -15,6 +16,8 @@ class RuleSelectionService {
     this.ruleAdapter = SunlintRuleAdapter.getInstance();
     this.ruleMappingService = new RuleMappingService();
     this.initialized = false;
+    // Path works both in dev (from pages/) and npm package (from config/)
+    this.releasedRulesPath = path.join(__dirname, '../config/released-rules.json');
   }
 
   async initialize() {
@@ -24,55 +27,102 @@ class RuleSelectionService {
     }
   }
 
+  /**
+   * Load released rules from released-rules.json
+   * @param {string} [version] - Version to load (default: latest)
+   * @returns {Object} Object with Common, Security arrays
+   */
+  loadReleasedRules(version = null) {
+    try {
+      if (!fs.existsSync(this.releasedRulesPath)) {
+        return null;
+      }
+
+      const data = JSON.parse(fs.readFileSync(this.releasedRulesPath, 'utf8'));
+      const versions = data.versions || [];
+
+      if (versions.length === 0) {
+        return null;
+      }
+
+      // Get specified version or latest
+      const targetVersion = version
+        ? versions.find(v => v.version === version)
+        : versions[versions.length - 1]; // Latest version
+
+      if (!targetVersion) {
+        return null;
+      }
+
+      return targetVersion.rulesByCategory;
+    } catch (error) {
+      return null;
+    }
+  }
+
   async selectRules(config, options) {
     // Ensure adapter is initialized
     await this.initialize();
-    
+
     const allRules = config.rules || {};
     let selectedRules = [];
 
+    // Try to load from released-rules.json first
+    const releasedRules = this.loadReleasedRules();
+
     // Determine rule selection strategy
     if (options.rule) {
       selectedRules = [options.rule];
     } else if (options.rules) {
       selectedRules = options.rules.split(',').map(r => r.trim());
     } else if (options.all) {
-      // Handle --all shortcut (load from preset file)
-      selectedRules = this.loadPresetRules('all');
-      
-      if (options.verbose) {
-        console.log(chalk.blue(`📋 Selected ${selectedRules.length} rules from all preset file`));
+      // Load all rules from released-rules.json
+      if (releasedRules) {
+        selectedRules = [
+          ...(releasedRules.Common || []),
+          ...(releasedRules.Security || []),
+          ...(releasedRules.Frontend || []),
+          ...(releasedRules.Backend || []),
+          ...(releasedRules.Mobile || [])
+        ];
+      } else {
+        // Fallback to preset file
+        selectedRules = this.loadPresetRules('all');
       }
     } else if (options.quality) {
-      // Handle --quality shortcut (load from preset file)
-      selectedRules = this.loadPresetRules('quality');
-      
-      if (options.verbose) {
-        console.log(chalk.blue(`📋 Selected ${selectedRules.length} quality rules from preset file`));
+      // Load Common rules from released-rules.json
+      if (releasedRules && releasedRules.Common) {
+        selectedRules = releasedRules.Common;
+      } else {
+        selectedRules = this.loadPresetRules('quality');
       }
     } else if (options.security) {
-      // Handle --security shortcut (load from preset file)
-      selectedRules = this.loadPresetRules('security');
-      
-      if (options.verbose) {
-        console.log(chalk.blue(`📋 Selected ${selectedRules.length} security rules from preset file`));
+      // Load Security rules from released-rules.json
+      if (releasedRules && releasedRules.Security) {
+        selectedRules = releasedRules.Security;
+      } else {
+        selectedRules = this.loadPresetRules('security');
       }
     } else if (options.category) {
       // Handle --category shortcut (standardized approach)
       const categoryRules = this.ruleAdapter.getStandardCategoryRules(options.category);
       selectedRules = categoryRules.map(rule => rule.id);
-      
-      if (options.verbose) {
-        console.log(chalk.blue(`📋 Selected ${selectedRules.length} ${options.category} rules from core files`));
-      }
     } else {
-      // Default: use config rules or minimal set
-      selectedRules = Object.keys(allRules).filter(ruleId => 
-        allRules[ruleId] !== 'off' && allRules[ruleId] !== false
-      );
-      
-      if (selectedRules.length === 0) {
-        selectedRules = ['C006', 'C019']; // Default minimal set
+      // Default: load all from released-rules.json
+      if (releasedRules) {
+        selectedRules = [
+          ...(releasedRules.Common || []),
+          ...(releasedRules.Security || [])
+        ];
+      } else {
+        // Fallback to config rules or minimal set
+        selectedRules = Object.keys(allRules).filter(ruleId =>
+          allRules[ruleId] !== 'off' && allRules[ruleId] !== false
+        );
+
+        if (selectedRules.length === 0) {
+          selectedRules = ['C006', 'C019']; // Default minimal set
+        }
       }
     }
 

package/core/scoring-service.js

@@ -10,19 +10,50 @@ const path = require('path');
 
 class ScoringService {
   constructor() {
-    // Scoring weights
+    // Scoring weights based on violations per KLOC (1000 lines)
+    //
+    // Calibration targets:
+    //   - 0 violations/KLOC = 100 (A+)
+    //   - 1-2 violations/KLOC = 90-95 (A/A+)
+    //   - 3-4 violations/KLOC = 80-89 (B/B+)
+    //   - 5-7 violations/KLOC = 70-79 (C/C+)
+    //   - 8-10 violations/KLOC = 60-69 (D)
+    //   - >10 violations/KLOC = <60 (F)
+    //
     this.weights = {
-      errorPenalty: 5,      // Each error reduces score by 5 points
-      warningPenalty: 1,    // Each warning reduces score by 1 point
-      ruleBonus: 0.5,       // Bonus for each rule checked
-      locFactor: 0.001      // Factor for normalizing by LOC
+      // Penalty per violation type (per KLOC)
+      // Errors are 3x more severe than warnings
+      errorPenaltyPerKLOC: 6,      // Each error per KLOC reduces score by 6 points
+      warningPenaltyPerKLOC: 2,    // Each warning per KLOC reduces score by 2 points
+
+      // Absolute penalty thresholds (regardless of LOC)
+      // Large projects should still be penalized for raw violation counts
+      absoluteErrorThreshold: 20,   // Start penalizing if errors > 20
+      absoluteErrorPenalty: 0.05,   // Each error above threshold reduces score by 0.05 (max 15 pts)
+
+      absoluteWarningThreshold: 100, // Start penalizing if warnings > 100
+      absoluteWarningPenalty: 0.01,  // Each warning above threshold reduces score by 0.01 (max 10 pts)
+    };
+
+    // Thresholds for violations per KLOC (used for grading reference)
+    this.thresholds = {
+      excellent: 1,    // < 1 violation per KLOC = excellent (A+/A)
+      good: 3,         // < 3 violations per KLOC = good (B+/B)
+      acceptable: 5,   // < 5 violations per KLOC = acceptable (C+/C)
+      poor: 10,        // < 10 violations per KLOC = poor (D)
+      // >= 10 = very poor (F)
     };
   }
 
   /**
    * Calculate quality score
-   * Score formula: 100 - (errorCount * 5 + warningCount * 1) * (1000 / LOC) + (rulesChecked * 0.5)
-   * 
+   *
+   * New formula (v2):
+   * 1. Calculate violations per KLOC (errorsPerKLOC, warningsPerKLOC)
+   * 2. Apply penalty based on density: errorsPerKLOC * 2 + warningsPerKLOC * 0.5
+   * 3. Apply absolute penalty for projects with too many errors
+   * 4. Add small bonus for rules checked
+   *
    * @param {Object} params
    * @param {number} params.errorCount - Number of errors found
    * @param {number} params.warningCount - Number of warnings found
@@ -34,20 +65,34 @@ class ScoringService {
     // Base score starts at 100
     let score = 100;
 
-    // Calculate violations penalty
-    const totalPenalty = (errorCount * this.weights.errorPenalty) + 
-                        (warningCount * this.weights.warningPenalty);
-
-    // Normalize penalty by LOC (per 1000 lines)
-    const locNormalization = loc > 0 ? 1000 / loc : 1;
-    const normalizedPenalty = totalPenalty * locNormalization;
-
-    // Apply penalty
-    score -= normalizedPenalty;
+    // Calculate KLOC (thousands of lines of code)
+    const kloc = Math.max(loc / 1000, 1); // Minimum 1 KLOC to avoid division issues
+
+    // Calculate violations per KLOC
+    const errorsPerKLOC = errorCount / kloc;
+    const warningsPerKLOC = warningCount / kloc;
+    const totalViolationsPerKLOC = errorsPerKLOC + warningsPerKLOC;
+
+    // 1. Density-based penalty (main scoring factor)
+    // This penalizes based on how "dense" the violations are
+    const densityPenalty = (errorsPerKLOC * this.weights.errorPenaltyPerKLOC) +
+                          (warningsPerKLOC * this.weights.warningPenaltyPerKLOC);
+    score -= densityPenalty;
+
+    // 2. Absolute penalty for projects with too many errors
+    // Even large codebases should not have hundreds of errors
+    if (errorCount > this.weights.absoluteErrorThreshold) {
+      const excessErrors = errorCount - this.weights.absoluteErrorThreshold;
+      const absoluteErrorPenalty = excessErrors * this.weights.absoluteErrorPenalty;
+      score -= Math.min(absoluteErrorPenalty, 15); // Cap at 15 points
+    }
 
-    // Add bonus for rules checked (more rules = more thorough check)
-    const ruleBonus = Math.min(rulesChecked * this.weights.ruleBonus, 10); // Max 10 points bonus
-    score += ruleBonus;
+    // 3. Absolute penalty for projects with too many warnings
+    if (warningCount > this.weights.absoluteWarningThreshold) {
+      const excessWarnings = warningCount - this.weights.absoluteWarningThreshold;
+      const absoluteWarningPenalty = excessWarnings * this.weights.absoluteWarningPenalty;
+      score -= Math.min(absoluteWarningPenalty, 10); // Cap at 10 points
+    }
 
     // Ensure score is between 0-100
     score = Math.max(0, Math.min(100, score));