Global Exclusion Pattern System

docs/example/config/exclude-config.yaml

@@ -0,0 +1,28 @@
+# Example configuration with exclusion patterns
+
+# Global exclusion patterns
+exclude:
+  # File patterns to exclude globally (glob patterns with wildcards)
+  patterns:
+    - "**/.env*"
+    - "**/config/secrets.yaml"
+    - "**/*.pem"
+    - "**/*.key"
+    - "**/id_rsa"
+    - "**/credentials.json"
+
+  # Paths to exclude globally (exact directories or files)
+  paths:
+    - ".secrets/"
+    - "config/credentials/"
+    - "node_modules"
+    - "vendor"
+
+# Regular configuration continues
+documents:
+  - description: "Project Documentation"
+    outputPath: "docs/project.md"
+    sources:
+      - type: file
+        sourcePaths: 
+          - "src/"

json-schema.json

@@ -44,6 +44,26 @@
         "$ref": "#/definitions/prompt"
       }
     },
+    "exclude": {
+      "type": "object",
+      "description": "Global exclusion patterns for filtering files from being included in documents",
+      "properties": {
+        "patterns": {
+          "type": "array",
+          "description": "Glob patterns to exclude files globally (e.g., '**/.env*', '**/*.pem')",
+          "items": {
+            "type": "string"
+          }
+        },
+        "paths": {
+          "type": "array",
+          "description": "Specific paths to exclude globally (directories or files)",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
     "variables": {
       "type": "object",
       "description": "Custom variables to use throughout the configuration",
@@ -705,7 +725,7 @@
           }
         }
       },
-      "allOf": [
+      "anyOf": [
         {
           "if": {
             "properties": {

src/Application/Bootloader/ExcludeBootloader.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Application\Bootloader;
+
+use Butschster\ContextGenerator\Config\Exclude\ExcludeParserPlugin;
+use Butschster\ContextGenerator\Config\Exclude\ExcludeRegistry;
+use Butschster\ContextGenerator\Config\Exclude\ExcludeRegistryInterface;
+use Spiral\Boot\Bootloader\Bootloader;
+use Spiral\Core\Attribute\Singleton;
+
+#[Singleton]
+final class ExcludeBootloader extends Bootloader
+{
+    #[\Override]
+    public function defineSingletons(): array
+    {
+        return [
+            ExcludeRegistryInterface::class => ExcludeRegistry::class,
+        ];
+    }
+
+    public function boot(ConfigLoaderBootloader $configLoader, ExcludeParserPlugin $excludeParser): void
+    {
+        // Register the exclude parser plugin
+        $configLoader->registerParserPlugin($excludeParser);
+    }
+}

src/Application/Kernel.php

@@ -10,6 +10,7 @@
 use Butschster\ContextGenerator\Application\Bootloader\ConsoleBootloader;
 use Butschster\ContextGenerator\Application\Bootloader\ContentRendererBootloader;
 use Butschster\ContextGenerator\Application\Bootloader\CoreBootloader;
+use Butschster\ContextGenerator\Application\Bootloader\ExcludeBootloader;
 use Butschster\ContextGenerator\Application\Bootloader\GithubClientBootloader;
 use Butschster\ContextGenerator\Application\Bootloader\GitlabClientBootloader;
 use Butschster\ContextGenerator\Application\Bootloader\HttpClientBootloader;
@@ -58,9 +59,10 @@ protected function defineBootloaders(): array
             GithubClientBootloader::class,
             ComposerClientBootloader::class,
             ConfigLoaderBootloader::class,
+            VariableBootloader::class,
+            ExcludeBootloader::class,
             ModifierBootloader::class,
             ContentRendererBootloader::class,
-            VariableBootloader::class,
             SourceFetcherBootloader::class,
             SourceRegistryBootloader::class,
 

src/Config/Exclude/AbstractExclusion.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Config\Exclude;
+
+/**
+ * Base class for all exclusion patterns
+ */
+abstract readonly class AbstractExclusion implements ExclusionPatternInterface
+{
+    /**
+     * @param string $pattern Exclusion pattern value
+     */
+    public function __construct(
+        protected string $pattern,
+    ) {}
+
+    /**
+     * Get the raw pattern string
+     */
+    public function getPattern(): string
+    {
+        return $this->pattern;
+    }
+
+    /**
+     * Abstract method to check if a path matches this pattern
+     */
+    abstract public function matches(string $path): bool;
+
+    /**
+     * Normalize a pattern for consistent comparison
+     */
+    protected function normalizePattern(string $pattern): string
+    {
+        $pattern = \preg_replace('#^\./#', '', $pattern);
+
+        // Remove trailing slash
+        return \rtrim((string) $pattern, '/');
+    }
+}

src/Config/Exclude/ExcludeParserPlugin.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Config\Exclude;
+
+use Butschster\ContextGenerator\Application\Logger\LoggerPrefix;
+use Butschster\ContextGenerator\Config\Parser\ConfigParserPluginInterface;
+use Butschster\ContextGenerator\Config\Registry\RegistryInterface;
+use Psr\Log\LoggerInterface;
+
+/**
+ * Parser plugin for the 'exclude' section in configuration
+ */
+final readonly class ExcludeParserPlugin implements ConfigParserPluginInterface
+{
+    public function __construct(
+        private ExcludeRegistryInterface $registry,
+        #[LoggerPrefix(prefix: 'exclude-parser')]
+        private ?LoggerInterface $logger = null,
+    ) {}
+
+    public function getConfigKey(): string
+    {
+        return 'exclude';
+    }
+
+    public function supports(array $config): bool
+    {
+        return isset($config['exclude']) && \is_array($config['exclude']);
+    }
+
+    public function parse(array $config, string $rootPath): ?RegistryInterface
+    {
+        if (!$this->supports($config)) {
+            return null;
+        }
+
+        \assert($this->registry instanceof RegistryInterface);
+        $excludeConfig = $config['exclude'];
+
+        // Parse patterns
+        if (isset($excludeConfig['patterns']) && \is_array($excludeConfig['patterns'])) {
+            $this->parsePatterns($excludeConfig['patterns']);
+        }
+
+        // Parse paths
+        if (isset($excludeConfig['paths']) && \is_array($excludeConfig['paths'])) {
+            $this->parsePaths($excludeConfig['paths']);
+        }
+
+        $this->logger?->info('Parsed exclusion configuration', [
+            'patternCount' => \count($this->registry->getPatterns()),
+        ]);
+
+        return $this->registry;
+    }
+
+    public function updateConfig(array $config, string $rootPath): array
+    {
+        // We don't need to modify the config, just return it as is
+        return $config;
+    }
+
+    /**
+     * Parse glob pattern exclusions
+     */
+    private function parsePatterns(array $patterns): void
+    {
+        foreach ($patterns as $pattern) {
+            if (!\is_string($pattern) || empty($pattern)) {
+                $this->logger?->warning('Invalid exclusion pattern, skipping', [
+                    'pattern' => $pattern,
+                ]);
+                continue;
+            }
+
+            $this->registry->addPattern(new PatternExclusion($pattern));
+        }
+    }
+
+    /**
+     * Parse path exclusions
+     */
+    private function parsePaths(array $paths): void
+    {
+        foreach ($paths as $path) {
+            if (!\is_string($path) || empty($path)) {
+                $this->logger?->warning('Invalid exclusion path, skipping', [
+                    'path' => $path,
+                ]);
+                continue;
+            }
+
+            $this->registry->addPattern(new PathExclusion($path));
+        }
+    }
+}

src/Config/Exclude/ExcludeRegistry.php

@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Config\Exclude;
+
+use Butschster\ContextGenerator\Application\Logger\LoggerPrefix;
+use Butschster\ContextGenerator\Config\Registry\RegistryInterface;
+use Psr\Log\LoggerInterface;
+use Spiral\Core\Attribute\Singleton;
+
+/**
+ * Registry for file exclusion patterns
+ *
+ * @implements RegistryInterface<ExclusionPatternInterface>
+ */
+#[Singleton]
+final class ExcludeRegistry implements ExcludeRegistryInterface, RegistryInterface
+{
+    /** @var array<ExclusionPatternInterface> */
+    private array $patterns = [];
+
+    public function __construct(
+        #[LoggerPrefix(prefix: 'exclude-registry')]
+        private readonly ?LoggerInterface $logger = null,
+    ) {}
+
+    /**
+     * Add a new exclusion pattern
+     */
+    public function addPattern(ExclusionPatternInterface $pattern): self
+    {
+        $this->patterns[] = $pattern;
+
+        $this->logger?->debug('Added exclusion pattern', [
+            'pattern' => $pattern->getPattern(),
+        ]);
+
+        return $this;
+    }
+
+    /**
+     * Check if a path should be excluded
+     */
+    public function shouldExclude(string $path): bool
+    {
+        foreach ($this->patterns as $pattern) {
+            if ($pattern->matches($path)) {
+                $this->logger?->debug('Path excluded by pattern', [
+                    'path' => $path,
+                    'pattern' => $pattern->getPattern(),
+                ]);
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Get all registered exclusion patterns
+     */
+    public function getPatterns(): array
+    {
+        return $this->patterns;
+    }
+
+    /**
+     * Get the registry type
+     */
+    public function getType(): string
+    {
+        return 'exclude';
+    }
+
+    /**
+     * Get all items in the registry
+     */
+    public function getItems(): array
+    {
+        return $this->patterns;
+    }
+
+    /**
+     * Make the registry iterable
+     */
+    public function getIterator(): \Traversable
+    {
+        return new \ArrayIterator($this->patterns);
+    }
+
+    /**
+     * JSON serialization
+     */
+    public function jsonSerialize(): array
+    {
+        return [
+            'patterns' => \array_map(
+                static fn(ExclusionPatternInterface $pattern) => $pattern->jsonSerialize(),
+                $this->patterns,
+            ),
+        ];
+    }
+}

src/Config/Exclude/ExcludeRegistryInterface.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Config\Exclude;
+
+/**
+ * Interface for exclusion pattern registry
+ */
+interface ExcludeRegistryInterface
+{
+    /**
+     * Add an exclusion pattern
+     */
+    public function addPattern(ExclusionPatternInterface $pattern): self;
+
+    /**
+     * Check if a path should be excluded
+     */
+    public function shouldExclude(string $path): bool;
+
+    /**
+     * Get all registered exclusion patterns
+     *
+     * @return array<ExclusionPatternInterface>
+     */
+    public function getPatterns(): array;
+}