Add comprehensive tests for directory exclusion patterns

Co-authored-by: danielmeppiel <51440732+danielmeppiel@users.noreply.github.com>

Author: Copilot

src/apm_cli/compilation/context_optimizer.py

@@ -470,30 +470,91 @@ def _should_exclude_path(self, path: Path) -> bool:
             # Path is not relative to base_dir, don't exclude
             return False
 
-        # Convert to string with forward slashes for consistent glob matching
-        rel_path_str = str(rel_path).replace(os.sep, '/')
-        
         # Check each exclusion pattern
         for pattern in self._exclude_patterns:
-            # Normalize pattern to use forward slashes
-            normalized_pattern = pattern.replace(os.sep, '/')
-            
-            # Use fnmatch for glob pattern matching
-            if fnmatch.fnmatch(rel_path_str, normalized_pattern):
+            if self._matches_pattern(rel_path, pattern):
                 return True
+        
+        return False
+    
+    def _matches_pattern(self, rel_path: Path, pattern: str) -> bool:
+        """Check if a relative path matches an exclusion pattern.
+        
+        Supports glob patterns including ** for recursive matching.
+        
+        Args:
+            rel_path: Path relative to base_dir
+            pattern: Exclusion pattern (glob syntax)
             
-            # Also check if the path starts with the pattern (for directory matching)
-            # This handles cases like "apm_modules/" matching "apm_modules/foo/bar"
-            if normalized_pattern.endswith('/'):
-                if rel_path_str.startswith(normalized_pattern) or rel_path_str == normalized_pattern.rstrip('/'):
-                    return True
-            else:
-                # Check if pattern with trailing slash would match
-                if rel_path_str.startswith(normalized_pattern + '/') or rel_path_str == normalized_pattern:
-                    return True
+        Returns:
+            True if path matches pattern, False otherwise
+        """
+        # Normalize pattern to use forward slashes
+        normalized_pattern = pattern.replace(os.sep, '/')
+        
+        # Convert path to string with forward slashes
+        rel_path_str = str(rel_path).replace(os.sep, '/')
+        
+        # Handle ** patterns (match any number of directories)
+        if '**' in normalized_pattern:
+            # Convert ** glob to regex-like matching
+            # Split pattern into parts
+            parts = normalized_pattern.split('/')
+            path_parts = rel_path_str.split('/')
+            
+            # Try to match using recursive logic
+            return self._match_glob_recursive(path_parts, parts)
+        
+        # Simple fnmatch for patterns without **
+        if fnmatch.fnmatch(rel_path_str, normalized_pattern):
+            return True
+        
+        # Also check if the path starts with the pattern (for directory matching)
+        # This handles cases like "apm_modules/" matching "apm_modules/foo/bar"
+        if normalized_pattern.endswith('/'):
+            if rel_path_str.startswith(normalized_pattern) or rel_path_str == normalized_pattern.rstrip('/'):
+                return True
+        else:
+            # Check if pattern with trailing slash would match
+            if rel_path_str.startswith(normalized_pattern + '/') or rel_path_str == normalized_pattern:
+                return True
 
         return False
 
+    def _match_glob_recursive(self, path_parts: list, pattern_parts: list) -> bool:
+        """Recursively match path parts against pattern parts with ** support.
+        
+        Args:
+            path_parts: List of path components
+            pattern_parts: List of pattern components
+            
+        Returns:
+            True if path matches pattern, False otherwise
+        """
+        if not pattern_parts:
+            return not path_parts
+        
+        if not path_parts:
+            # Check if remaining pattern parts are all ** or empty
+            return all(p == '**' or p == '' for p in pattern_parts)
+        
+        pattern_part = pattern_parts[0]
+        
+        if pattern_part == '**':
+            # ** matches zero or more directories
+            # Try matching with zero directories
+            if self._match_glob_recursive(path_parts, pattern_parts[1:]):
+                return True
+            # Try matching with one or more directories
+            if self._match_glob_recursive(path_parts[1:], pattern_parts):
+                return True
+            return False
+        else:
+            # Regular pattern part - must match current path part
+            if fnmatch.fnmatch(path_parts[0], pattern_part):
+                return self._match_glob_recursive(path_parts[1:], pattern_parts[1:])
+            return False
+    
     def _find_optimal_placements(
         self,
         instruction: Instruction,

tests/unit/compilation/test_compilation.py

@@ -375,6 +375,102 @@ def test_compilation_config_from_apm_yml(self):
 
         # Clean up
         Path('apm.yml').unlink()
+    
+    def test_compilation_config_exclude_patterns_from_yml(self):
+        """Test loading exclude patterns from apm.yml."""
+        # Create test apm.yml with exclude patterns
+        test_config = {
+            'name': 'test-project',
+            'version': '1.0.0',
+            'compilation': {
+                'exclude': [
+                    'apm_modules/**',
+                    'tmp/**',
+                    'projects/packages/apm/**'
+                ]
+            }
+        }
+        
+        with open('apm.yml', 'w') as f:
+            yaml.dump(test_config, f)
+        
+        # Test config loading
+        config = CompilationConfig.from_apm_yml()
+        self.assertIsNotNone(config.exclude)
+        self.assertEqual(len(config.exclude), 3)
+        self.assertIn('apm_modules/**', config.exclude)
+        self.assertIn('tmp/**', config.exclude)
+        self.assertIn('projects/packages/apm/**', config.exclude)
+        
+        # Clean up
+        Path('apm.yml').unlink()
+    
+    def test_compilation_config_exclude_patterns_single_string(self):
+        """Test loading a single exclude pattern as string from apm.yml."""
+        # Create test apm.yml with single exclude pattern as string
+        test_config = {
+            'name': 'test-project',
+            'version': '1.0.0',
+            'compilation': {
+                'exclude': 'tmp/**'
+            }
+        }
+        
+        with open('apm.yml', 'w') as f:
+            yaml.dump(test_config, f)
+        
+        # Test config loading
+        config = CompilationConfig.from_apm_yml()
+        self.assertIsNotNone(config.exclude)
+        self.assertEqual(len(config.exclude), 1)
+        self.assertEqual(config.exclude[0], 'tmp/**')
+        
+        # Clean up
+        Path('apm.yml').unlink()
+    
+    def test_compilation_config_no_exclude_patterns(self):
+        """Test that config initializes with empty list when no exclude patterns."""
+        # Create test apm.yml without exclude patterns
+        test_config = {
+            'name': 'test-project',
+            'version': '1.0.0',
+            'compilation': {
+                'output': 'AGENTS.md'
+            }
+        }
+        
+        with open('apm.yml', 'w') as f:
+            yaml.dump(test_config, f)
+        
+        # Test config loading
+        config = CompilationConfig.from_apm_yml()
+        self.assertIsNotNone(config.exclude)
+        self.assertEqual(len(config.exclude), 0)
+        
+        # Clean up
+        Path('apm.yml').unlink()
+    
+    def test_compilation_config_exclude_patterns_override(self):
+        """Test that command-line overrides work for exclude patterns."""
+        # Create test apm.yml with exclude patterns
+        test_config = {
+            'name': 'test-project',
+            'version': '1.0.0',
+            'compilation': {
+                'exclude': ['apm_modules/**']
+            }
+        }
+        
+        with open('apm.yml', 'w') as f:
+            yaml.dump(test_config, f)
+        
+        # Test config with override
+        override_patterns = ['tmp/**', 'coverage/**']
+        config = CompilationConfig.from_apm_yml(exclude=override_patterns)
+        self.assertEqual(config.exclude, override_patterns)
+        
+        # Clean up
+        Path('apm.yml').unlink()
 
 
 if __name__ == '__main__':

tests/unit/compilation/test_context_optimizer.py

@@ -514,5 +514,168 @@ def test_real_project_optimization_benefits(self, temp_project):
             assert optimized_efficiency >= naive_efficiency or optimized_efficiency >= 0.3
 
 
+class TestDirectoryExclusion:
+    """Test directory exclusion patterns in ContextOptimizer."""
+    
+    def test_should_exclude_path_no_patterns(self):
+        """Test that no exclusions occur when no patterns are provided."""
+        optimizer = ContextOptimizer(base_dir="/test", exclude_patterns=None)
+        assert not optimizer._should_exclude_path(Path("/test/src"))
+        assert not optimizer._should_exclude_path(Path("/test/apm_modules"))
+    
+    def test_should_exclude_path_simple_directory(self):
+        """Test exclusion of simple directory patterns."""
+        optimizer = ContextOptimizer(
+            base_dir="/test", 
+            exclude_patterns=["apm_modules", "tmp"]
+        )
+        assert optimizer._should_exclude_path(Path("/test/apm_modules"))
+        assert optimizer._should_exclude_path(Path("/test/tmp"))
+        assert not optimizer._should_exclude_path(Path("/test/src"))
+    
+    def test_should_exclude_path_with_trailing_slash(self):
+        """Test exclusion patterns with trailing slashes."""
+        optimizer = ContextOptimizer(
+            base_dir="/test", 
+            exclude_patterns=["apm_modules/", "tmp/"]
+        )
+        assert optimizer._should_exclude_path(Path("/test/apm_modules"))
+        assert optimizer._should_exclude_path(Path("/test/apm_modules/package"))
+        assert optimizer._should_exclude_path(Path("/test/tmp"))
+        assert not optimizer._should_exclude_path(Path("/test/src"))
+    
+    def test_should_exclude_path_nested_directories(self):
+        """Test exclusion of nested directory patterns."""
+        optimizer = ContextOptimizer(
+            base_dir="/test", 
+            exclude_patterns=["projects/packages/apm"]
+        )
+        assert optimizer._should_exclude_path(Path("/test/projects/packages/apm"))
+        assert optimizer._should_exclude_path(Path("/test/projects/packages/apm/src"))
+        assert not optimizer._should_exclude_path(Path("/test/projects/packages/other"))
+    
+    def test_should_exclude_path_glob_patterns(self):
+        """Test exclusion using glob patterns."""
+        optimizer = ContextOptimizer(
+            base_dir="/test", 
+            exclude_patterns=["**/test-fixtures", "coverage/**"]
+        )
+        assert optimizer._should_exclude_path(Path("/test/test-fixtures"))
+        assert optimizer._should_exclude_path(Path("/test/src/test-fixtures"))
+        assert optimizer._should_exclude_path(Path("/test/coverage"))
+        assert optimizer._should_exclude_path(Path("/test/coverage/report"))
+        assert not optimizer._should_exclude_path(Path("/test/src"))
+    
+    def test_should_exclude_path_wildcard_patterns(self):
+        """Test exclusion using wildcard patterns."""
+        optimizer = ContextOptimizer(
+            base_dir="/test", 
+            exclude_patterns=["tmp*", "*cache*"]
+        )
+        assert optimizer._should_exclude_path(Path("/test/tmp"))
+        assert optimizer._should_exclude_path(Path("/test/tmp123"))
+        assert optimizer._should_exclude_path(Path("/test/cache"))
+        assert optimizer._should_exclude_path(Path("/test/mycache"))
+        assert not optimizer._should_exclude_path(Path("/test/src"))
+    
+    def test_should_exclude_path_complex_glob(self):
+        """Test complex glob patterns."""
+        optimizer = ContextOptimizer(
+            base_dir="/test", 
+            exclude_patterns=["projects/**/apm/**", "**/node_modules/**"]
+        )
+        assert optimizer._should_exclude_path(Path("/test/projects/packages/apm"))
+        assert optimizer._should_exclude_path(Path("/test/projects/packages/apm/src"))
+        assert optimizer._should_exclude_path(Path("/test/node_modules"))
+        assert optimizer._should_exclude_path(Path("/test/src/node_modules"))
+        assert not optimizer._should_exclude_path(Path("/test/projects/other"))
+    
+    def test_should_exclude_path_path_outside_base_dir(self):
+        """Test that paths outside base_dir are not excluded."""
+        optimizer = ContextOptimizer(
+            base_dir="/test", 
+            exclude_patterns=["apm_modules"]
+        )
+        # Path that's not relative to base_dir should not be excluded
+        assert not optimizer._should_exclude_path(Path("/other/apm_modules"))
+    
+    def test_analyze_project_structure_with_exclusions(self):
+        """Test that _analyze_project_structure respects exclusion patterns."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            base_path = Path(tmpdir)
+            
+            # Create directory structure
+            (base_path / "src").mkdir()
+            (base_path / "src" / "file.py").touch()
+            (base_path / "apm_modules").mkdir()
+            (base_path / "apm_modules" / "file.py").touch()
+            (base_path / "tmp").mkdir()
+            (base_path / "tmp" / "file.py").touch()
+            
+            # Create optimizer with exclusions
+            optimizer = ContextOptimizer(
+                base_dir=str(base_path),
+                exclude_patterns=["apm_modules", "tmp"]
+            )
+            optimizer._analyze_project_structure()
+            
+            # Check that excluded directories are not in cache
+            cached_dirs = set(optimizer._directory_cache.keys())
+            assert base_path / "src" in cached_dirs
+            assert base_path / "apm_modules" not in cached_dirs
+            assert base_path / "tmp" not in cached_dirs
+    
+    def test_analyze_project_structure_with_nested_exclusions(self):
+        """Test that nested exclusions work correctly."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            base_path = Path(tmpdir)
+            
+            # Create nested directory structure
+            (base_path / "projects" / "packages" / "apm" / "src").mkdir(parents=True)
+            (base_path / "projects" / "packages" / "apm" / "src" / "file.py").touch()
+            (base_path / "projects" / "packages" / "other" / "src").mkdir(parents=True)
+            (base_path / "projects" / "packages" / "other" / "src" / "file.py").touch()
+            
+            # Create optimizer with nested exclusion
+            optimizer = ContextOptimizer(
+                base_dir=str(base_path),
+                exclude_patterns=["projects/packages/apm/**"]
+            )
+            optimizer._analyze_project_structure()
+            
+            # Check that excluded directories are not in cache
+            cached_dirs = set(optimizer._directory_cache.keys())
+            assert base_path / "projects" / "packages" / "apm" not in cached_dirs
+            assert base_path / "projects" / "packages" / "apm" / "src" not in cached_dirs
+            # Other directories should be present
+            assert base_path / "projects" / "packages" / "other" / "src" in cached_dirs
+    
+    def test_default_exclusions_still_work(self):
+        """Test that default hardcoded exclusions still work alongside custom patterns."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            base_path = Path(tmpdir)
+            
+            # Create directories including default exclusions
+            (base_path / "src").mkdir()
+            (base_path / "src" / "file.py").touch()
+            (base_path / "node_modules").mkdir()
+            (base_path / "node_modules" / "file.js").touch()
+            (base_path / "custom_exclude").mkdir()
+            (base_path / "custom_exclude" / "file.py").touch()
+            
+            # Create optimizer with custom exclusion only
+            optimizer = ContextOptimizer(
+                base_dir=str(base_path),
+                exclude_patterns=["custom_exclude"]
+            )
+            optimizer._analyze_project_structure()
+            
+            # Check that both default and custom exclusions work
+            cached_dirs = set(optimizer._directory_cache.keys())
+            assert base_path / "src" in cached_dirs
+            assert base_path / "node_modules" not in cached_dirs  # Default exclusion
+            assert base_path / "custom_exclude" not in cached_dirs  # Custom exclusion
+
+
 if __name__ == "__main__":
     pytest.main([__file__])