@sun-asterisk/sunlint 1.3.18 → 1.3.20

package/core/output-service.js

@@ -34,21 +34,59 @@ class OutputService {
     }
   }
 
+
   async outputResults(results, options, metadata = {}) {
-    // Generate report based on format
-    const report = this.generateReport(results, metadata, options);
+    // Handle GitHub annotation setup
+    const githubAnnotateConfig = this._prepareGitHubAnnotation(options);
+
+    // Generate report based on format (override format to json if github-annotate is enabled)
+    const effectiveFormat = githubAnnotateConfig.shouldAnnotate ? 'json' : options.format;
+    const report = this.generateReport(results, metadata, { ...options, format: effectiveFormat });
 
     // Console output
     if (!options.quiet) {
       console.log(report.formatted);
     }
 
+    // Determine output file (temp or user-specified)
+    let outputFile = options.output;
+    let shouldCleanupTempFile = false;
+
+    if (githubAnnotateConfig.shouldAnnotate && !outputFile) {
+      // Create temp file for GitHub annotation
+      outputFile = githubAnnotateConfig.tempFile;
+      shouldCleanupTempFile = true;
+      if (options.verbose) {
+        console.log(chalk.gray(`ℹ️  Created temporary report file for GitHub annotation: ${outputFile}`));
+      }
+    }
+
     // File output
-    if (options.output) {
-      const outputData = options.format === 'json' ? report.raw : report.formatted;
+    if (outputFile) {
+      const outputData = effectiveFormat === 'json' ? report.raw : report.formatted;
       const content = typeof outputData === 'string' ? outputData : JSON.stringify(outputData, null, 2);
-      fs.writeFileSync(options.output, content);
-      console.log(chalk.green(`📄 Report saved to: ${options.output}`));
+
+      try {
+        fs.writeFileSync(outputFile, content);
+        if (!shouldCleanupTempFile) {
+          console.log(chalk.green(`📄 Report saved to: ${outputFile}`));
+        }
+      } catch (error) {
+        console.error(chalk.red(`❌ Failed to write report file: ${error.message}`));
+        if (shouldCleanupTempFile) {
+          this._cleanupTempFile(outputFile);
+        }
+        throw error;
+      }
+    }
+
+    // GitHub annotation
+    if (githubAnnotateConfig.shouldAnnotate) {
+      await this._handleGitHubAnnotation(
+        githubAnnotateConfig,
+        outputFile,
+        shouldCleanupTempFile
+      );
     }
 
     // Summary report output (new feature for CI/CD)
@@ -474,6 +512,256 @@ class OutputService {
       };
     }
   }
