@sun-asterisk/sunlint 1.3.21 → 1.3.23

package/core/analysis-orchestrator.js

@@ -196,13 +196,24 @@ class AnalysisOrchestrator {
 
       // Group rules by their preferred engines
       const engineGroups = this.groupRulesByEngine(optimizedRules, config);
-      
+
+      // Calculate total batches for progress tracking
+      let totalBatches = 0;
+      const engineBatchInfo = new Map();
+      for (const [engineName, rules] of engineGroups) {
+        const ruleBatches = this.performanceOptimizer.createRuleBatches(rules, config);
+        engineBatchInfo.set(engineName, ruleBatches);
+        totalBatches += ruleBatches.length;
+      }
+
       if (!options.quiet) {
-        console.log(chalk.cyan(`🚀 Running analysis across ${engineGroups.size} engines...`));
+        console.log(chalk.cyan(`🚀 Running analysis across ${engineGroups.size} engines (${totalBatches} batches total)...`));
       }
 
       // Run analysis on each engine with batching
       const results = [];
+      let completedBatches = 0;
+
       for (const [engineName, rules] of engineGroups) {
         const engine = this.engines.get(engineName);
         if (!engine) {
@@ -210,38 +221,44 @@ class AnalysisOrchestrator {
           continue;
         }
 
-        // Process rules in batches for performance
-        const ruleBatches = this.performanceOptimizer.createRuleBatches(rules, config);
-        
+        // Get pre-calculated batches
+        const ruleBatches = engineBatchInfo.get(engineName);
+
         for (let i = 0; i < ruleBatches.length; i++) {
           const batch = ruleBatches[i];
           const batchNumber = i + 1;
-          
-          if (!options.quiet && ruleBatches.length > 1) {
-            console.log(chalk.blue(`⚙️ ${engineName} - Batch ${batchNumber}/${ruleBatches.length}: ${batch.length} rules`));
-          } else if (!options.quiet) {
-            console.log(chalk.blue(`⚙️ Running ${batch.length} rules on ${engineName} engine...`));
+          const overallProgress = Math.round((completedBatches / totalBatches) * 100);
+
+          if (!options.quiet) {
+            if (ruleBatches.length > 1) {
+              console.log(chalk.blue(`⚙️ [${overallProgress}%] ${engineName} - Batch ${batchNumber}/${ruleBatches.length}: ${batch.length} rules (${optimizedFiles.length} files)`));
+            } else {
+              console.log(chalk.blue(`⚙️ [${overallProgress}%] Running ${batch.length} rules on ${engineName} engine (${optimizedFiles.length} files)...`));
+            }
           }
 
           try {
             const engineResult = await this.runEngineWithOptimizations(
-              engine, 
-              optimizedFiles, 
-              batch, 
+              engine,
+              optimizedFiles,
+              batch,
               options,
-              { batchNumber, totalBatches: ruleBatches.length }
+              { batchNumber, totalBatches: ruleBatches.length, overallProgress }
             );
-            
+
             results.push({
               engine: engineName,
               batch: batchNumber,
               rules: batch.map(r => r.id),
               ...engineResult
             });
-            
+
+            completedBatches++;
+            const newProgress = Math.round((completedBatches / totalBatches) * 100);
+
             if (!options.quiet) {
               const violationCount = this.countViolations(engineResult);
-              console.log(chalk.blue(`✅ ${engineName} batch ${batchNumber}: ${violationCount} violations found`));
+              console.log(chalk.green(`✅ [${newProgress}%] ${engineName} batch ${batchNumber}/${ruleBatches.length}: ${violationCount} violations found`));
             }
           } catch (error) {
             // Enhanced error recovery with batch context

package/core/git-utils.js

@@ -121,6 +121,23 @@ class GitUtils {
       // Get git root directory
       const gitRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf8' }).trim();
 
+      // Check if we're in PR context
+      const prContext = this.detectPRContext();
+
+      // If in PR context and no explicit baseRef, try PR-specific logic
+      if (prContext && !baseRef) {
+        try {
+          const prFiles = this.getPRChangedFiles(prContext, gitRoot);
+          if (prFiles && prFiles.length >= 0) {
+            return prFiles;
+          }
+        } catch (prError) {
+          // Log warning and fallback to standard logic
+          console.warn(`⚠️  PR context detected but failed to get changed files: ${prError.message}`);
+          console.log(`   Falling back to standard git diff logic...`);
+        }
+      }
+
       // Auto-detect base ref if not provided
       const actualBaseRef = baseRef || this.getSmartBaseRef(cwd);
 
@@ -159,6 +176,194 @@ class GitUtils {
     }
   }
 
+  /**
+   * Get changed files in PR context using merge-base
+   * @param {Object} prContext - PR context info from detectPRContext()
+   * @param {string} gitRoot - Git repository root path
+   * @returns {string[]} Array of changed file paths in the PR
+   */
+  static getPRChangedFiles(prContext, gitRoot) {
+    try {
+      const { baseBranch, provider } = prContext;
+
+      console.log(`🔍 Detecting changed files for PR (provider: ${provider}, base: ${baseBranch})`);
+
+      // 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}...`);
+
+        // Try to fetch and create the ref
+        const fetchSuccess = this.ensureBaseRefExists(`origin/${baseBranch}`, gitRoot);
+
+        if (fetchSuccess) {
+          baseRef = `origin/${baseBranch}`;
+        } else {
+          throw new Error(`Cannot find or fetch base branch: ${baseBranch}`);
+        }
+      } else {
+        // Ensure we have the latest
+        console.log(`✅ Found base ref: ${baseRef}`);
+        this.ensureBaseRefExists(baseRef, gitRoot);
+      }
+
+      // Use merge-base to find the common ancestor
+      let mergeBase;
+      try {
+        mergeBase = execSync(`git merge-base ${baseRef} HEAD`, {
+          cwd: gitRoot,
+          encoding: 'utf8'
+        }).trim();
+        console.log(`✅ Found 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}`);
+        mergeBase = baseRef;
+      }
+
+      // Get all files changed from merge-base to HEAD
+      const command = `git diff --name-only ${mergeBase}...HEAD`;
+      const output = execSync(command, { cwd: gitRoot, encoding: 'utf8' });
+
+      const changedFiles = output
+        .split('\n')
+        .filter(file => file.trim() !== '')
+        .map(file => path.resolve(gitRoot, file))
+        .filter(file => fs.existsSync(file));
+
+      console.log(`✅ Found ${changedFiles.length} changed files in PR`);
+
+      return changedFiles;
+    } catch (error) {
+      throw new Error(`Failed to get PR changed files: ${error.message}`);
+    }
+  }
+
+  /**
+   * Find base reference for the given branch name
+   * @param {string} baseBranch - Base branch name
+   * @param {string} gitRoot - Git repository root path
+   * @returns {string|null} Base reference or null if not found
+   */
+  static findBaseRef(baseBranch, gitRoot) {
+    const candidates = [
+      `origin/${baseBranch}`,
+      `upstream/${baseBranch}`,
+      baseBranch
+    ];
+
+    for (const candidate of candidates) {
+      try {
+        execSync(`git rev-parse --verify ${candidate}`, {
+          cwd: gitRoot,
+          stdio: 'ignore'
+        });
+        return candidate;
+      } catch (error) {
+        // Continue to next candidate
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Ensure base ref exists (fetch if necessary)
+   * @param {string} baseRef - Base reference
+   * @param {string} gitRoot - Git repository root path
+   */
+  static ensureBaseRefExists(baseRef, gitRoot) {
+    try {
+      // Check if ref exists
+      execSync(`git rev-parse --verify ${baseRef}`, {
+        cwd: gitRoot,
+        stdio: 'ignore'
+      });
+      // Ref exists, return true
+      return true;
+    } catch (error) {
+      // Try to fetch if it doesn't exist
+      const parts = baseRef.split('/');
+      const remote = parts[0];
+      const branch = parts.slice(1).join('/');
+
+      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...`);
+
+            // For shallow clones, we need to:
+            // 1. Fetch the base branch
+            // 2. Get enough history to find merge-base
+            try {
+              // Unshallow current branch first to get more history
+              execSync(`git fetch --deepen=50`, {
+                cwd: gitRoot,
+                stdio: 'pipe',
+                encoding: 'utf8'
+              });
+
+              // Then fetch the base branch with history
+              execSync(`git fetch ${remote} ${branch} --depth=50`, {
+                cwd: gitRoot,
+                stdio: 'pipe',
+                encoding: 'utf8'
+              });
+            } catch (shallowError) {
+              // If deepen fails, try direct fetch
+              console.log(`   ℹ️  Trying direct fetch...`);
+              execSync(`git fetch ${remote} ${branch}`, {
+                cwd: gitRoot,
+                stdio: 'pipe',
+                encoding: 'utf8'
+              });
+            }
+          } else {
+            // Normal fetch for non-shallow repos
+            execSync(`git fetch ${remote} ${branch}`, {
+              cwd: gitRoot,
+              stdio: 'pipe',
+              encoding: 'utf8'
+            });
+          }
+
+          // Verify it now exists
+          execSync(`git rev-parse --verify ${baseRef}`, {
+            cwd: gitRoot,
+            stdio: 'ignore'
+          });
+
+          console.log(`✅ Successfully fetched ${baseRef}`);
+          return true;
+        } catch (fetchError) {
+          console.warn(`⚠️  Failed to fetch ${baseRef}: ${fetchError.message}`);
+          return false;
+        }
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Check if repository is shallow
+   * @param {string} gitRoot - Git repository root path
+   * @returns {boolean} True if shallow
+   */
+  static isShallowRepository(gitRoot) {
+    try {
+      const shallowFile = path.join(gitRoot, '.git', 'shallow');
+      return fs.existsSync(shallowFile);
+    } catch (error) {
+      return false;
+    }
+  }
+
   /**
    * Get list of staged files
    * @param {string} cwd - Working directory

package/core/output-service.js

@@ -44,7 +44,8 @@ class OutputService {
     const report = this.generateReport(results, metadata, { ...options, format: effectiveFormat });
 
     // Console output
-    if (!options.quiet) {
+    // Skip console output when using --github-annotate to avoid JSON clutter
+    if (!options.quiet && !githubAnnotateConfig.shouldAnnotate) {
       console.log(report.formatted);
     }
 

package/docs/GITHUB_ACTIONS_INTEGRATION.md

@@ -90,15 +90,78 @@ jobs:
 
 ## Advanced Usage
 
-### 1. Analyze only changed files
+### 1. Analyze only changed files (Auto-detect PR)
+
+**⭐ Tính năng mới**: Tự động phát hiện PR context, tự động fetch base branch, và sử dụng merge-base để diff chính xác!
 
 ```yaml
-- name: Run SunLint on Changed Files
-  run: sunlint --all --changed-files --github-annotate
-  env:
-    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+steps:
+  - name: Checkout code
+    uses: actions/checkout@v4
+    with:
+      fetch-depth: 0  # Recommended: fetch full history for accurate diff
+
+  - name: Run SunLint on Changed Files (Auto-detect)
+    run: sunlint --all --changed-files --github-annotate
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+```
+
+**✨ Đơn giản nhất có thể - không cần config gì thêm!**
+
+**Cách hoạt động**:
+
+- ✅ Tự động detect GitHub Actions PR event (`GITHUB_EVENT_NAME=pull_request`)
+- ✅ Tự động lấy base branch từ `GITHUB_BASE_REF`
+- ✅ **Tự động fetch base branch nếu chưa có** (không cần thêm step!)
+- ✅ Detect shallow clone và fetch thêm history nếu cần
+- ✅ Sử dụng `git merge-base` để tìm common ancestor
+- ✅ So sánh với merge-base thay vì HEAD → Lấy đúng các file thay đổi trong PR
+
+**Không cần:**
+
+- ❌ Chỉ định `--diff-base`
+- ❌ Thêm step fetch base branch thủ công
+- ❌ Config phức tạp
+
+**Fallback**: Nếu không phát hiện được PR context hoặc không fetch được base branch, sẽ fallback về standard git diff logic
+
+**❓ Có cần `fetch-depth: 0` không?**
+
+**Không bắt buộc!** Nhưng **strongly recommended** vì performance.
+
+| Option | Performance | Checkout Time | Total Time | Accuracy |
+|--------|-------------|---------------|------------|----------|
+| **With `fetch-depth: 0`** ⭐ | Fast | +2-3s | **Fastest** | 100% |
+| Without (shallow clone) | Slower | Fast | Slower | ~95% |
+
+**Với `fetch-depth: 0` (Recommended):**
+
+```yaml
+- uses: actions/checkout@v4
+  with:
+    fetch-depth: 0  # One-time full fetch
+```
+
+- ✅ **Fastest total time** - fetch once, use immediately
+- ✅ **100% accurate** - full history for merge-base
+- ✅ **Simpler** - no runtime fetch needed
+
+**Không có `fetch-depth: 0` (Vẫn work):**
+
+```yaml
+- uses: actions/checkout@v4  # Shallow clone (depth=1)
 ```
 
+- ✅ Fast checkout
+- ⚠️ **Slower total time** - SunLint must fetch at runtime:
+  - Detect shallow clone
+  - `git fetch --deepen=50`
+  - `git fetch origin/main --depth=50`
+- ⚠️ May miss history for very large PRs
+
+**Recommendation**: Dùng `fetch-depth: 0` trừ khi bạn có lý do đặc biệt (e.g., monorepo cực lớn)
+
 ### 2. Save report file + annotate
 
 ```yaml

package/engines/heuristic-engine.js

@@ -819,7 +819,14 @@ class HeuristicEngine extends AnalysisEngineInterface {
     // Group files by language for efficient processing
     const filesByLanguage = this.groupFilesByLanguage(files);
 
+    // Track progress across rules
+    const totalRules = rules.length;
+    let processedRules = 0;
+
     for (const rule of rules) {
+      processedRules++;
+      const ruleProgress = Math.floor((processedRules / totalRules) * 100);
+
       // Special case: Load C047 semantic rule on-demand
       if (rule.id === 'C047' && !this.semanticRules.has('C047')) {
         if (options.verbose) {
@@ -827,7 +834,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
         }
         await this.manuallyLoadC047();
       }
-      
+
       // Lazy load rule if not already loaded
       if (!this.isRuleSupported(rule.id)) {
         if (options.verbose) {
@@ -835,7 +842,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
         }
         await this.lazyLoadRule(rule.id, options);
       }
-      
+
       if (!this.isRuleSupported(rule.id)) {
         if (options.verbose) {
           console.warn(`⚠️ Rule ${rule.id} not supported by Heuristic engine, skipping...`);
@@ -845,25 +852,29 @@ class HeuristicEngine extends AnalysisEngineInterface {
 
       try {
         let ruleViolations = [];
-        
+
         // Check if this is a semantic rule first (higher priority)
         if (this.semanticRules.has(rule.id)) {
-          if (options.verbose) {
-            console.log(`🧠 [HeuristicEngine] Running semantic analysis for rule ${rule.id}`);
-          }
+          const progressInfo = options.batchInfo?.overallProgress !== undefined
+            ? `[${options.batchInfo.overallProgress}% overall] `
+            : '';
+          console.log(`🧠 ${progressInfo}Rule ${processedRules}/${totalRules} (${ruleProgress}%): ${rule.id} - Analyzing ${files.length} files...`);
+
           ruleViolations = await this.analyzeSemanticRule(rule, files, options);
         } else {
           // Fallback to traditional analysis
-          if (options.verbose) {
-            console.log(`🔧 [HeuristicEngine] Running traditional analysis for rule ${rule.id}`);
-          }
+          const progressInfo = options.batchInfo?.overallProgress !== undefined
+            ? `[${options.batchInfo.overallProgress}% overall] `
+            : '';
+          console.log(`🔧 ${progressInfo}Rule ${processedRules}/${totalRules} (${ruleProgress}%): ${rule.id} - Analyzing ${files.length} files...`);
+
           ruleViolations = await this.analyzeRule(rule, filesByLanguage, options);
         }
         
         if (ruleViolations.length > 0) {
           // Group violations by file
           const violationsByFile = this.groupViolationsByFile(ruleViolations);
-          
+
           for (const [filePath, violations] of violationsByFile) {
             // Find or create file result
             let fileResult = results.results.find(r => r.file === filePath);
@@ -875,8 +886,14 @@ class HeuristicEngine extends AnalysisEngineInterface {
           }
         }
 
+        // Log completion
+        const progressInfo = options.batchInfo?.overallProgress !== undefined
+          ? `[${options.batchInfo.overallProgress}% overall] `
+          : '';
+        console.log(`✅ ${progressInfo}${rule.id}: Found ${ruleViolations.length} violations`);
+
         results.metadata.analyzersUsed.push(rule.id);
-        
+
       } catch (error) {
         console.error(`❌ Failed to analyze rule ${rule.id}:`, error.message);
         // Continue with other rules
@@ -911,16 +928,28 @@ class HeuristicEngine extends AnalysisEngineInterface {
 
       const allViolations = [];
 
-      // Run semantic analysis for each file
+      // Run semantic analysis for each file with progress tracking
+      const totalFiles = files.length;
+      let processedFiles = 0;
+      let lastReportedProgress = 0;
+
       for (const filePath of files) {
         try {
-          if (options.verbose) {
-            console.log(`🧠 [SemanticRule] Analyzing ${path.basename(filePath)} with ${rule.id}`);
+          processedFiles++;
+          const currentProgress = Math.floor((processedFiles / totalFiles) * 100);
+
+          // Report progress every 10% or when verbose
+          if (options.verbose || (currentProgress >= lastReportedProgress + 10 && currentProgress < 100)) {
+            const progressInfo = options.batchInfo?.overallProgress !== undefined
+              ? `[${options.batchInfo.overallProgress}% overall] `
+              : '';
+            console.log(`🧠 ${progressInfo}${rule.id}: Processing file ${processedFiles}/${totalFiles} (${currentProgress}%) - ${path.basename(filePath)}`);
+            lastReportedProgress = currentProgress;
           }
-          
+
           // Call semantic rule's analyzeFile method
           await ruleInstance.analyzeFile(filePath, options);
-          
+
           // Get violations from the rule instance
           const fileViolations = ruleInstance.getViolations();
           allViolations.push(...fileViolations);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.21",
+  "version": "1.3.23",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {