@sun-asterisk/sunlint 1.3.19 → 1.3.21

package/core/output-service.js

@@ -28,54 +28,67 @@ class OutputService {
     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.21';
     } catch (error) {
-      return '1.3.18'; // Fallback version
+      return '1.3.21'; // Fallback version
     }
   }
 
 
   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}`));
 
-      // Annotate GitHub nếu đủ điều kiện
-      if (options.githubAnnotate && options.format === 'json') {
-        try {
-          const annotate = require('./github-annotate-service').annotate;
-          // Lấy các biến môi trường cần thiết cho annotate
-          const repo = process.env.GITHUB_REPOSITORY || options.githubRepo;
-          const prNumber = process.env.GITHUB_PR_NUMBER ? parseInt(process.env.GITHUB_PR_NUMBER) : options.githubPrNumber;
-          const githubToken = process.env.GITHUB_TOKEN || options.githubToken;
-          if (repo && prNumber && githubToken) {
-            await annotate({
-              jsonFile: options.output,
-              githubToken,
-              repo,
-              prNumber
-            });
-            console.log(chalk.green('✅ Annotated GitHub PR with SunLint results.'));
-          } else {
-            console.log(chalk.yellow('⚠️  Missing GITHUB_REPOSITORY, GITHUB_PR_NUMBER, or GITHUB_TOKEN for GitHub annotation.'));
-          }
-        } catch (err) {
-          console.log(chalk.red('❌ Failed to annotate GitHub PR:'), err.message);
+      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)
     if (options.outputSummary) {
       const summaryReport = this.generateAndSaveSummaryReport(
@@ -499,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;