@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/core/file-targeting-service.js

@@ -616,22 +616,80 @@ class FileTargetingService {
     return files;
   }
 
+  /**
+   * Directories to always skip during file collection (performance + safety)
+   * These are known heavy/problematic directories in Flutter/mobile projects
+   */
+  static SKIP_DIRECTORIES = new Set([
+    'node_modules',
+    '.git',
+    '.dart_tool',
+    'build',
+    'Pods',
+    '.symlinks',
+    '.pub-cache',
+    '.gradle',
+    'DerivedData',
+    '__pycache__',
+    '.venv',
+    'vendor',
+    '.bundle'
+  ]);
+
   /**
    * Collect files from directory recursively
    * Rule C006: collectFilesFromDirectory - verb-noun naming
+   * Enhanced: Skip symlinks and known heavy directories to prevent stack overflow
    */
-  async collectFilesFromDirectory(dirPath) {
+  async collectFilesFromDirectory(dirPath, visitedPaths = new Set()) {
     const files = [];
-    const entries = fs.readdirSync(dirPath);
+
+    // Resolve real path to detect circular symlinks
+    let realPath;
+    try {
+      realPath = fs.realpathSync(dirPath);
+    } catch {
+      return files; // Cannot resolve path, skip
+    }
+
+    // Prevent infinite loops from circular symlinks
+    if (visitedPaths.has(realPath)) {
+      return files;
+    }
+    visitedPaths.add(realPath);
+
+    let entries;
+    try {
+      entries = fs.readdirSync(dirPath);
+    } catch {
+      return files; // Cannot read directory, skip
+    }
 
     for (const entry of entries) {
+      // Skip known heavy directories early (before stat call)
+      if (FileTargetingService.SKIP_DIRECTORIES.has(entry)) {
+        continue;
+      }
+
       const fullPath = path.join(dirPath, entry);
-      const stats = fs.statSync(fullPath);
+
+      let stats;
+      try {
+        // Use lstatSync to detect symlinks without following them
+        stats = fs.lstatSync(fullPath);
+      } catch {
+        continue; // Cannot stat, skip this entry
+      }
+
+      // Skip symlinks to prevent circular references
+      if (stats.isSymbolicLink()) {
+        continue;
+      }
 
       if (stats.isFile()) {
         files.push(path.resolve(fullPath));
       } else if (stats.isDirectory()) {
-        const subFiles = await this.collectFilesFromDirectory(fullPath);
+        const subFiles = await this.collectFilesFromDirectory(fullPath, visitedPaths);
         files.push(...subFiles);
       }
     }

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;
         }
       }