+
+  /**
+   * Prepare GitHub annotation configuration
+   * Check environment and prerequisites
+   * @param {Object} options - CLI options
+   * @returns {Object} Configuration object
+   * @private
+   */
+  _prepareGitHubAnnotation(options) {
+    // Check if github-annotate flag is enabled
+    if (!options.githubAnnotate) {
+      return { shouldAnnotate: false };
+    }
+
+    // Parse mode: true/'all' -> all, 'annotate' -> annotate, 'summary' -> summary
+    let mode = 'all'; // default
+    if (typeof options.githubAnnotate === 'string') {
+      const validModes = ['annotate', 'summary', 'all'];
+      if (validModes.includes(options.githubAnnotate.toLowerCase())) {
+        mode = options.githubAnnotate.toLowerCase();
+      } else {
+        console.log(chalk.yellow(`⚠️  Invalid --github-annotate mode: ${options.githubAnnotate}. Using default: all`));
+      }
+    }
+
+    // Check if we're in a GitHub Actions environment
+    const isGitHubActions = process.env.GITHUB_ACTIONS === 'true';
+    if (!isGitHubActions) {
+      if (options.verbose) {
+        console.log(chalk.yellow('⚠️  --github-annotate only works in GitHub Actions environment'));
+      }
+      return { shouldAnnotate: false };
+    }
+
+    // Get GitHub environment variables
+    const eventName = process.env.GITHUB_EVENT_NAME;
+    const repo = process.env.GITHUB_REPOSITORY;
+    const githubToken = process.env.GITHUB_TOKEN || options.githubToken;
+
+    // Check if it's a PR event
+    const isPullRequestEvent = eventName === 'pull_request' || eventName === 'pull_request_target';
+
+    if (!isPullRequestEvent) {
+      if (options.verbose) {
+        console.log(chalk.yellow(`⚠️  GitHub annotation only works on pull_request events (current: ${eventName})`));
+      }
+      return { shouldAnnotate: false };
+    }
+
+    // Get PR number from GitHub context
+    let prNumber = null;
+    try {
+      // Try to get PR number from GITHUB_EVENT_PATH
+      const eventPath = process.env.GITHUB_EVENT_PATH;
+      if (eventPath && fs.existsSync(eventPath)) {
+        const event = JSON.parse(fs.readFileSync(eventPath, 'utf8'));
+        prNumber = event.pull_request?.number;
+      }
+    } catch (error) {
+      if (options.verbose) {
+        console.log(chalk.yellow(`⚠️  Failed to read GitHub event data: ${error.message}`));
+      }
+    }
+
+    // Fallback: try from environment variable
+    if (!prNumber && process.env.GITHUB_PR_NUMBER) {
+      prNumber = parseInt(process.env.GITHUB_PR_NUMBER, 10);
+    }
+
+    // Validate required data
+    if (!repo) {
+      console.log(chalk.yellow('⚠️  Missing GITHUB_REPOSITORY environment variable'));
+      return { shouldAnnotate: false };
+    }
+
+    if (!prNumber) {
+      console.log(chalk.yellow('⚠️  Could not determine PR number from GitHub context'));
+      return { shouldAnnotate: false };
+    }
+
+    if (!githubToken) {
+      console.log(chalk.yellow('⚠️  Missing GITHUB_TOKEN for authentication'));
+      return { shouldAnnotate: false };
+    }
+
+    // Generate temp file path if needed
+    const tempFile = path.join(
+      process.env.RUNNER_TEMP || '/tmp',
+      `sunlint-report-${Date.now()}-${Math.random().toString(36).substring(2, 11)}.json`
+    );
+
+    return {
+      shouldAnnotate: true,
+      mode,
+      repo,
+      prNumber,
+      githubToken,
+      tempFile,
+      eventName
+    };
+  }
+
+  /**
+   * Handle GitHub annotation process
+   * @param {Object} config - GitHub annotation configuration
+   * @param {string} outputFile - Path to report file
+   * @param {boolean} shouldCleanup - Whether to cleanup temp file
+   * @private
+   */
+  async _handleGitHubAnnotation(config, outputFile, shouldCleanup) {
+    const mode = config.mode || 'all';
+    const results = {};
+
+    try {
+      console.log(chalk.blue(`🔄 GitHub PR annotation mode: ${mode}`));
+
+      if (!config.repo || !config.prNumber || !config.githubToken) {
+        throw new Error('Missing required GitHub configuration');
+      }
+
+      if (!outputFile || !fs.existsSync(outputFile)) {
+        throw new Error(`Report file not found: ${outputFile}`);
+      }
+
+      // Import services
+      const { annotate, postSummaryComment } = require('./github-annotate-service');
+
+      // Execute based on mode
+      const shouldAnnotate = mode === 'annotate' || mode === 'all';
+      const shouldSummary = mode === 'summary' || mode === 'all';
+
+      // 1. Inline comments (annotate mode)
+      if (shouldAnnotate) {
+        try {
+          console.log(chalk.blue('📝 Creating inline comments...'));
+          const annotateResult = await annotate({
+            jsonFile: outputFile,
+            githubToken: config.githubToken,
+            repo: config.repo,
+            prNumber: config.prNumber,
+            skipDuplicates: true
+          });
+
+          results.annotate = annotateResult;
+
+          if (annotateResult.success) {
+            console.log(chalk.green(`✅ Inline comments: ${annotateResult.stats.commentsCreated} created`));
+            if (annotateResult.stats.duplicatesSkipped > 0) {
+              console.log(chalk.gray(`   • Duplicates skipped: ${annotateResult.stats.duplicatesSkipped}`));
+            }
+          }
+        } catch (error) {
+          console.log(chalk.red(`❌ Failed to create inline comments: ${error.message}`));
+          results.annotate = { success: false, error: error.message };
+
+          // Don't throw if we still need to create summary
+          if (!shouldSummary) {
+            throw error;
+          }
+        }
+      }
+
+      // 2. Summary comment (summary mode)
+      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
+          });
+
+          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}`));
+          results.summary = { success: false, error: error.message };
+
+          // Throw if both failed or if this is the only mode
+          if (!results.annotate || !results.annotate.success) {
+            throw error;
+          }
+        }
+      }
+
+      // Final summary
+      const successCount = [results.annotate?.success, results.summary?.success].filter(Boolean).length;
+      const totalCount = [shouldAnnotate, shouldSummary].filter(Boolean).length;
+
+      if (successCount === totalCount) {
+        console.log(chalk.green(`\n✅ Successfully annotated PR #${config.prNumber} (${successCount}/${totalCount} tasks completed)`));
+      } else if (successCount > 0) {
+        console.log(chalk.yellow(`\n⚠️  Partially completed (${successCount}/${totalCount} tasks successful)`));
+      } else {
+        console.log(chalk.red(`\n❌ Annotation failed`));
+      }
+
+    } catch (error) {
+      console.log(chalk.red(`\n❌ Failed to annotate GitHub PR: ${error.message}`));
+
+      // Log detailed error in verbose mode
+      if (process.env.DEBUG === 'true' && error.stack) {
+        console.error(chalk.gray('Error stack:'), error.stack);
+      }
+
+      // Show suggestions based on error type
+      if (error.name === 'ValidationError') {
+        console.log(chalk.yellow('💡 Hint: Check your GitHub environment variables'));
+      } else if (error.name === 'GitHubAPIError') {
+        console.log(chalk.yellow('💡 Hint: Check GitHub token permissions (needs pull-requests:write)'));
+      }
+
+    } finally {
+      // Cleanup temp file if needed
+      if (shouldCleanup) {
+        this._cleanupTempFile(outputFile);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Cleanup temporary file
+   * @param {string} filePath - Path to temp file
+   * @private
+   */
+  _cleanupTempFile(filePath) {
+    try {
+      if (filePath && fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        if (process.env.DEBUG === 'true') {
+          console.log(chalk.gray(`🗑️  Cleaned up temp file: ${filePath}`));
+        }
+      }
+    } catch (error) {
+      // Non-critical error, just log in debug mode
+      if (process.env.DEBUG === 'true') {
+        console.warn(chalk.yellow(`⚠️  Failed to cleanup temp file: ${error.message}`));
+      }
+    }
+  }
 }
 
 module.exports = OutputService;

package/core/summary-report-service.js

@@ -13,7 +13,7 @@ class SummaryReportService {
     // Load version from package.json
     this.version = this._loadVersion();
   }
-  
+
   /**
    * Load version from package.json
    * @returns {string} Package version
@@ -23,9 +23,9 @@ class SummaryReportService {
     try {
       const packageJsonPath = path.join(__dirname, '..', 'package.json');
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-      return packageJson.version || '1.3.18';
+      return packageJson.version || '1.3.19';
     } catch (error) {
-      return '1.3.18'; // Fallback version
+      return '1.3.19'; // Fallback version
     }
   }
 
@@ -154,44 +154,44 @@ class SummaryReportService {
     const gitInfo = this.getGitInfo(options.cwd);
 
     // Override with environment variables if available (from CI/CD)
-    const repository_url = process.env.GITHUB_REPOSITORY 
+    const repository_url = process.env.GITHUB_REPOSITORY
       ? `https://github.com/${process.env.GITHUB_REPOSITORY}`
       : gitInfo.repository_url;
-    
-    const repository_name = process.env.GITHUB_REPOSITORY 
+
+    const repository_name = process.env.GITHUB_REPOSITORY
       ? process.env.GITHUB_REPOSITORY.split('/')[1]
       : (gitInfo.repository_name || null);
-    
+
     const branch = process.env.GITHUB_REF_NAME || gitInfo.branch;
     const commit_hash = process.env.GITHUB_SHA || gitInfo.commit_hash;
-    
+
     // Get commit details from GitHub context or git
-    const commit_message = process.env.GITHUB_EVENT_HEAD_COMMIT_MESSAGE 
-      || (process.env.GITHUB_EVENT_PATH 
+    const commit_message = process.env.GITHUB_EVENT_HEAD_COMMIT_MESSAGE
+      || (process.env.GITHUB_EVENT_PATH
         ? this._getGitHubEventData('head_commit.message')
         : null)
       || gitInfo.commit_message;
-    
+
     const author_email = process.env.GITHUB_EVENT_HEAD_COMMIT_AUTHOR_EMAIL
-      || (process.env.GITHUB_EVENT_PATH 
+      || (process.env.GITHUB_EVENT_PATH
         ? this._getGitHubEventData('head_commit.author.email')
         : null)
       || gitInfo.author_email;
-    
+
     const author_name = process.env.GITHUB_EVENT_HEAD_COMMIT_AUTHOR_NAME
-      || (process.env.GITHUB_EVENT_PATH 
+      || (process.env.GITHUB_EVENT_PATH
         ? this._getGitHubEventData('head_commit.author.name')
         : null)
       || gitInfo.author_name;
-    
+
     // Get PR number from GitHub event or git
     let pr_number = null;
     if (process.env.GITHUB_EVENT_PATH) {
-      pr_number = this._getGitHubEventData('pull_request.number') 
+      pr_number = this._getGitHubEventData('pull_request.number')
         || this._getGitHubEventData('number');
     }
     pr_number = pr_number || gitInfo.pr_number;
-    
+
     // Get project path (for mono-repo support)
     const project_path = gitInfo.project_path;
 
@@ -203,20 +203,20 @@ class SummaryReportService {
       if (!violation || typeof violation !== 'object') {
         return; // Skip non-objects
       }
-      
+
       // Skip objects that look like metadata/config (have nested objects like semanticEngine, project, etc.)
       if (violation.semanticEngine || violation.project || violation.options) {
         return; // Skip config objects
       }
-      
+
       // Get ruleId from various possible fields
       const ruleId = violation.ruleId || violation.rule || 'unknown';
-      
+
       // Ensure ruleId is a string (not an object)
       if (typeof ruleId !== 'string') {
         return; // Skip invalid ruleId
       }
-      
+
       if (!violationsByRule[ruleId]) {
         violationsByRule[ruleId] = {
           rule_code: ruleId,
@@ -253,7 +253,7 @@ class SummaryReportService {
       sunlint_version: options.version || this.version,
       analysis_duration_ms: options.duration || 0,
       violations: violationsSummary,
-      
+
       // Additional metadata for backwards compatibility
       metadata: {
         generated_at: new Date().toISOString(),
@@ -283,11 +283,11 @@ class SummaryReportService {
       if (!eventPath || !fs.existsSync(eventPath)) {
         return null;
       }
-      
+
       const eventData = JSON.parse(fs.readFileSync(eventPath, 'utf8'));
       const keys = path.split('.');
       let value = eventData;
-      
+
       for (const key of keys) {
         if (value && typeof value === 'object' && key in value) {
           value = value[key];
@@ -295,7 +295,7 @@ class SummaryReportService {
           return null;
         }
       }
-      
+
       return value;
     } catch (error) {
       return null;
@@ -311,7 +311,7 @@ class SummaryReportService {
    */
   saveSummaryReport(violations, scoringSummary, outputPath, options = {}) {
     const summaryReport = this.generateSummaryReport(violations, scoringSummary, options);
-    
+
     // Ensure directory exists
     const dir = path.dirname(outputPath);
     if (!fs.existsSync(dir)) {
@@ -320,7 +320,7 @@ class SummaryReportService {
 
     // Write to file with pretty formatting
     fs.writeFileSync(outputPath, JSON.stringify(summaryReport, null, 2), 'utf8');
-    
+
     return summaryReport;
   }
 
@@ -340,7 +340,7 @@ class SummaryReportService {
     const warningCount = summaryReport.warning_count || 0;
     const violationsByRule = summaryReport.violations || [];
     const violationsPerKLOC = summaryReport.quality?.metrics?.violationsPerKLOC || 0;
-    
+
     let output = '\n📊 Quality Summary Report\n';
     output += '━'.repeat(50) + '\n';
     output += `📈 Quality Score: ${score} (Grade: ${grade})\n`;
@@ -348,14 +348,14 @@ class SummaryReportService {
     output += `📏 Lines of Code: ${linesOfCode.toLocaleString()}\n`;
     output += `⚠️  Total Violations: ${totalViolations} (${errorCount} errors, ${warningCount} warnings)\n`;
     output += `📊 Violations per KLOC: ${violationsPerKLOC}\n`;
-    
+
     if (violationsByRule.length > 0) {
       output += '\n🔍 Top Violations by Rule:\n';
       violationsByRule.slice(0, 10).forEach((item, index) => {
         output += `  ${index + 1}. ${item.rule_code}: ${item.count} violations (${item.severity})\n`;
       });
     }
-    
+
     return output;
   }
 }