@sun-asterisk/sunlint 1.3.22 → 1.3.23

package/core/git-utils.js

@@ -124,9 +124,18 @@ class GitUtils {
       // Check if we're in PR context
       const prContext = this.detectPRContext();
 
-      // If in PR context and no explicit baseRef, use PR-specific logic
+      // If in PR context and no explicit baseRef, try PR-specific logic
       if (prContext && !baseRef) {
-        return this.getPRChangedFiles(prContext, gitRoot);
+        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
@@ -175,17 +184,29 @@ class GitUtils {
    */
   static getPRChangedFiles(prContext, gitRoot) {
     try {
-      const { baseBranch } = prContext;
+      const { baseBranch, provider } = prContext;
+
+      console.log(`🔍 Detecting changed files for PR (provider: ${provider}, base: ${baseBranch})`);
 
       // Try to find the base branch reference
-      const baseRef = this.findBaseRef(baseBranch, gitRoot);
+      let baseRef = this.findBaseRef(baseBranch, gitRoot);
 
       if (!baseRef) {
-        throw new Error(`Cannot find base branch: ${baseBranch}`);
-      }
+        console.log(`⚠️  Base ref not found locally, attempting to fetch origin/${baseBranch}...`);
 
-      // Ensure we have the latest base branch
-      this.ensureBaseRefExists(baseRef, gitRoot);
+        // 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;
@@ -194,9 +215,10 @@ class GitUtils {
           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(`Warning: Could not find merge-base, using direct diff with ${baseRef}`);
+        console.warn(`⚠️  Could not find merge-base, using direct diff with ${baseRef}`);
         mergeBase = baseRef;
       }
 
@@ -210,6 +232,8 @@ class GitUtils {
         .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}`);
@@ -256,20 +280,87 @@ class GitUtils {
         cwd: gitRoot,
         stdio: 'ignore'
       });
+      // Ref exists, return true
+      return true;
     } catch (error) {
       // Try to fetch if it doesn't exist
-      const remote = baseRef.split('/')[0];
+      const parts = baseRef.split('/');
+      const remote = parts[0];
+      const branch = parts.slice(1).join('/');
+
       if (remote === 'origin' || remote === 'upstream') {
         try {
-          console.log(`Fetching ${remote}...`);
-          execSync(`git fetch ${remote} --depth=1`, {
+          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: 'inherit'
+            stdio: 'ignore'
           });
+
+          console.log(`✅ Successfully fetched ${baseRef}`);
+          return true;
         } catch (fetchError) {
-          console.warn(`Warning: Failed to fetch ${remote}: ${fetchError.message}`);
+          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;
     }
   }
 

package/docs/GITHUB_ACTIONS_INTEGRATION.md

@@ -92,25 +92,75 @@ jobs:
 
 ### 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!
+**⭐ 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 (Auto-detect)
-  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
-- ✅ 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ý.
+**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
 
-**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)
+**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
 

package/package.json

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