@sun-asterisk/sunlint 1.3.20 → 1.3.22

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/file-targeting-service.js

@@ -12,6 +12,7 @@ const { minimatch } = require('minimatch');
 class FileTargetingService {
   constructor() {
     this.supportedLanguages = ['typescript', 'javascript', 'dart', 'kotlin', 'java', 'swift'];
+    this.GitUtils = require('./git-utils');
   }
 
   /**
@@ -22,35 +23,43 @@ class FileTargetingService {
     try {
       const startTime = Date.now();
       const metadata = config._metadata;
-      
+
       if (cliOptions.verbose) {
         console.log(chalk.cyan(`📁 File Targeting: ${this.getTargetingMode(metadata)}`));
         if (metadata?.shouldBypassProjectDiscovery) {
           console.log(chalk.blue(`🎯 Optimized targeting for ${metadata.analysisScope}`));
         }
       }
-      
+
       let allFiles = [];
-      
-      // Smart project-level optimization
-      const optimizedPaths = this.optimizeProjectPaths(inputPaths, cliOptions);
-      
-      // Use enhanced targeting based on metadata
-      if (metadata?.shouldBypassProjectDiscovery) {
-        allFiles = await this.collectTargetedFiles(optimizedPaths, config, cliOptions);
+
+      // Handle --changed-files option (git diff mode)
+      if (cliOptions.changedFiles) {
+        if (cliOptions.verbose) {
+          console.log(chalk.cyan('🔄 Using --changed-files mode (git diff)'));
+        }
+        allFiles = await this.getGitChangedFiles(cliOptions);
       } else {
-        allFiles = await this.collectProjectFiles(optimizedPaths, config, cliOptions);
+        // Smart project-level optimization
+        const optimizedPaths = this.optimizeProjectPaths(inputPaths, cliOptions);
+
+        // Use enhanced targeting based on metadata
+        if (metadata?.shouldBypassProjectDiscovery) {
+          allFiles = await this.collectTargetedFiles(optimizedPaths, config, cliOptions);
+        } else {
+          allFiles = await this.collectProjectFiles(optimizedPaths, config, cliOptions);
+        }
       }
 
       // Apply filtering logic
       const targetFiles = this.applyFiltering(allFiles, config, cliOptions);
-      
+
       const duration = Date.now() - startTime;
-      
+
       if (cliOptions.verbose) {
         console.log(chalk.green(`✅ File targeting completed in ${duration}ms (${targetFiles.length} files)`));
       }
-      
+
       return {
         files: targetFiles,
         stats: this.generateStats(targetFiles, config),
@@ -62,6 +71,41 @@ class FileTargetingService {
     }
   }
 
+  /**
+   * Get files changed in git (for --changed-files option)
+   */
+  async getGitChangedFiles(cliOptions) {
+    try {
+      const baseRef = cliOptions.diffBase || null; // null = auto-detect
+      const changedFiles = this.GitUtils.getChangedFiles(baseRef);
+
+      if (cliOptions.verbose) {
+        const detectedBase = baseRef || this.GitUtils.getSmartBaseRef();
+        console.log(chalk.blue(`ℹ️  Using base ref: ${detectedBase}`));
+        console.log(chalk.blue(`ℹ️  Found ${changedFiles.length} changed file(s)`));
+
+        if (changedFiles.length > 0 && changedFiles.length <= 10) {
+          console.log(chalk.gray('   Changed files:'));
+          changedFiles.forEach(f => {
+            console.log(chalk.gray(`   - ${path.relative(process.cwd(), f)}`));
+          });
+        } else if (changedFiles.length > 10) {
+          console.log(chalk.gray(`   First 10 changed files:`));
+          changedFiles.slice(0, 10).forEach(f => {
+            console.log(chalk.gray(`   - ${path.relative(process.cwd(), f)}`));
+          });
+          console.log(chalk.gray(`   ... and ${changedFiles.length - 10} more`));
+        }
+      }
+
+      return changedFiles;
+    } catch (error) {
+      console.error(chalk.yellow(`⚠️  Failed to get changed files: ${error.message}`));
+      console.error(chalk.yellow('ℹ️  Falling back to all files'));
+      return [];
+    }
+  }
+
   /**
    * Get targeting mode description
    */
@@ -293,15 +337,22 @@ class FileTargetingService {
     if (debug) console.log(`🔍 [DEBUG] applyFiltering: start with ${filteredFiles.length} files`);
     if (debug) console.log(`🔍 [DEBUG] config.include:`, config.include);
     if (debug) console.log(`🔍 [DEBUG] cliOptions.include:`, cliOptions.include);
+    if (debug) console.log(`🔍 [DEBUG] cliOptions.changedFiles:`, cliOptions.changedFiles);
+
+    // IMPORTANT: When using --changed-files, skip include patterns
+    // Git already filtered the files, we only need to apply excludes
+    const skipIncludePatterns = cliOptions.changedFiles;
 
     // 1. Apply config include patterns first (medium priority)
-    if (config.include && config.include.length > 0) {
+    if (!skipIncludePatterns && config.include && config.include.length > 0) {
       filteredFiles = this.applyIncludePatterns(filteredFiles, config.include, debug);
       if (debug) console.log(`🔍 [DEBUG] After config include: ${filteredFiles.length} files`);
+    } else if (skipIncludePatterns && debug) {
+      console.log(`🔍 [DEBUG] Skipping config include patterns (--changed-files mode)`);
     }
 
     // 2. Apply CLI include overrides (highest priority - completely overrides config)
-    if (cliOptions.include) {
+    if (!skipIncludePatterns && cliOptions.include) {
       // CLI include completely replaces config include - start fresh from all files
       filteredFiles = this.applyIncludePatterns([...files], cliOptions.include, debug);
     }

package/core/git-utils.js

@@ -21,13 +21,98 @@ class GitUtils {
     }
   }
 
+  /**
+   * Detect if running in PR context (GitHub Actions, GitLab CI, etc.)
+   * @returns {Object|null} PR context info or null
+   */
+  static detectPRContext() {
+    // GitHub Actions
+    if (process.env.GITHUB_EVENT_NAME === 'pull_request' ||
+        process.env.GITHUB_EVENT_NAME === 'pull_request_target') {
+      return {
+        provider: 'github',
+        baseBranch: process.env.GITHUB_BASE_REF,
+        headBranch: process.env.GITHUB_HEAD_REF,
+        prNumber: process.env.GITHUB_REF ? process.env.GITHUB_REF.match(/refs\/pull\/(\d+)\/merge/)?.[1] : null
+      };
+    }
+
+    // GitLab CI
+    if (process.env.CI_MERGE_REQUEST_ID) {
+      return {
+        provider: 'gitlab',
+        baseBranch: process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME,
+        headBranch: process.env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME,
+        prNumber: process.env.CI_MERGE_REQUEST_IID
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Get smart base reference for diff
+   * Auto-detects PR context or falls back to common base branches
+   * @param {string} cwd - Working directory
+   * @returns {string} Base reference for git diff
+   */
+  static getSmartBaseRef(cwd = process.cwd()) {
+    if (!this.isGitRepository(cwd)) {
+      throw new Error('Not a git repository');
+    }
+
+    // Check PR context first
+    const prContext = this.detectPRContext();
+    if (prContext && prContext.baseBranch) {
+      const candidates = [
+        `origin/${prContext.baseBranch}`,
+        `upstream/${prContext.baseBranch}`,
+        prContext.baseBranch
+      ];
+
+      for (const candidate of candidates) {
+        try {
+          execSync(`git rev-parse --verify ${candidate}`, { cwd, stdio: 'ignore' });
+          return candidate;
+        } catch (error) {
+          // Continue to next candidate
+        }
+      }
+    }
+
+    // Fallback to common base branches
+    const fallbackBranches = [
+      'origin/main',
+      'origin/master',
+      'origin/develop',
+      'upstream/main',
+      'upstream/master',
+      'main',
+      'master',
+      'develop'
+    ];
+
+    for (const branch of fallbackBranches) {
+      try {
+        execSync(`git rev-parse --verify ${branch}`, { cwd, stdio: 'ignore' });
+        return branch;
+      } catch (error) {
+        // Continue to next candidate
+      }
+    }
+
+    // Last resort: use HEAD (uncommitted changes only)
+    return 'HEAD';
+  }
+
   /**
    * Get list of changed files compared to base reference
-   * @param {string} baseRef - Base git reference (e.g., 'origin/main')
+   * @param {string|null} baseRef - Base git reference (e.g., 'origin/main'). If null, auto-detect.
    * @param {string} cwd - Working directory
+   * @param {boolean} includeUncommitted - Include uncommitted changes
    * @returns {string[]} Array of changed file paths
    */
-  static getChangedFiles(baseRef = 'HEAD', cwd = process.cwd()) {
+  static getChangedFiles(baseRef = null, cwd = process.cwd(), includeUncommitted = true) {
     if (!this.isGitRepository(cwd)) {
       throw new Error('Not a git repository');
     }
@@ -35,17 +120,156 @@ class GitUtils {
     try {
       // Get git root directory
       const gitRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf8' }).trim();
-      
-      const command = `git diff --name-only ${baseRef}`;
+
+      // Check if we're in PR context
+      const prContext = this.detectPRContext();
+
+      // If in PR context and no explicit baseRef, use PR-specific logic
+      if (prContext && !baseRef) {
+        return this.getPRChangedFiles(prContext, gitRoot);
+      }
+
+      // Auto-detect base ref if not provided
+      const actualBaseRef = baseRef || this.getSmartBaseRef(cwd);
+
+      const allFiles = new Set();
+
+      // Get committed changes
+      if (actualBaseRef !== 'HEAD') {
+        // Use two-dot diff for branch comparison (what's new in this branch)
+        const command = `git diff --name-only ${actualBaseRef}..HEAD`;
+        const output = execSync(command, { cwd: gitRoot, encoding: 'utf8' });
+
+        output
+          .split('\n')
+          .filter(file => file.trim() !== '')
+          .forEach(file => allFiles.add(path.resolve(gitRoot, file)));
+      }
+
+      // Get uncommitted changes if requested
+      if (includeUncommitted) {
+        const uncommittedCommand = 'git diff --name-only HEAD';
+        try {
+          const uncommittedOutput = execSync(uncommittedCommand, { cwd: gitRoot, encoding: 'utf8' });
+          uncommittedOutput
+            .split('\n')
+            .filter(file => file.trim() !== '')
+            .forEach(file => allFiles.add(path.resolve(gitRoot, file)));
+        } catch (error) {
+          // Ignore errors for uncommitted changes (might be empty)
+        }
+      }
+
+      // Filter to only existing files
+      return Array.from(allFiles).filter(file => fs.existsSync(file));
+    } catch (error) {
+      throw new Error(`Failed to get changed files: ${error.message}`);
+    }
+  }
+
+  /**
+   * 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 } = prContext;
+
+      // Try to find the base branch reference
+      const baseRef = this.findBaseRef(baseBranch, gitRoot);
+
+      if (!baseRef) {
+        throw new Error(`Cannot find base branch: ${baseBranch}`);
+      }
+
+      // Ensure we have the latest base branch
+      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();
+      } catch (error) {
+        // If merge-base fails, fall back to direct comparison
+        console.warn(`Warning: 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' });
-      
-      return output
+
+      const changedFiles = output
         .split('\n')
         .filter(file => file.trim() !== '')
         .map(file => path.resolve(gitRoot, file))
-        .filter(file => fs.existsSync(file)); // Only existing files
+        .filter(file => fs.existsSync(file));
+
+      return changedFiles;
     } catch (error) {
-      throw new Error(`Failed to get changed files: ${error.message}`);
+      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'
+      });
+    } catch (error) {
+      // Try to fetch if it doesn't exist
+      const remote = baseRef.split('/')[0];
+      if (remote === 'origin' || remote === 'upstream') {
+        try {
+          console.log(`Fetching ${remote}...`);
+          execSync(`git fetch ${remote} --depth=1`, {
+            cwd: gitRoot,
+            stdio: 'inherit'
+          });
+        } catch (fetchError) {
+          console.warn(`Warning: Failed to fetch ${remote}: ${fetchError.message}`);
+        }
+      }
     }
   }
 

package/core/github-annotate-service.js

@@ -182,14 +182,56 @@ function readJsonFile(jsonFile) {
   }
 }
 
+/**
+ * Get git root directory
+ * @param {string} cwd - Current working directory
+ * @returns {string} Git root path
+ */
+function getGitRoot(cwd = process.cwd()) {
+  try {
+    const { execSync } = require('child_process');
+    const gitRoot = execSync('git rev-parse --show-toplevel', {
+      cwd,
+      encoding: 'utf8'
+    }).trim();
+    return gitRoot;
+  } catch (error) {
+    logger.warn('Not a git repository, using cwd as root');
+    return cwd;
+  }
+}
+
+/**
+ * Normalize path to be relative from git root
+ * @param {string} filePath - File path (absolute or relative)
+ * @param {string} gitRoot - Git root directory
+ * @returns {string} Normalized relative path
+ */
+function normalizePathFromGitRoot(filePath, gitRoot) {
+  let normalized = filePath;
+
+  // Convert absolute path to relative from git root
+  if (filePath.startsWith(gitRoot)) {
+    normalized = filePath.slice(gitRoot.length);
+    if (normalized.startsWith('/') || normalized.startsWith('\\')) {
+      normalized = normalized.slice(1);
+    }
+  }
+
+  // Normalize path separators to forward slash
+  normalized = normalized.replace(/\\/g, '/');
+
+  return normalized;
+}
+
 /**
  * Parse violations from JSON data
  * @param {Array|Object} raw - Raw JSON data
+ * @param {string} gitRoot - Git root directory for path normalization
  * @returns {Array} Array of violation objects
  */
-function parseViolations(raw) {
+function parseViolations(raw, gitRoot) {
   const violations = [];
-  const cwd = process.env.GITHUB_WORKSPACE || process.cwd();
 
   if (Array.isArray(raw)) {
     for (const fileObj of raw) {
@@ -203,18 +245,8 @@ function parseViolations(raw) {
         continue;
       }
 
-      let relPath = fileObj.filePath;
-
-      // Convert absolute path to relative
-      if (relPath.startsWith(cwd)) {
-        relPath = relPath.slice(cwd.length);
-        if (relPath.startsWith('/') || relPath.startsWith('\\')) {
-          relPath = relPath.slice(1);
-        }
-      }
-
-      // Normalize path separators
-      relPath = relPath.replace(/\\/g, '/');
+      // Normalize path relative to git root (same as GitHub API)
+      const relPath = normalizePathFromGitRoot(fileObj.filePath, gitRoot);
 
       for (const msg of fileObj.messages) {
         if (!msg || typeof msg !== 'object') {
@@ -243,7 +275,12 @@ function parseViolations(raw) {
     if (!Array.isArray(rawViolations)) {
       throw new Error('violations property must be an array');
     }
-    violations.push(...rawViolations);
+
+    // Normalize paths for raw violations too
+    violations.push(...rawViolations.map(v => ({
+      ...v,
+      file: normalizePathFromGitRoot(v.file, gitRoot)
+    })));
   } else {
     throw new Error('JSON data must be an array or object with violations property');
   }
@@ -521,9 +558,13 @@ async function annotate({
     logger.info('Reading result file', { jsonFile });
     const raw = readJsonFile(jsonFile);
 
-    // Step 3: Parse violations
+    // Step 2.5: Get git root for path normalization
+    const gitRoot = getGitRoot();
+    logger.debug('Git root directory', { gitRoot });
+
+    // Step 3: Parse violations with git root normalization
     logger.info('Parsing violations');
-    const violations = parseViolations(raw);
+    const violations = parseViolations(raw, gitRoot);
 
     if (violations.length === 0) {
       logger.info('No violations found');
@@ -607,6 +648,14 @@ async function annotate({
     let linesSkipped = 0;
     let renamedFilesHandled = 0;
 
+    // Debug: Log sample paths for comparison
+    logger.debug('Path comparison debug:', {
+      sampleViolationFiles: violations.slice(0, 3).map(v => v.file),
+      samplePRFiles: Array.from(prFilesInfo.keys()).slice(0, 3),
+      totalViolations: violations.length,
+      totalPRFiles: prFilesInfo.size
+    });
+
     for (const v of violations) {
       let targetFile = v.file;
       let fileInfo = prFilesInfo.get(targetFile);
@@ -813,9 +862,13 @@ async function postSummaryComment({
     logger.info('Reading result file', { jsonFile });
     const raw = readJsonFile(jsonFile);
 
-    // Step 3: Parse violations
+    // Step 2.5: Get git root for path normalization
+    const gitRoot = getGitRoot();
+    logger.debug('Git root directory', { gitRoot });
+
+    // Step 3: Parse violations with git root normalization
     logger.info('Parsing violations for summary');
-    const violations = parseViolations(raw);
+    const violations = parseViolations(raw, gitRoot);
 
     // Step 4: Initialize Octokit
     const token = githubToken || process.env.GITHUB_TOKEN;

package/core/output-service.js

@@ -28,9 +28,9 @@ 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
     }
   }
 
@@ -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,28 @@ 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 và sử dụng merge-base để diff chính xác!
 
 ```yaml
-- name: Run SunLint on Changed Files
+- name: Run SunLint on Changed Files (Auto-detect)
   run: sunlint --all --changed-files --github-annotate
   env:
     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 ```
 
+**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`
+- ✅ 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
+- ✅ Tự động fetch base branch nếu cần
+
+**Không cần chỉ định `--diff-base` nữa!** SunLint sẽ tự động xử lý.
+
+**Fallback**: Nếu không phát hiện được PR context, sẽ fallback về logic cũ (so sánh với HEAD hoặc origin/main)
+
 ### 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.20",
+  "version": "1.3.22",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {