@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/core/output-service.js

@@ -86,7 +86,8 @@ class OutputService {
       await this._handleGitHubAnnotation(
         githubAnnotateConfig,
         outputFile,
-        shouldCleanupTempFile
+        shouldCleanupTempFile,
+        results  // Pass full results for combined summary
       );
     }
 
@@ -111,6 +112,11 @@ class OutputService {
       }
     }
 
+    // HTML report output (--output-html option)
+    if (options.outputHtml) {
+      await this._generateLocalHTMLReport(report.violations, results, options, metadata);
+    }
+
     // Summary (skip for JSON format)
     if (!options.quiet && options.format !== 'json') {
       console.log(report.summary);
@@ -333,7 +339,7 @@ class OutputService {
 
   formatViolations(violations) {
     if (violations.length === 0) {
-      return chalk.green('✅ No violations found!');
+      return ''; // Summary already shown by orchestrator
     }
 
     let output = '';
@@ -398,22 +404,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;
@@ -683,12 +690,16 @@ class OutputService {
    * @param {Object} config - GitHub annotation configuration
    * @param {string} outputFile - Path to report file
    * @param {boolean} shouldCleanup - Whether to cleanup temp file
+   * @param {Object} analysisResults - Full analysis results (includes architecture, impact)
    * @private
    */
-  async _handleGitHubAnnotation(config, outputFile, shouldCleanup) {
+  async _handleGitHubAnnotation(config, outputFile, shouldCleanup, analysisResults = {}) {
     const mode = config.mode || 'all';
     const results = {};
 
+    // Define codeQualityData at function scope so it's accessible in HTML generation
+    let codeQualityData = null;
+
     try {
       console.log(chalk.blue(`🔄 GitHub PR annotation mode: ${mode}`));
 
@@ -701,12 +712,17 @@ class OutputService {
       }
 
       // Import services
-      const { annotate, postSummaryComment } = require('./github-annotate-service');
+      const { annotate, postSummaryComment, postCombinedSummaryComment, generateAISummary } = require('./github-annotate-service');
 
       // Execute based on mode
       const shouldAnnotate = mode === 'annotate' || mode === 'all';
       const shouldSummary = mode === 'summary' || mode === 'all';
 
+      // Check if we have architecture or impact results for combined summary
+      const hasArchitecture = analysisResults.architecture != null;
+      const hasImpact = analysisResults.impact != null;
+      const useCombinedSummary = hasArchitecture || hasImpact;
+
       // 1. Inline comments (annotate mode)
       if (shouldAnnotate) {
         try {
@@ -742,21 +758,63 @@ class OutputService {
       if (shouldSummary) {
         try {
           console.log(chalk.blue('💬 Creating summary comment...'));
-          const summaryResult = await postSummaryComment({
-            jsonFile: outputFile,
-            githubToken: config.githubToken,
-            repo: config.repo,
-            prNumber: config.prNumber
-          });
+
+          let summaryResult;
+
+          if (useCombinedSummary) {
+            // Use combined summary with architecture and impact
+            codeQualityData = this._extractCodeQualityStats(outputFile, analysisResults);
+            const architectureData = hasArchitecture ? this._extractArchitectureStats(analysisResults.architecture) : null;
+            const impactData = hasImpact ? this._extractImpactStats(analysisResults.impact) : null;
+
+            // Generate AI summary for code quality
+            if (codeQualityData && codeQualityData.totalViolations > 0) {
+              try {
+                console.log(chalk.blue('🤖 Generating AI summary...'));
+                const violations = this._extractViolationsForAI(outputFile);
+                console.log(chalk.gray(`   Found ${violations.length} violations for AI analysis`));
+
+                const aiSummary = await generateAISummary(violations, {
+                  errorCount: codeQualityData.errorCount,
+                  warningCount: codeQualityData.warningCount,
+                  filesWithIssues: codeQualityData.filesWithIssues,
+                  totalViolations: codeQualityData.totalViolations
+                });
+
+                if (aiSummary) {
+                  codeQualityData.aiSummary = aiSummary;
+                  console.log(chalk.green('✅ AI summary generated'));
+                } else {
+                  console.log(chalk.yellow('⚠️  AI summary not available (API may not be accessible)'));
+                }
+              } catch (aiError) {
+                // AI summary is optional, continue without it
+                console.log(chalk.yellow(`⚠️  AI summary skipped: ${aiError.message}`));
+              }
+            }
+
+            summaryResult = await postCombinedSummaryComment({
+              githubToken: config.githubToken,
+              repo: config.repo,
+              prNumber: config.prNumber,
+              codeQuality: codeQualityData,
+              architecture: architectureData,
+              impact: impactData
+            });
+          } else {
+            // Use standard summary (code quality only)
+            summaryResult = await postSummaryComment({
+              jsonFile: outputFile,
+              githubToken: config.githubToken,
+              repo: config.repo,
+              prNumber: config.prNumber
+            });
+          }
 
           results.summary = summaryResult;
 
           if (summaryResult.success) {
             console.log(chalk.green(`✅ Summary comment: ${summaryResult.action}`));
-            if (summaryResult.stats) {
-              console.log(chalk.gray(`   • Total violations: ${summaryResult.stats.totalViolations}`));
-              console.log(chalk.gray(`   • Errors: ${summaryResult.stats.errorCount}, Warnings: ${summaryResult.stats.warningCount}`));
-            }
           }
         } catch (error) {
           console.log(chalk.red(`❌ Failed to create summary comment: ${error.message}`));
@@ -775,7 +833,9 @@ class OutputService {
         try {
           console.log(chalk.blue('📊 Generating full HTML report...'));
 
-          const htmlFile = this._generateHTMLReportFile(outputFile, config);
+          // Include AI summary if available
+          const aiSummary = useCombinedSummary && codeQualityData?.aiSummary ? codeQualityData.aiSummary : null;
+          const htmlFile = this._generateHTMLReportFile(outputFile, config, analysisResults, aiSummary);
 
           if (htmlFile) {
             results.htmlReport = { success: true, file: htmlFile };
@@ -906,14 +966,85 @@ class OutputService {
     return results;
   }
 
+  /**
+   * Generate HTML report locally (for --output-html option)
+   * @param {Array} violations - Array of violation objects
+   * @param {Object} analysisResults - Full analysis results
+   * @param {Object} options - CLI options
+   * @param {Object} metadata - Analysis metadata
+   * @private
+   */
+  async _generateLocalHTMLReport(violations, analysisResults, options, metadata) {
+    try {
+      console.log(chalk.blue('📊 Generating HTML report...'));
+
+      // Determine output file path
+      const outputPath = typeof options.outputHtml === 'string'
+        ? options.outputHtml
+        : 'sunlint-report.html';
+
+      // Calculate scoring summary
+      const errorCount = violations.filter(v => v.severity === 'error').length;
+      const warningCount = violations.filter(v => v.severity === 'warning').length;
+      const scoringSummary = this.scoringService.generateScoringSummary({
+        errorCount,
+        warningCount,
+        rulesChecked: options.rulesChecked || 1,
+        loc: metadata?.loc || 0
+      });
+
+      // Get git info
+      const gitInfo = this.summaryReportService.getGitInfo(process.cwd());
+
+      // Extract architecture and impact data
+      const architectureData = analysisResults.architecture ? {
+        pattern: analysisResults.architecture.primaryPattern || analysisResults.architecture.pattern || 'Unknown',
+        confidence: analysisResults.architecture.confidence || 0,
+        healthScore: analysisResults.architecture.healthScore || 0,
+        violations: analysisResults.architecture.violations || []
+      } : null;
+
+      const impactData = analysisResults.impact ? {
+        score: analysisResults.impact.score || 0,
+        severity: analysisResults.impact.severity || 'LOW',
+        endpoints: analysisResults.impact.endpoints || [],
+        tables: analysisResults.impact.tables || []
+      } : null;
+
+      // Generate HTML
+      const htmlGenerator = require('./html-report-generator');
+      const htmlContent = htmlGenerator.generateHTMLReport(violations, {
+        score: scoringSummary,
+        gitInfo: gitInfo,
+        timestamp: new Date().toISOString(),
+        architecture: architectureData,
+        impact: impactData,
+        aiSummary: null // AI summary not available in local mode without --github-annotate
+      });
+
+      // Write HTML file
+      const htmlFile = path.resolve(outputPath);
+      fs.writeFileSync(htmlFile, htmlContent, 'utf8');
+
+      console.log(chalk.green(`✅ HTML report generated: ${htmlFile}`));
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to generate HTML report: ${error.message}`));
+      if (process.env.DEBUG === 'true' && error.stack) {
+        console.error(chalk.gray('Error stack:'), error.stack);
+      }
+    }
+  }
+
   /**
    * Generate HTML report file
    * @param {string} jsonFile - Path to JSON report file
    * @param {Object} options - Generation options
+   * @param {Object} analysisResults - Full analysis results (including architecture and impact)
+   * @param {string} aiSummary - AI-generated summary text
    * @returns {string} Path to HTML report file
    * @private
    */
-  _generateHTMLReportFile(jsonFile, options = {}) {
+  _generateHTMLReportFile(jsonFile, options = {}, analysisResults = {}, aiSummary = null) {
     try {
       // Read JSON report
       const jsonContent = fs.readFileSync(jsonFile, 'utf8');
@@ -950,19 +1081,34 @@ class OutputService {
       // Get git info
       const gitInfo = this.summaryReportService.getGitInfo(process.cwd());
 
+      // Extract architecture and impact data
+      const architectureData = analysisResults.architecture ? {
+        pattern: analysisResults.architecture.primaryPattern || analysisResults.architecture.pattern || 'Unknown',
+        confidence: analysisResults.architecture.confidence || 0,
+        healthScore: analysisResults.architecture.healthScore || 0,
+        violations: analysisResults.architecture.violations || []
+      } : null;
+
+      const impactData = analysisResults.impact ? {
+        score: analysisResults.impact.score || 0,
+        severity: analysisResults.impact.severity || 'LOW',
+        endpoints: analysisResults.impact.endpoints || [],
+        tables: analysisResults.impact.tables || []
+      } : null;
+
       // Generate HTML
       const htmlGenerator = require('./html-report-generator');
       const htmlContent = htmlGenerator.generateHTMLReport(violations, {
         score: scoringSummary,
         gitInfo: gitInfo,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
+        architecture: architectureData,
+        impact: impactData,
+        aiSummary: aiSummary
       });
 
-      // Create HTML file in temp directory
-      const htmlFile = path.join(
-        process.env.RUNNER_TEMP || '/tmp',
-        `sunlint-full-report-${Date.now()}.html`
-      );
+      // Create HTML file in current directory (for GitHub Actions artifact upload)
+      const htmlFile = path.join(process.cwd(), 'sunlint-report.html');
 
       fs.writeFileSync(htmlFile, htmlContent, 'utf8');
 
@@ -996,6 +1142,133 @@ class OutputService {
       }
     }
   }
+
+  /**
+   * Extract code quality stats from JSON report
+   * @param {string} jsonFile - Path to JSON report file
+   * @param {Object} analysisResults - Full analysis results
+   * @returns {Object} Code quality stats for combined summary
+   * @private
+   */
+  _extractCodeQualityStats(jsonFile, analysisResults) {
+    try {
+      const jsonContent = fs.readFileSync(jsonFile, 'utf8');
+      const reportData = JSON.parse(jsonContent);
+
+      let errorCount = 0;
+      let warningCount = 0;
+      let filesWithIssues = 0;
+      let totalViolations = 0;
+
+      if (Array.isArray(reportData)) {
+        for (const fileObj of reportData) {
+          if (fileObj.messages && fileObj.messages.length > 0) {
+            filesWithIssues++;
+            for (const msg of fileObj.messages) {
+              totalViolations++;
+              if (msg.severity === 2) {
+                errorCount++;
+              } else {
+                warningCount++;
+              }
+            }
+          }
+        }
+      }
+
+      // Calculate score - use default values to prevent NaN
+      const score = this.scoringService.generateScoringSummary({
+        errorCount,
+        warningCount,
+        rulesChecked: 1,
+        loc: 1000 // Default 1 KLOC to prevent division issues
+      });
+
+      // Ensure score is a valid number
+      const scoreValue = typeof score.score === 'number' && !isNaN(score.score) ? score.score : 0;
+
+      return {
+        errorCount,
+        warningCount,
+        filesWithIssues,
+        totalViolations,
+        score: {
+          value: scoreValue,
+          grade: score.grade || 'F'
+        }
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Extract violations for AI summary generation
+   * @param {string} jsonFile - Path to JSON report file
+   * @returns {Array} Array of violation objects for AI
+   * @private
+   */
+  _extractViolationsForAI(jsonFile) {
+    try {
+      const jsonContent = fs.readFileSync(jsonFile, 'utf8');
+      const reportData = JSON.parse(jsonContent);
+      const violations = [];
+
+      if (Array.isArray(reportData)) {
+        for (const fileObj of reportData) {
+          if (fileObj.messages && fileObj.messages.length > 0) {
+            for (const msg of fileObj.messages) {
+              violations.push({
+                file: fileObj.filePath,
+                rule: msg.ruleId || 'unknown',
+                message: msg.message,
+                severity: msg.severity === 2 ? 'error' : 'warning'
+              });
+            }
+          }
+        }
+      }
+
+      return violations;
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Extract architecture stats from architecture results
+   * @param {Object} archResults - Architecture analysis results
+   * @returns {Object} Architecture stats for combined summary
+   * @private
+   */
+  _extractArchitectureStats(archResults) {
+    if (!archResults) return null;
+
+    return {
+      pattern: archResults.primaryPattern || archResults.pattern || 'Unknown',
+      confidence: archResults.confidence || 0,
+      healthScore: archResults.healthScore || archResults.score || 0,
+      violations: archResults.violations || []
+    };
+  }
+
+  /**
+   * Extract impact stats from impact analysis results
+   * @param {Object} impactResults - Impact analysis results
+   * @returns {Object} Impact stats for combined summary
+   * @private
+   */
+  _extractImpactStats(impactResults) {
+    if (!impactResults) return null;
+
+    return {
+      score: impactResults.score || impactResults.impactScore || 0,
+      severity: impactResults.severity || 'LOW',
+      endpoints: impactResults.endpoints || impactResults.affectedEndpoints || [],
+      tables: impactResults.tables || impactResults.affectedTables || [],
+      changedFiles: impactResults.changedFiles || impactResults.filesChanged || 0
+    };
+  }
 }
 
 module.exports = OutputService;

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

@@ -61,12 +61,13 @@ class ScoringService {
    * @param {number} params.loc - Total lines of code
    * @returns {number} Score between 0-100
    */
-  calculateScore({ errorCount, warningCount, rulesChecked, loc }) {
+  calculateScore({ errorCount = 0, warningCount = 0, rulesChecked = 0, loc = 0 }) {
     // Base score starts at 100
     let score = 100;
 
     // Calculate KLOC (thousands of lines of code)
-    const kloc = Math.max(loc / 1000, 1); // Minimum 1 KLOC to avoid division issues
+    // Default to 1 KLOC if loc is 0 or undefined to avoid NaN
+    const kloc = loc > 0 ? Math.max(loc / 1000, 1) : 1;
 
     // Calculate violations per KLOC
     const errorsPerKLOC = errorCount / kloc;