@sun-asterisk/sunlint 1.3.47 → 1.3.49

package/engines/arch-detect/rules/presentation/pr006-router-layer.js

@@ -50,6 +50,7 @@ const rule = (0, base_rule_1.createRule)('PR006', 'Router/Wireframe Layer', 'Xá
     folderPatterns: ['routers', 'wireframes', 'navigation', 'routing', 'Routers', 'coordinators'],
     filePatterns: ['*Router.*', '*Wireframe.*', '*Coordinator.*', '*Navigator.*'],
     codePatterns: [
+        // Swift
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.PATTERN, pattern: /protocol\s+\w+Router/ },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Router/ },
         {
@@ -59,12 +60,31 @@ const rule = (0, base_rule_1.createRule)('PR006', 'Router/Wireframe Layer', 'Xá
         },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.METHOD, pattern: /func\s+navigate/ },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.METHOD, pattern: /func\s+present/ },
+        // Kotlin
         {
             language: enums_1.Language.KOTLIN,
             type: enums_1.CodePatternType.PATTERN,
             pattern: /interface\s+\w+Router/,
         },
         { language: enums_1.Language.KOTLIN, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Router/ },
+        // Java
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Router/ },
+        // PHP
+        {
+            language: enums_1.Language.PHP,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /Route::(get|post|put|delete|group)\s*\(/,
+        },
+        // Python
+        { language: enums_1.Language.PYTHON, type: enums_1.CodePatternType.PATTERN, pattern: /urlpatterns\s*=/ },
+        {
+            language: enums_1.Language.PYTHON,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /router\s*=\s*APIRouter\s*\(/,
+        },
+        // Go
+        { language: enums_1.Language.GO, type: enums_1.CodePatternType.PATTERN, pattern: /func\s+\w+Router\b/ },
+        { language: enums_1.Language.GO, type: enums_1.CodePatternType.PATTERN, pattern: /r\.Group\s*\(/ },
     ],
 }, {
     isKeyIndicator: true,
@@ -110,10 +130,10 @@ let PR006RouterLayer = (() => {
                 }
             }
             // Check for router files - match any file containing Router/Wireframe/WireFrame/Coordinator
-            const routerFiles = context.files.filter((f) => /Router\.(swift|kt|java|ts|js)$/i.test(f.fileName) ||
+            const routerFiles = context.files.filter((f) => /Router\.(swift|kt|java|ts|js|php|py|go|rb|cs)$/i.test(f.fileName) ||
                 /WireFrame\.(swift|kt|java)$/i.test(f.fileName) ||
                 /Wireframe\.(swift|kt|java)$/i.test(f.fileName) ||
-                /Coordinator\.(swift|kt|java|ts)$/i.test(f.fileName));
+                /Coordinator\.(swift|kt|java|ts|php|py|go)$/i.test(f.fileName));
             if (routerFiles.length > 0) {
                 for (const file of routerFiles.slice(0, 5)) {
                     matches.push({
@@ -129,12 +149,17 @@ let PR006RouterLayer = (() => {
                 .filter((f) => !f.isTest && !f.isConfig && f.language)
                 .slice(0, 50);
             const codePatterns = [
-                /protocol\s+\w+Router/,
-                /class\s+\w+Router/,
-                /class\s+\w+Coordinator/,
-                /func\s+navigateTo/,
-                /func\s+presentModule/,
-                /interface\s+\w+Router/,
+                /protocol\s+\w+Router/, // Swift
+                /class\s+\w+Router/, // Swift/Kotlin/Java
+                /class\s+\w+Coordinator/, // Swift
+                /func\s+navigateTo/, // Swift/Kotlin
+                /func\s+presentModule/, // Swift
+                /interface\s+\w+Router/, // Kotlin/Java
+                /Route::(get|post|put|delete|group)\s*\(/, // PHP Laravel
+                /urlpatterns\s*=/, // Python Django
+                /router\s*=\s*APIRouter\s*\(/, // Python FastAPI
+                /func\s+\w+Router\b/, // Go
+                /r\.Group\s*\(/, // Go Gin
             ];
             for (const file of sourceFiles) {
                 try {

package/engines/arch-detect/rules/presentation/pr007-interactor-layer.js

@@ -50,12 +50,14 @@ const rule = (0, base_rule_1.createRule)('PR007', 'Interactor Layer', 'Xác nh
     folderPatterns: ['interactors', 'usecases', 'Interactors', 'UseCases'],
     filePatterns: ['*Interactor.*', '*UseCase.*', '*BusinessLogic.*'],
     codePatterns: [
+        // Swift
         {
             language: enums_1.Language.SWIFT,
             type: enums_1.CodePatternType.PATTERN,
             pattern: /protocol\s+\w+Interactor/,
         },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Interactor/ },
+        // Kotlin
         {
             language: enums_1.Language.KOTLIN,
             type: enums_1.CodePatternType.PATTERN,
@@ -67,6 +69,31 @@ const rule = (0, base_rule_1.createRule)('PR007', 'Interactor Layer', 'Xác nh
             pattern: /class\s+\w+Interactor/,
         },
         { language: enums_1.Language.KOTLIN, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        // Java
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Interactor/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        // TypeScript
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /class\s+\w+UseCase/,
+        },
+        // PHP
+        { language: enums_1.Language.PHP, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        { language: enums_1.Language.PHP, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Interactor/ },
+        // Python
+        { language: enums_1.Language.PYTHON, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        // Go
+        {
+            language: enums_1.Language.GO,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /type\s+\w+UseCase\s+struct/,
+        },
+        {
+            language: enums_1.Language.GO,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /type\s+\w+Interactor\s+struct/,
+        },
     ],
 }, {
     isKeyIndicator: true,
@@ -110,8 +137,8 @@ let PR007InteractorLayer = (() => {
                 }
             }
             // Check for interactor files
-            const interactorFiles = context.files.filter((f) => /Interactor\.(swift|kt|java|ts|js)$/i.test(f.fileName) ||
-                /UseCase\.(swift|kt|java|ts|js)$/i.test(f.fileName));
+            const interactorFiles = context.files.filter((f) => /Interactor\.(swift|kt|java|ts|js|php|py|go|rb|cs)$/i.test(f.fileName) ||
+                /UseCase\.(swift|kt|java|ts|js|php|py|go|rb|cs)$/i.test(f.fileName));
             if (interactorFiles.length > 0) {
                 for (const file of interactorFiles.slice(0, 5)) {
                     matches.push({
@@ -127,10 +154,12 @@ let PR007InteractorLayer = (() => {
                 .filter((f) => !f.isTest && !f.isConfig && f.language)
                 .slice(0, 50);
             const codePatterns = [
-                /protocol\s+\w+Interactor/,
-                /class\s+\w+Interactor/,
-                /interface\s+\w+Interactor/,
-                /class\s+\w+UseCase/,
+                /protocol\s+\w+Interactor/, // Swift
+                /class\s+\w+Interactor/, // Swift/Kotlin/Java/PHP
+                /interface\s+\w+Interactor/, // Kotlin/Java
+                /class\s+\w+UseCase/, // Kotlin/Java/TS/PHP/Python
+                /type\s+\w+UseCase\s+struct/, // Go
+                /type\s+\w+Interactor\s+struct/, // Go
             ];
             for (const file of sourceFiles) {
                 try {

package/engines/arch-detect/rules/project-scanner/ps003-framework-detection.js

@@ -86,9 +86,20 @@ const FRAMEWORK_DETECTORS = [
         dependencies: [
             { file: 'pom.xml', packages: ['spring-boot-starter'] },
             { file: 'build.gradle', packages: ['spring-boot'] },
+            { file: 'build.gradle.kts', packages: ['spring-boot'] },
         ],
         codePatterns: [/@SpringBootApplication/],
     },
+    // Ktor
+    {
+        framework: enums_1.Framework.KTOR,
+        configFiles: [],
+        dependencies: [
+            { file: 'build.gradle.kts', packages: ['io.ktor'] },
+            { file: 'build.gradle', packages: ['io.ktor'] },
+        ],
+        codePatterns: [/routing\s*\{/, /embeddedServer\s*\(/],
+    },
     // Angular
     {
         framework: enums_1.Framework.ANGULAR,
@@ -133,15 +144,26 @@ const FRAMEWORK_DETECTORS = [
     // Laravel
     {
         framework: enums_1.Framework.LARAVEL,
-        configFiles: ['artisan'],
+        configFiles: ['artisan', 'config/app.php'],
         dependencies: [{ file: 'composer.json', packages: ['laravel/framework'] }],
-        codePatterns: [/extends\s+Controller/],
+        codePatterns: [/extends\s+Controller/, /use\s+Illuminate\\/],
+    },
+    // Symfony
+    {
+        framework: enums_1.Framework.SYMFONY,
+        configFiles: ['config/bundles.php', 'symfony.lock'],
+        dependencies: [{ file: 'composer.json', packages: ['symfony/framework-bundle'] }],
+        codePatterns: [/#\[Route\s*\(/, /extends\s+AbstractController/],
     },
     // Django
     {
         framework: enums_1.Framework.DJANGO,
         configFiles: ['manage.py'],
-        dependencies: [{ file: 'requirements.txt', packages: ['django', 'Django'] }],
+        dependencies: [
+            { file: 'requirements.txt', packages: ['django', 'Django'] },
+            { file: 'pyproject.toml', packages: ['django', 'Django'] },
+            { file: 'Pipfile', packages: ['django', 'Django'] },
+        ],
         codePatterns: [/from\s+django/, /INSTALLED_APPS/],
     },
     // Rails
@@ -186,15 +208,23 @@ const FRAMEWORK_DETECTORS = [
     {
         framework: enums_1.Framework.FASTAPI,
         configFiles: [],
-        dependencies: [{ file: 'requirements.txt', packages: ['fastapi'] }],
+        dependencies: [
+            { file: 'requirements.txt', packages: ['fastapi'] },
+            { file: 'pyproject.toml', packages: ['fastapi'] },
+            { file: 'Pipfile', packages: ['fastapi'] },
+        ],
         codePatterns: [/from\s+fastapi/, /@app\.(get|post|put|delete)\s*\(/],
     },
     // Flask
     {
         framework: enums_1.Framework.FLASK,
         configFiles: [],
-        dependencies: [{ file: 'requirements.txt', packages: ['flask', 'Flask'] }],
-        codePatterns: [/from\s+flask/, /Flask\s*\(__name__\)/],
+        dependencies: [
+            { file: 'requirements.txt', packages: ['flask', 'Flask'] },
+            { file: 'pyproject.toml', packages: ['flask', 'Flask'] },
+            { file: 'Pipfile', packages: ['flask', 'Flask'] },
+        ],
+        codePatterns: [/from\s+flask/, /Flask\s*\(\s*__name__\s*\)/],
     },
     // Gin (Go)
     {
@@ -247,7 +277,7 @@ let PS003FrameworkDetection = (() => {
                 // Check dependencies
                 if (detector.dependencies) {
                     for (const dep of detector.dependencies) {
-                        const depDetected = await this.checkDependency(projectRoot, dep.file, dep.packages);
+                        const depDetected = await this.checkDependency(projectRoot, dep.file, dep.packages, context.files);
                         if (depDetected) {
                             matches.push({
                                 type: enums_1.MatchType.CONFIG,
@@ -289,10 +319,26 @@ let PS003FrameworkDetection = (() => {
                 score,
             };
         }
-        async checkDependency(projectRoot, depFile, packages) {
-            // Handle glob patterns
+        async checkDependency(projectRoot, depFile, packages, files) {
+            // Handle glob patterns by searching matching files
             if (depFile.includes('*')) {
-                // Skip glob for now, check exact files
+                if (!files)
+                    return false;
+                const globRegex = new RegExp(`${depFile.replace(/\./g, '\\.').replace(/\*/g, '.*')}$`, 'i');
+                const matchingFiles = files.filter((f) => globRegex.test(f.fileName));
+                for (const file of matchingFiles) {
+                    try {
+                        const content = await file_scanner_1.FileScanner.readFileContent(file.absolutePath);
+                        for (const pkg of packages) {
+                            if (content.includes(pkg)) {
+                                return true;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip unreadable files
+                    }
+                }
                 return false;
             }
             const filePath = `${projectRoot}/${depFile}`;

package/engines/impact/cli.js

@@ -50,57 +50,72 @@ DESCRIPTION:
   components in TypeScript/JavaScript projects.
 
 OPTIONS:
-  --input=<path>          Source directory to analyze
-                          Default: src
 
-  --base=<ref>            Base git reference for comparison
-                          Default: HEAD~1 (previous commit)
-                          Examples: origin/main, HEAD~5, abc123
+  Input & Source:
+    --input=<path>          Source directory to analyze (default: src)
+    
+  Git References:
+    --base=<ref>            Base git reference (default: HEAD~1)
+    --head=<ref>            Head git reference (default: current working dir)
+    
+  Exclusions:
+    --exclude=<paths>       Comma-separated paths to exclude
+                            Example: --exclude=test,examples,mocks
+    --use-gitignore         Use .gitignore patterns for exclusions (recommended)
+                            This automatically excludes files ignored by git
+    
+  Analysis Options:
+    --max-depth=<n>         Maximum call chain depth (default: 3)
+    --include-tests         Include test files in analysis
+    --verbose               Show detailed analysis output
+    
+  Output:
+    --format=<type>         Output format: markdown, json, csv (default: markdown)
+    --output=<file>         Output file path (default: impact-report.md)
+    
+  Other:
+    --help                  Show this help message
 
-  --head=<ref>            Head git reference (optional)
-                          Default: (working directory)
-
-  --exclude=<paths>       Comma-separated paths to exclude
-                          Default: node_modules,dist,build,specs,coverage
-
-  --output=<file>         Output markdown report file
-                          Default: impact-report.md
-
-  --json=<file>           Output JSON report file (optional)
-                          Example: --json=impact-report.json
-
-  --max-depth=<n>         Maximum call graph depth
-                          Default: 3
-
-  --include-tests         Include test files in analysis
+EXAMPLES:
 
-  --verbose               Show verbose output and stack traces
+  Basic usage (analyze changes from last commit):
+    $ impact-analyzer --input=src --verbose
 
-  --no-fail               Don't exit with error on critical impact
+  Use .gitignore patterns (recommended for large projects):
+    $ impact-analyzer --input=src --use-gitignore --verbose
 
-  --help, -h              Show this help message
+  Analyze specific git range:
+    $ impact-analyzer --base=main --head=feature-branch
 
-EXAMPLES:
-  # Analyze changes in last commit (default)
-  impact-analyzer
+  Custom exclusions:
+    $ impact-analyzer --exclude=test,examples,fixtures
 
-  # Analyze changes between main branch and current
-  impact-analyzer --base=origin/main
+  Include tests in analysis:
+    $ impact-analyzer --include-tests
 
-  # Analyze specific directory with JSON output
-  impact-analyzer --input=backend/src --json=report.json
+  Generate JSON report:
+    $ impact-analyzer --format=json --output=impact.json
 
-  # Analyze last 3 commits with verbose output
-  impact-analyzer --base=HEAD~3 --verbose
+PERFORMANCE TIPS:
 
-  # Compare two specific commits
-  impact-analyzer --base=abc123 --head=def456
+  ⚡ Use --use-gitignore for automatic exclusion of unnecessary files
+     This can reduce analysis time by 60-90% on large projects!
+  
+  ⚡ Exclude test/example directories if not needed:
+     --exclude=test,tests,examples,samples,mocks
+  
+  ⚡ For large codebases, limit max-depth:
+     --max-depth=2
 
-REFERENCE:
-  Architecture: .specify/plans/architecture.md
-  Coding Rules: .github/copilot-instructions.md
+DEFAULT EXCLUSIONS (when not using --use-gitignore):
 
-For more information, visit: https://github.com/sun-asterisk/impact-analyzer
+  • node_modules, dist, build, out
+  • test files: *.test.ts, *.spec.ts
+  • examples, samples, fixtures, mocks
+  • coverage, reports
+  • .cache, .temp, .history
+  • IDE: .idea, .vscode
+  • Type definitions: *.d.ts
 `);
   }
 }

package/engines/impact/config/default-config.js

@@ -3,15 +3,49 @@
  * Loads and validates configuration from CLI args and defaults
  */
 
+import { GitignoreParser, gitignoreToExcludePaths } from '../core/utils/gitignore-parser.js';
+import path from 'path';
+
 export function loadConfig(cli) {
+  const sourceDir = cli.getArg('input', 'src');
+  const rootDir = path.resolve(sourceDir, '..');
+  
+  // Load patterns from .gitignore
+  const gitignorePatterns = cli.hasArg('use-gitignore') 
+    ? gitignoreToExcludePaths(rootDir)
+    : [];
+
+  // Custom exclude paths from CLI
+  const customExcludes = cli.getArg('exclude', '')
+    .split(',')
+    .map(p => p.trim())
+    .filter(p => p);
+
+  // Merge: gitignore + custom + defaults
+  const allExcludes = [
+    ...new Set([
+      ...gitignorePatterns,
+      ...customExcludes,
+      ...DEFAULT_EXCLUDE_PATHS,
+    ])
+  ];
+
   const config = {
     // Source directory to analyze
-    sourceDir: cli.getArg('input', 'src'),
+    sourceDir: sourceDir,
+    rootDir: rootDir,
 
     // Paths to exclude from analysis
-    excludePaths: cli.getArg('exclude', 'node_modules,dist,build,specs,coverage')
-      .split(',')
-      .map(p => p.trim()),
+    excludePaths: allExcludes,
+    
+    // Gitignore parser for advanced pattern matching
+    gitignoreParser: cli.hasArg('use-gitignore') 
+      ? (() => {
+          const parser = new GitignoreParser(rootDir);
+          parser.loadGitignore();
+          return parser;
+        })()
+      : null,
 
     // Git references - defaults to HEAD~1 (previous commit)
     baseRef: cli.getArg('base', 'HEAD~1'),
@@ -41,9 +75,75 @@ function validateConfig(config) {
   // baseRef and headRef are optional, have sensible defaults
 }
 
+// Default exclude paths - comprehensive list
+const DEFAULT_EXCLUDE_PATHS = [
+  // Build & Dependencies
+  'node_modules',
+  'dist',
+  'build',
+  'out',
+  '.turbo',
+  '.next',
+  
+  // Tests (unless --include-tests)
+  '__tests__',
+  'test',
+  'tests',
+  '.test.ts',
+  '.spec.ts',
+  '.test.js',
+  '.spec.js',
+  '.test.tsx',
+  '.spec.tsx',
+  
+  // Examples & Samples
+  'examples',
+  'samples',
+  'fixtures',
+  'mocks',
+  '__mocks__',
+  'project-samples',
+  
+  // Coverage & Reports
+  'coverage',
+  'reports',
+  '.nyc_output',
+  
+  // Cache & Temp
+  '.cache',
+  '.temp',
+  '.tmp',
+  '.history',
+  
+  // Documentation Sites
+  'pages/_site',
+  '_site',
+  '.jekyll-cache',
+  '.jekyll-metadata',
+  'vendor',
+  '.bundle',
+  
+  // IDE & Tools
+  '.idea',
+  '.vscode',
+  '.github',
+  '.agent',
+  '.claude',
+  '.serena',
+  
+  // Config-specific
+  'specs',
+  '.sunlint-cache',
+  'origin-rules',
+  'arch-detect',
+  
+  // Type definitions (no runtime code to analyze)
+  '.d.ts',
+];
+
 export const DEFAULT_CONFIG = {
   sourceDir: 'src',
-  excludePaths: ['node_modules', 'dist', 'build', 'specs', 'coverage'],
+  excludePaths: DEFAULT_EXCLUDE_PATHS,
   baseRef: 'HEAD~1',  // Previous commit
   headRef: 'HEAD',     // Current commit
   maxDepth: 3,

package/engines/impact/core/impact-analyzer.js

@@ -20,7 +20,8 @@ export class ImpactAnalyzer {
     await this.methodCallGraph.initialize(
       this.absoluteSourceDir,
       this.config.excludePaths,
-      this.config.verbose
+      this.config.verbose,
+      this.config.gitignoreParser || null
     );
 
     this.endpointDetector = new EndpointDetector(this.methodCallGraph, this.config);
@@ -69,28 +70,24 @@ export class ImpactAnalyzer {
 
   detectLogicImpact(changedSymbols) {
     const directCallers = new Set();
-    const indirectCallers = new Set();
+    const allCallers = new Set();
 
     for (const symbol of changedSymbols) {
       const methodName = `${symbol.className || 'global'}.${symbol.name}`;
-      const callers = this.methodCallGraph.findAllCallers(methodName);
       
-      callers.forEach(caller => {
-        directCallers.add(caller);
-        
-        const indirectCallersOfCaller = this.methodCallGraph.findAllCallers(caller);
-        indirectCallersOfCaller.forEach(ic => {
-          if (!callers.includes(ic)) {
-            indirectCallers.add(ic);
-          }
-        });
-      });
+      const immediateCallers = this.methodCallGraph.getCallers(methodName);
+      immediateCallers.forEach(caller => directCallers.add(caller));
+      
+      const recursiveCallers = this.methodCallGraph.findAllCallers(methodName);
+      recursiveCallers.forEach(caller => allCallers.add(caller));
     }
 
+    const indirectCallers = Array.from(allCallers).filter(caller => !directCallers.has(caller));
+
     return {
       directCallers: Array.from(directCallers),
-      indirectCallers: Array.from(indirectCallers),
-      riskLevel: this.calculateRiskLevel(directCallers.size, indirectCallers.size),
+      indirectCallers: indirectCallers,
+      riskLevel: this.calculateRiskLevel(directCallers.size, indirectCallers.length),
     };
   }
 

package/engines/impact/core/utils/gitignore-parser.js

@@ -0,0 +1,123 @@
+/**
+ * Gitignore Parser
+ * Reads .gitignore files and converts patterns to exclude paths
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { minimatch } from 'minimatch';
+
+export class GitignoreParser {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.patterns = [];
+    this.negationPatterns = [];
+  }
+
+  /**
+   * Load patterns from .gitignore file
+   */
+  loadGitignore(gitignorePath = null) {
+    const ignoreFile = gitignorePath || path.join(this.rootDir, '.gitignore');
+    
+    if (!fs.existsSync(ignoreFile)) {
+      return [];
+    }
+
+    const content = fs.readFileSync(ignoreFile, 'utf8');
+    const lines = content.split('\n');
+
+    const patterns = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      // Handle negation patterns (!)
+      if (trimmed.startsWith('!')) {
+        this.negationPatterns.push(trimmed.substring(1));
+        continue;
+      }
+
+      patterns.push(trimmed);
+    }
+
+    this.patterns = patterns;
+    return patterns;
+  }
+
+  /**
+   * Check if a file path should be excluded based on gitignore patterns
+   */
+  shouldExclude(filePath) {
+    // Normalize path separators
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    
+    // Check if path matches any pattern
+    for (const pattern of this.patterns) {
+      if (this.matchesPattern(normalizedPath, pattern)) {
+        // Check if there's a negation pattern that overrides
+        const isNegated = this.negationPatterns.some(negPattern => 
+          this.matchesPattern(normalizedPath, negPattern)
+        );
+        
+        if (!isNegated) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Match a file path against a gitignore pattern
+   */
+  matchesPattern(filePath, pattern) {
+    // Handle directory-only patterns (ending with /)
+    if (pattern.endsWith('/')) {
+      const dirPattern = pattern.slice(0, -1);
+      return filePath.includes(`/${dirPattern}/`) || filePath.includes(`${dirPattern}/`);
+    }
+
+    // Handle patterns starting with /
+    if (pattern.startsWith('/')) {
+      return minimatch(filePath, pattern.substring(1), { matchBase: true });
+    }
+
+    // Handle wildcards and glob patterns
+    if (pattern.includes('*') || pattern.includes('?') || pattern.includes('[')) {
+      return minimatch(filePath, pattern, { matchBase: true, dot: true });
+    }
+
+    // Simple substring match for paths
+    return filePath.includes(pattern) || 
+           filePath.includes(`/${pattern}/`) ||
+           filePath.endsWith(`/${pattern}`);
+  }
+
+  /**
+   * Get all patterns
+   */
+  getPatterns() {
+    return this.patterns;
+  }
+}
+
+/**
+ * Convert gitignore patterns to simple exclude path list
+ * for backward compatibility
+ */
+export function gitignoreToExcludePaths(rootDir) {
+  const parser = new GitignoreParser(rootDir);
+  parser.loadGitignore();
+  
+  // Extract simple path patterns (non-glob)
+  const simplePaths = parser.getPatterns().filter(p => 
+    !p.includes('*') && !p.includes('?') && !p.includes('[')
+  );
+  
+  return simplePaths.map(p => p.replace(/^\//, '').replace(/\/$/, ''));
+}