feat: implement Change Chunks patch application system

Add comprehensive file-apply-patch MCP tool with progressive fuzzy matching capabilities for applying human-readable change chunks to files.

Author: butschster

src/Lib/ApplyPatchParser/ApplyResult.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Lib\ApplyPatchParser;
+
+final readonly class ApplyResult
+{
+    public function __construct(
+        public bool $success,
+        /**
+         * @var string[]
+         */
+        public array $modifiedContent,
+        /**
+         * @var string[]
+         */
+        public array $appliedChanges = [],
+        /**
+         * @var string[]
+         */
+        public array $errors = [],
+    ) {}
+
+    public function getModifiedContentAsString(): string
+    {
+        return \implode("\n", $this->modifiedContent);
+    }
+
+    public function hasErrors(): bool
+    {
+        return !empty($this->errors);
+    }
+
+    public function getSummary(): string
+    {
+        if (!$this->success) {
+            return \sprintf('Failed to apply changes: %s', \implode(', ', $this->errors));
+        }
+
+        return \sprintf(
+            'Successfully applied %d change chunks. %s',
+            \count($this->appliedChanges),
+            \implode('; ', $this->appliedChanges),
+        );
+    }
+}

src/Lib/ApplyPatchParser/ChangeChunkConfig.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Lib\ApplyPatchParser;
+
+use Spiral\JsonSchemaGenerator\Attribute\Field;
+
+final readonly class ChangeChunkConfig
+{
+    public function __construct(
+        #[Field(
+            description: 'Enable case-sensitive matching',
+            default: true,
+        )]
+        public bool $caseSensitive = true,
+        #[Field(
+            description: 'Preserve exact whitespace formatting',
+            default: false,
+        )]
+        public bool $preserveWhitespace = false,
+        #[Field(
+            description: 'Maximum number of lines to search for context markers',
+            default: 100,
+        )]
+        public int $maxSearchLines = 100,
+        #[Field(
+            description: 'Minimum confidence score required for fuzzy matching (0.0-1.0)',
+            default: 0.7,
+        )]
+        public float $minConfidence = 0.7,
+    ) {}
+}

src/Lib/ApplyPatchParser/ChangeChunkProcessor.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Lib\ApplyPatchParser;
+
+use Butschster\ContextGenerator\McpServer\Action\Tools\Filesystem\Dto\FileApplyPatchRequest;
+
+final readonly class ChangeChunkProcessor
+{
+    public function __construct(
+        private ChunkParser $parser = new ChunkParser(),
+        private ContextMatcher $contextMatcher = new ContextMatcher(),
+        private ChangeValidator $validator = new ChangeValidator(),
+        private ChunkApplier $applier = new ChunkApplier(),
+    ) {}
+
+    public function processChanges(
+        FileApplyPatchRequest $request,
+        ChangeChunkConfig $config,
+        string $fileContent,
+    ): ProcessResult {
+        $contentLines = $this->splitIntoLines($fileContent);
+
+        // Step 1: Parse all chunks
+        $parsedChunks = $this->parser->parseChunks($request->chunks);
+
+        // Step 2: Validate chunks
+        $validation = $this->validator->validateChanges($parsedChunks, $contentLines);
+        if (!$validation->isValid) {
+            return new ProcessResult(
+                success: false,
+                originalContent: $fileContent,
+                modifiedContent: $fileContent,
+                errors: $validation->errors,
+                warnings: $validation->warnings,
+            );
+        }
+
+        // Step 3: Apply changes
+        $applyResult = $this->applier->applyChanges($parsedChunks, $contentLines, $this->contextMatcher, $config);
+
+        return new ProcessResult(
+            success: $applyResult->success,
+            originalContent: $fileContent,
+            modifiedContent: $applyResult->getModifiedContentAsString(),
+            appliedChanges: $applyResult->appliedChanges,
+            errors: $applyResult->errors,
+            warnings: $validation->warnings,
+        );
+    }
+
+    private function splitIntoLines(string $content): array
+    {
+        // Handle different line endings and preserve empty lines
+        $lines = \preg_split('/\r\n|\r|\n/', $content);
+
+        // Remove last empty line if it exists (common with file endings)
+        if (\end($lines) === '') {
+            \array_pop($lines);
+        }
+
+        return $lines;
+    }
+}

src/Lib/ApplyPatchParser/ChangeOperation.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Lib\ApplyPatchParser;
+
+final readonly class ChangeOperation
+{
+    public function __construct(
+        public ChangeType $type,
+        public string $content,
+    ) {}
+
+    public function isAddition(): bool
+    {
+        return $this->type === ChangeType::ADD;
+    }
+
+    public function isRemoval(): bool
+    {
+        return $this->type === ChangeType::REMOVE;
+    }
+
+    public function isContext(): bool
+    {
+        return $this->type === ChangeType::CONTEXT;
+    }
+}

src/Lib/ApplyPatchParser/ChangeType.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Lib\ApplyPatchParser;
+
+enum ChangeType: string
+{
+    case ADD = 'add';
+    case REMOVE = 'remove';
+    case CONTEXT = 'context';
+}

src/Lib/ApplyPatchParser/ChangeValidator.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Butschster\ContextGenerator\Lib\ApplyPatchParser;
+
+final readonly class ChangeValidator
+{
+    public function validateChanges(array $parsedChunks, array $contentLines): ValidationResult
+    {
+        $errors = [];
+        $warnings = [];
+        $positions = [];
+
+        foreach ($parsedChunks as $index => $chunk) {
+            $chunkErrors = $this->validateChunk($chunk, $contentLines, $index);
+            $errors = \array_merge($errors, $chunkErrors);
+        }
+
+        // Check for overlapping changes
+        $overlaps = $this->detectOverlaps($positions);
+        if (!empty($overlaps)) {
+            $errors[] = 'Detected overlapping changes that would conflict';
+        }
+
+        return new ValidationResult(
+            isValid: empty($errors),
+            errors: $errors,
+            warnings: $warnings,
+        );
+    }
+
+    private function validateChunk(ParsedChunk $chunk, array $contentLines, int $chunkIndex): array
+    {
+        $errors = [];
+
+        if (empty($chunk->contextMarker)) {
+            $errors[] = \sprintf('Chunk %d has empty context marker', $chunkIndex);
+        }
+
+        if (empty($chunk->changes)) {
+            $errors[] = \sprintf('Chunk %d has no changes', $chunkIndex);
+        }
+
+        // Validate that removal operations match existing content
+        foreach ($chunk->getRemovals() as $removal) {
+            if (!$this->lineExistsInContent($removal->content, $contentLines)) {
+                $errors[] = \sprintf('Chunk %d tries to remove non-existent line: "%s"', $chunkIndex, $removal->content);
+            }
+        }
+
+        return $errors;
+    }
+
+    private function lineExistsInContent(string $line, array $contentLines): bool
+    {
+        foreach ($contentLines as $contentLine) {
+            if (\trim((string) $contentLine) === \trim($line)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function detectOverlaps(array $positions): array
+    {
+        // Implementation for detecting overlapping line ranges
+        // For now, return empty array - this would need more sophisticated logic
+        return [];
+    }
+}