@sun-asterisk/sunlint 1.3.7 → 1.3.9

package/core/file-targeting-service.js

@@ -16,7 +16,7 @@ class FileTargetingService {
 
   /**
    * Get target files based on enhanced configuration
-   * ENHANCED: Uses metadata for intelligent file targeting
+   * ENHANCED: Uses metadata for intelligent file targeting with smart project-level optimization
    */
   async getTargetFiles(inputPaths, config, cliOptions = {}) {
     try {
@@ -32,11 +32,14 @@ class FileTargetingService {
       
       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(inputPaths, config, cliOptions);
+        allFiles = await this.collectTargetedFiles(optimizedPaths, config, cliOptions);
       } else {
-        allFiles = await this.collectProjectFiles(inputPaths, config, cliOptions);
+        allFiles = await this.collectProjectFiles(optimizedPaths, config, cliOptions);
       }
 
       // Apply filtering logic
@@ -150,13 +153,84 @@ class FileTargetingService {
     return allFiles;
   }
 
+    /**
+   * Optimize project paths to focus on source and test directories
+   * Prevents unnecessary scanning of entire project when smart targeting is possible
+   */
+  optimizeProjectPaths(inputPaths, cliOptions = {}) {
+    const optimizedPaths = [];
+    
+    for (const inputPath of inputPaths) {
+      // If targeting entire project directory, try to find source/test subdirectories
+      if (fs.existsSync(inputPath) && fs.statSync(inputPath).isDirectory()) {
+        const absoluteInputPath = path.resolve(inputPath);
+        const inputDirName = path.basename(absoluteInputPath);
+        
+        // If user already specified a source directory (src, lib, app, packages, test, etc.), 
+        // don't try to optimize further - use it as is
+        const sourceDirectoryNames = ['src', 'lib', 'app', 'packages', 'test', 'tests', '__tests__', 'spec', 'specs'];
+        if (sourceDirectoryNames.includes(inputDirName)) {
+          if (cliOptions.verbose) {
+            console.log(chalk.blue(`🎯 Direct targeting: Using specified source directory ${inputDirName}`));
+          }
+          optimizedPaths.push(inputPath);
+          continue;
+        }
+        
+        // Only optimize if this appears to be a project root directory
+        const projectOptimization = this.findProjectSourceDirs(inputPath, cliOptions);
+        if (projectOptimization.length > 0) {
+          if (cliOptions.verbose) {
+            console.log(chalk.blue(`🎯 Smart targeting: Found ${projectOptimization.length} source directories in ${path.basename(inputPath)}`));
+          }
+          optimizedPaths.push(...projectOptimization);
+        } else {
+          optimizedPaths.push(inputPath);
+        }
+      } else {
+        optimizedPaths.push(inputPath);
+      }
+    }
+    
+    return optimizedPaths;
+  }
+
+  /**
+   * Find source directories in project to avoid scanning entire project
+   */
+  findProjectSourceDirs(projectPath, cliOptions = {}) {
+    const sourceDirs = [];
+    const candidateDirs = ['src', 'lib', 'app', 'packages'];
+    const testDirs = ['test', 'tests', '__tests__', 'spec', 'specs'];
+    
+    // Always include test directories if --include-tests flag is used
+    const dirsToCheck = cliOptions.includeTests ? [...candidateDirs, ...testDirs] : candidateDirs;
+    
+    for (const dir of dirsToCheck) {
+      const dirPath = path.join(projectPath, dir);
+      if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+        sourceDirs.push(dirPath);
+      }
+    }
+    
+    return sourceDirs;
+  }
+
   /**
    * Check if directory should be skipped
+   * Enhanced with more comprehensive ignore patterns
+   * Enhanced with more comprehensive ignore patterns
    */
   shouldSkipDirectory(dirName) {
     const skipDirs = [
       'node_modules', '.git', 'dist', 'build', 'coverage', 
-      '.next', '.nuxt', 'vendor', 'target', 'generated'
+      '.next', '.nuxt', 'vendor', 'target', 'generated',
+      '.vscode', '.id',
+      '.vscode', '.idea', '.husky', '.github', '.yarn',
+      'out', 'public', 'static', 'assets', 'tmp', 'temp',
+      'cache', '.cache', 'logs', 'logea', '.husky', '.github', '.yarn',
+      'out', 'public', 'static', 'assets', 'tmp', 'temp',
+      'cache', '.cache', 'logs', 'log'
     ];
     return skipDirs.includes(dirName);
   }
@@ -278,10 +352,27 @@ class FileTargetingService {
           if (debug) console.log(`🔍 [DEBUG] After include patterns ${langConfig.include}: ${langFiles.length} files`);
         }
 
-        // Apply language-specific exclude patterns
+        // Apply language-specific exclude patterns (but respect --include-tests for test files)
         if (langConfig.exclude && langConfig.exclude.length > 0) {
-          langFiles = this.applyExcludePatterns(langFiles, langConfig.exclude, debug);
-          if (debug) console.log(`🔍 [DEBUG] After exclude patterns ${langConfig.exclude}: ${langFiles.length} files`);
+          // Skip test-related exclude patterns if --include-tests is enabled
+          let effectiveExcludes = langConfig.exclude;
+          if (cliOptions.includeTests === true) {
+            // Remove test-related patterns completely
+            effectiveExcludes = langConfig.exclude.filter(pattern => {
+              const isTestPattern = pattern.includes('.test.') || pattern.includes('.spec.') || 
+                                    pattern.includes('/test/') || pattern.includes('/tests/') || 
+                                    pattern.includes('/__tests__/');
+              return !isTestPattern;
+            });
+            if (debug) console.log(`🔍 [DEBUG] --include-tests enabled, filtered excludes: ${effectiveExcludes}`);
+          }
+          
+          if (effectiveExcludes.length > 0) {
+            langFiles = this.applyExcludePatterns(langFiles, effectiveExcludes, debug);
+            if (debug) console.log(`🔍 [DEBUG] After exclude patterns ${effectiveExcludes}: ${langFiles.length} files`);
+          } else {
+            if (debug) console.log(`🔍 [DEBUG] All exclude patterns filtered out by --include-tests`);
+          }
         }
 
         languageFiles.push(...langFiles);

package/package.json

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