@sun-asterisk/sunlint 1.3.34 → 1.3.36

package/core/git-utils.js

@@ -186,13 +186,19 @@ class GitUtils {
     try {
       const { baseBranch, provider } = prContext;
 
-      console.log(`🔍 Detecting changed files for PR (provider: ${provider}, base: ${baseBranch})`);
+      // Professional output header
+      console.log('');
+      console.log('┌─ Git Integration ────────────────────────────────────');
+      console.log(`│  Provider: ${provider.toUpperCase()}`);
+      console.log(`│  Base:     ${baseBranch}`);
+      console.log('├──────────────────────────────────────────────────────');
 
       // Try to find the base branch reference
       let baseRef = this.findBaseRef(baseBranch, gitRoot);
 
       if (!baseRef) {
-        console.log(`⚠️  Base ref not found locally, attempting to fetch origin/${baseBranch}...`);
+        console.log(`│  ⚠ Base ref not found locally`);
+        console.log(`│  → Fetching origin/${baseBranch}...`);
 
         // Try to fetch and create the ref
         const fetchSuccess = this.ensureBaseRefExists(`origin/${baseBranch}`, gitRoot);
@@ -200,11 +206,12 @@ class GitUtils {
         if (fetchSuccess) {
           baseRef = `origin/${baseBranch}`;
         } else {
+          console.log('└──────────────────────────────────────────────────────');
           throw new Error(`Cannot find or fetch base branch: ${baseBranch}`);
         }
       } else {
         // Ensure we have the latest
-        console.log(`✅ Found base ref: ${baseRef}`);
+        console.log(`│  ✓ Base ref: ${baseRef}`);
         this.ensureBaseRefExists(baseRef, gitRoot);
       }
 
@@ -215,10 +222,10 @@ class GitUtils {
           cwd: gitRoot,
           encoding: 'utf8'
         }).trim();
-        console.log(`✅ Found merge-base: ${mergeBase.substring(0, 8)}`);
+        console.log(`│  ✓ Merge-base: ${mergeBase.substring(0, 8)}`);
       } catch (error) {
         // If merge-base fails, fall back to direct comparison
-        console.warn(`⚠️  Could not find merge-base, using direct diff with ${baseRef}`);
+        console.log(`│  ⚠ Merge-base not found, using direct diff`);
         mergeBase = baseRef;
       }
 
@@ -232,7 +239,10 @@ class GitUtils {
         .map(file => path.resolve(gitRoot, file))
         .filter(file => fs.existsSync(file));
 
-      console.log(`✅ Found ${changedFiles.length} changed files in PR`);
+      console.log('├──────────────────────────────────────────────────────');
+      console.log(`│  Changed files: ${changedFiles.length}`);
+      console.log('└──────────────────────────────────────────────────────');
+      console.log('');
 
       return changedFiles;
     } catch (error) {
@@ -290,13 +300,11 @@ class GitUtils {
 
       if (remote === 'origin' || remote === 'upstream') {
         try {
-          console.log(`⬇️  Fetching ${remote}/${branch}...`);
-
           // Check if this is a shallow repository (common in GitHub Actions)
           const isShallow = this.isShallowRepository(gitRoot);
 
           if (isShallow) {
-            console.log(`   ℹ️  Detected shallow clone, fetching with additional history...`);
+            console.log(`│  → Shallow clone detected, deepening...`);
 
             // For shallow clones, we need to:
             // 1. Fetch the base branch
@@ -317,7 +325,6 @@ class GitUtils {
               });
             } catch (shallowError) {
               // If deepen fails, try direct fetch
-              console.log(`   ℹ️  Trying direct fetch...`);
               execSync(`git fetch ${remote} ${branch}`, {
                 cwd: gitRoot,
                 stdio: 'pipe',
@@ -339,10 +346,10 @@ class GitUtils {
             stdio: 'ignore'
           });
 
-          console.log(`✅ Successfully fetched ${baseRef}`);
+          console.log(`│  ✓ Fetched ${baseRef}`);
           return true;
         } catch (fetchError) {
-          console.warn(`⚠️  Failed to fetch ${baseRef}: ${fetchError.message}`);
+          console.log(`│  ✗ Failed to fetch: ${fetchError.message}`);
           return false;
         }
       }

package/core/github-annotate-service.js

@@ -71,9 +71,10 @@ function sleep(ms) {
  * @returns {Promise<string|null>} AI-generated summary or null
  */
 async function generateAISummary(violations, stats) {
-  const token = process.env.GITHUB_TOKEN;
+  // Prefer GH_MODELS_TOKEN (PAT with Models access) over GITHUB_TOKEN
+  const token = process.env.GH_MODELS_TOKEN || process.env.GITHUB_TOKEN;
   if (!token) {
-    logger.debug('No GITHUB_TOKEN, skipping AI summary');
+    logger.debug('No GitHub token available, skipping AI summary');
     return null;
   }
 
@@ -96,7 +97,7 @@ async function generateAISummary(violations, stats) {
       ruleGroups[v.rule] = (ruleGroups[v.rule] || 0) + 1;
     }
 
-    const prompt = `You are a code review assistant. Analyze these code quality violations and provide a brief, actionable summary in 2-3 sentences.
+    const prompt = `You are a code review assistant. Analyze these code quality violations and provide a verdict and brief summary.
 
 Violations by rule:
 ${Object.entries(ruleGroups).map(([rule, count]) => `- ${rule}: ${count} issues`).join('\n')}
@@ -106,10 +107,19 @@ ${topViolations.slice(0, 5).map(v => `- [${v.rule}] ${v.file}: ${v.message}`).jo
 
 Stats: ${stats.errorCount} errors, ${stats.warningCount} warnings in ${stats.filesWithIssues} files.
 
-Provide a concise summary focusing on:
-1. Main patterns/issues found
-2. Priority areas to fix
-Keep it under 100 words, no markdown headers.`;
+Your response MUST start with one of these verdicts on its own line:
+- "🚫 REQUIRES FIXES" - if there are errors or critical issues that must be fixed before merging
+- "⚠️ NEEDS ATTENTION" - if there are warnings that should be reviewed but not blocking
+- "✅ READY TO MERGE" - if issues are minor or acceptable
+
+Then provide 2-3 sentences about:
+1. Main issues found
+2. Priority areas to address
+
+Keep it under 120 words total.`;
+
+    const tokenSource = process.env.GH_MODELS_TOKEN ? 'GH_MODELS_TOKEN' : 'GITHUB_TOKEN';
+    logger.info(`Generating AI summary via GitHub Models API (using ${tokenSource})...`);
 
     const response = await fetch('https://models.inference.ai.azure.com/chat/completions', {
       method: 'POST',
@@ -126,7 +136,8 @@ Keep it under 100 words, no markdown headers.`;
     });
 
     if (!response.ok) {
-      logger.debug(`GitHub Models API error: ${response.status}`);
+      const errorText = await response.text().catch(() => 'Unknown error');
+      logger.warn(`GitHub Models API error: ${response.status} - ${errorText}`);
       return null;
     }
 
@@ -138,13 +149,106 @@ Keep it under 100 words, no markdown headers.`;
       return aiSummary;
     }
 
+    logger.warn('AI summary response empty');
     return null;
   } catch (error) {
-    logger.debug(`AI summary generation failed: ${error.message}`);
+    logger.warn(`AI summary generation failed: ${error.message}`);
     return null;
   }
 }
 
+/**
+ * Format AI summary for better readability
+ * @param {string} summary - Raw AI summary text
+ * @returns {string} Formatted summary with highlights
+ */
+function formatAISummary(summary) {
+  if (!summary) return '';
+
+  let formatted = summary;
+  let verdictLine = '';
+
+  // Extract verdict from first line
+  const lines = formatted.split('\n');
+  const firstLine = lines[0].trim();
+
+  if (firstLine.includes('REQUIRES FIXES') || firstLine.includes('🚫')) {
+    verdictLine = '> 🚫 **REQUIRES FIXES** - Critical issues must be resolved before merging\n\n';
+    formatted = lines.slice(1).join('\n').trim();
+  } else if (firstLine.includes('NEEDS ATTENTION') || firstLine.includes('⚠️')) {
+    verdictLine = '> ⚠️ **NEEDS ATTENTION** - Review recommended but not blocking\n\n';
+    formatted = lines.slice(1).join('\n').trim();
+  } else if (firstLine.includes('READY TO MERGE') || firstLine.includes('✅')) {
+    verdictLine = '> ✅ **READY TO MERGE** - Code quality meets standards\n\n';
+    formatted = lines.slice(1).join('\n').trim();
+  }
+
+  // Highlight rule IDs (C001, C019, etc.)
+  formatted = formatted.replace(/\b(C\d{3})\b/g, '`$1`');
+
+  // Highlight severity words
+  formatted = formatted.replace(/\b(critical|high|error|errors)\b/gi, '**$1**');
+  formatted = formatted.replace(/\b(warning|warnings|medium)\b/gi, '*$1*');
+
+  // Split into sentences and format as list if multiple sentences
+  const sentences = formatted.split(/(?<=[.!?])\s+/).filter(s => s.trim());
+
+  if (sentences.length > 1) {
+    // Format as bullet points
+    const mainIssues = [];
+    const recommendations = [];
+
+    for (const sentence of sentences) {
+      const lower = sentence.toLowerCase();
+      if (lower.includes('prioritize') || lower.includes('focus') || lower.includes('recommend') || lower.includes('should')) {
+        recommendations.push(sentence.trim());
+      } else {
+        mainIssues.push(sentence.trim());
+      }
+    }
+
+    let result = verdictLine;
+
+    if (mainIssues.length > 0) {
+      result += '**🔍 Issues Found:**\n';
+      for (const issue of mainIssues) {
+        result += `- ${issue}\n`;
+      }
+    }
+
+    if (recommendations.length > 0) {
+      result += '\n**💡 Recommendations:**\n';
+      for (const rec of recommendations) {
+        result += `- ${rec}\n`;
+      }
+    }
+
+    return result || verdictLine + formatted;
+  }
+
+  return verdictLine + (formatted ? `> ${formatted}` : '');
+}
+
+/**
+ * Generate a visual score bar using Unicode blocks
+ * @param {number} score - Score from 0-100
+ * @returns {string} Visual progress bar
+ */
+function generateScoreBar(score) {
+  const total = 20;
+  const filled = Math.round((score / 100) * total);
+  const empty = total - filled;
+
+  // Use different colors based on score
+  let color;
+  if (score >= 80) color = '🟩';
+  else if (score >= 60) color = '🟨';
+  else if (score >= 40) color = '🟧';
+  else color = '🟥';
+
+  return color.repeat(filled) + '⬜'.repeat(empty);
+}
+
 /**
  * Calculate quality score from violations
  * @param {number} errorCount - Number of errors
@@ -1030,8 +1134,8 @@ async function postSummaryComment({
 
       // AI Summary (if available)
       if (aiSummary) {
-        summary += `#### 🤖 AI Analysis\n`;
-        summary += `${aiSummary}\n\n`;
+        summary += `#### 🧠 AI Analysis\n\n`;
+        summary += `${formatAISummary(aiSummary)}\n\n`;
       }
 
       // Compact summary table
@@ -1142,9 +1246,220 @@ async function postSummaryComment({
   }
 }
 
+/**
+ * Post combined summary comment on GitHub PR (Code Quality + Architecture + Impact)
+ * @param {Object} options
+ * @param {string} [options.githubToken] - GitHub token, falls back to GITHUB_TOKEN env
+ * @param {string} options.repo - GitHub repo in format owner/repo
+ * @param {number} options.prNumber - Pull request number
+ * @param {Object} [options.codeQuality] - Code quality results
+ * @param {Object} [options.architecture] - Architecture detection results
+ * @param {Object} [options.impact] - Impact analysis results
+ * @returns {Promise<Object>} Result object
+ */
+async function postCombinedSummaryComment({
+  githubToken,
+  repo,
+  prNumber,
+  codeQuality = null,
+  architecture = null,
+  impact = null
+}) {
+  const startTime = Date.now();
+
+  try {
+    logger.info('Starting combined summary comment', { repo, prNumber });
+
+    // Validate basic params
+    const token = githubToken || process.env.GITHUB_TOKEN;
+    if (!token) {
+      throw new ValidationError('githubToken is required or GITHUB_TOKEN env var must be set');
+    }
+    if (!repo || !repo.includes('/')) {
+      throw new ValidationError('repo must be in format "owner/repo"');
+    }
+    if (!prNumber || prNumber <= 0) {
+      throw new ValidationError('prNumber must be a positive integer');
+    }
+
+    const [owner, repoName] = repo.split('/');
+
+    if (!Octokit) {
+      Octokit = (await import('@octokit/rest')).Octokit;
+    }
+    const octokit = new Octokit({ auth: token });
+
+    // Build combined summary - Clean minimal style with logo
+    let summary = `## <a href="https://coding-standards.sun-asterisk.vn/"><img src="https://coding-standards.sun-asterisk.vn/logo-light.svg" alt="SunLint" height="28"></a> Code Quality Analysis\n\n`;
+
+    // === Quality Score Section ===
+    if (codeQuality) {
+      const { errorCount = 0, warningCount = 0, filesWithIssues = 0, totalViolations = 0, score = {} } = codeQuality;
+      const qualityScore = typeof score.value === 'number' && !isNaN(score.value) ? score.value : 0;
+      const grade = score.grade || 'F';
+
+      // Grade emoji and description based on score
+      let gradeEmoji, gradeDesc;
+      if (qualityScore >= 90) {
+        gradeEmoji = '🏆'; gradeDesc = 'Excellent';
+      } else if (qualityScore >= 80) {
+        gradeEmoji = '✨'; gradeDesc = 'Good';
+      } else if (qualityScore >= 70) {
+        gradeEmoji = '👍'; gradeDesc = 'Fair';
+      } else if (qualityScore >= 60) {
+        gradeEmoji = '⚡'; gradeDesc = 'Needs Work';
+      } else {
+        gradeEmoji = '🔧'; gradeDesc = 'Needs Improvement';
+      }
+
+      // Clean score display
+      summary += `### Quality Score: **${qualityScore}/100** · Grade: ${gradeEmoji} ${grade} (${gradeDesc})\n\n`;
+
+      // Issue summary
+      if (errorCount === 0 && warningCount === 0) {
+        summary += `✅ **No issues found!** Great job!\n\n`;
+      } else {
+        summary += `| | Count |\n`;
+        summary += `|:--|--:|\n`;
+        if (errorCount > 0) {
+          summary += `| ❌ Errors | **${errorCount}** |\n`;
+        }
+        if (warningCount > 0) {
+          summary += `| ⚠️ Warnings | ${warningCount} |\n`;
+        }
+        summary += `| 📁 Files with issues | ${filesWithIssues} |\n\n`;
+      }
+
+      // AI Summary (if available)
+      if (codeQuality.aiSummary) {
+        summary += `#### 🧠 AI Analysis\n\n`;
+        summary += `${formatAISummary(codeQuality.aiSummary)}\n\n`;
+      }
+    }
+
+    // === Additional Metrics (Direct display) ===
+    if (architecture || impact) {
+      // Architecture section
+      if (architecture) {
+        const { pattern, confidence, healthScore, violations = [] } = architecture;
+        const patternDisplay = pattern ? pattern.toUpperCase() : 'UNKNOWN';
+        const confidenceDisplay = confidence !== undefined ? confidence : 0;
+        const healthDisplay = healthScore !== undefined ? healthScore : 0;
+        const healthIcon = healthDisplay >= 80 ? '🟢' : healthDisplay >= 60 ? '🟡' : '🔴';
+
+        summary += `#### 🏛️ Architecture\n\n`;
+        summary += `| Pattern | Confidence | Health |\n`;
+        summary += `|:--|:--:|:--:|\n`;
+        summary += `| **${patternDisplay}** | ${confidenceDisplay}% | ${healthIcon} ${healthDisplay}/100 |\n\n`;
+
+        if (violations.length > 0) {
+          summary += `⚠️ ${violations.length} architecture violations detected\n\n`;
+        }
+      }
+
+      // Impact section
+      if (impact) {
+        const { score: impactScore = 0, severity = 'LOW', endpoints = [], tables = [] } = impact;
+        const severityIcon = severity === 'HIGH' ? '🔴' : severity === 'MEDIUM' ? '🟡' : '🟢';
+
+        summary += `#### 🎯 Impact Analysis\n\n`;
+        summary += `| Severity | Score | Affected |\n`;
+        summary += `|:--|:--:|:--|\n`;
+
+        let affectedItems = [];
+        if (endpoints.length > 0) affectedItems.push(`${endpoints.length} APIs`);
+        if (tables.length > 0) affectedItems.push(`${tables.length} tables`);
+        const affectedText = affectedItems.length > 0 ? affectedItems.join(', ') : 'None';
+
+        summary += `| ${severityIcon} **${severity}** | ${impactScore}/100 | ${affectedText} |\n\n`;
+      }
+    }
+
+    // === Footer ===
+    summary += `---\n`;
+    summary += `<sub>`;
+    summary += `Powered by [SunLint](https://coding-standards.sun-asterisk.vn)`;
+
+    if (process.env.GITHUB_RUN_ID) {
+      const runUrl = `https://github.com/${repo}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+      summary += ` · [View Details](${runUrl})`;
+    }
+    summary += `</sub>\n`;
+
+    // Find existing comment
+    let existingComment = null;
+    try {
+      const { data: comments } = await octokit.issues.listComments({
+        owner,
+        repo: repoName,
+        issue_number: prNumber,
+        per_page: 100
+      });
+
+      existingComment = comments.find(comment =>
+        comment.body.includes('Code Quality Analysis') ||
+        comment.body.includes('☀️ SunLint') ||
+        comment.body.includes('SunLint Analysis Report') ||
+        comment.body.includes('SunLint Report')
+      );
+    } catch (error) {
+      logger.warn('Failed to fetch existing comments', { error: error.message });
+    }
+
+    // Post or update comment
+    let commentResult;
+    try {
+      if (existingComment) {
+        commentResult = await withRetry(async () => {
+          return await octokit.issues.updateComment({
+            owner,
+            repo: repoName,
+            comment_id: existingComment.id,
+            body: summary
+          });
+        });
+        logger.info('Combined summary updated');
+      } else {
+        commentResult = await withRetry(async () => {
+          return await octokit.issues.createComment({
+            owner,
+            repo: repoName,
+            issue_number: prNumber,
+            body: summary
+          });
+        });
+        logger.info('Combined summary created');
+      }
+    } catch (error) {
+      throw new GitHubAPIError(
+        `Failed to post combined summary: ${error.message}`,
+        error.status,
+        error
+      );
+    }
+
+    return {
+      success: true,
+      action: existingComment ? 'updated' : 'created',
+      commentId: commentResult.data.id,
+      commentUrl: commentResult.data.html_url,
+      duration: Date.now() - startTime
+    };
+
+  } catch (error) {
+    logger.error('Combined summary failed', error);
+    if (error instanceof ValidationError || error instanceof GitHubAPIError) {
+      throw error;
+    }
+    throw new Error(`Combined summary failed: ${error.message}`);
+  }
+}
+
 module.exports = {
   annotate,
   postSummaryComment,
+  postCombinedSummaryComment,
+  generateAISummary,
   ValidationError,
   GitHubAPIError
 };