patch-fixer 0.3.2__tar.gz → 0.3.4__tar.gz

patch_fixer-0.3.4/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: patch-fixer
+Version: 0.3.4
+Summary: Fixes erroneous git apply patches to the best of its ability.
+Maintainer-email: Alex Mueller <amueller474@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/ajcm474/patch-fixer
+Project-URL: Issues, https://github.com/ajcm474/patch-fixer/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: GitPython
+Provides-Extra: test
+Requires-Dist: hypothesis; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: requests; extra == "test"
+Dynamic: license-file
+
+# patch-fixer
+So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch-fixer` is here to save the day... more or less.
+
+This tool can also split patches into separate files based on file lists, making it easy to selectively apply changes.
+
+## Installation
+```bash
+# Make sure you're using at least python 3.10
+python -m venv .venv/
+source .venv/bin/activate
+pip install patch-fixer
+```
+
+## Usage
+
+### Command Line Interface
+
+After installation, `patch-fixer` provides a unified command-line interface:
+
+#### Fixing broken patches:
+```bash
+patch-fixer fix original broken.patch fixed.patch
+```
+where:
+- `original` is the file or directory you were trying to patch
+- `broken.patch` is the malformed patch generated by the LLM
+- `fixed.patch` is the output file containing the (hopefully) fixed patch
+
+#### Splitting patches by file:
+```bash
+# Split with files specified on command line
+patch-fixer split input.patch included.patch excluded.patch -f file1.py file2.py
+
+# Split using a file list
+patch-fixer split input.patch included.patch excluded.patch -i files_to_include.txt
+```
+where:
+- `input.patch` is the patch file to split
+- `included.patch` will contain changes for the specified files
+- `excluded.patch` will contain changes for all other files
+- `-f` allows specifying files directly on the command line
+- `-i` reads the file list from a text file (one file per line)
+
+### Python API
+
+#### Fixing patches:
+```python
+from patch_fixer import fix_patch
+
+patch_file = "/path/to/broken.patch"
+original = "/path/to/original/state"    # file or directory being patched
+with open(patch_file, encoding="utf-8") as f:
+    patch_lines = f.readlines()
+    
+fixed_lines = fix_patch(patch_lines, original)
+output_file = "/path/to/fixed.patch"
+
+with open(output_file, 'w', encoding='utf-8') as f:
+    f.writelines(fixed_lines)
+```
+
+#### Splitting patches:
+```python
+from patch_fixer import split_patch
+
+with open("input.patch", encoding="utf-8") as f:
+    patch_lines = f.readlines()
+
+# split to include only specific files
+files_to_include = ["./src/main.py", "./src/utils.py"]
+included, excluded = split_patch(patch_lines, files_to_include)
+
+# write the split patches
+with open("included.patch", 'w', encoding='utf-8') as f:
+    f.writelines(included)
+    
+with open("excluded.patch", 'w', encoding='utf-8') as f:
+    f.writelines(excluded)
+```
+
+## Known Limitations
+
+- When fixing patches with missing `index` lines, the tool requires the files to be in a git repository to regenerate the index. This is only needed for file deletions and renames.
+- `patch-fixer` assumes the patch follows git's unified diff format.
+- Current implementation is not very robust to corrupted hunk content
+  - Much more comprehensive fuzzy string matching is planned
+
+## Local Testing
+```bash
+git clone https://github.com/ajcm474/patch-fixer.git
+cd patch-fixer
+pip install -e .[test]
+pytest
+```
+From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
+in bugfix versions as I like to use test-driven development to build out new features. 
+Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
+
+## License
+
+This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.

patch_fixer-0.3.4/README.md

@@ -0,0 +1,101 @@
+# patch-fixer
+So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch-fixer` is here to save the day... more or less.
+
+This tool can also split patches into separate files based on file lists, making it easy to selectively apply changes.
+
+## Installation
+```bash
+# Make sure you're using at least python 3.10
+python -m venv .venv/
+source .venv/bin/activate
+pip install patch-fixer
+```
+
+## Usage
+
+### Command Line Interface
+
+After installation, `patch-fixer` provides a unified command-line interface:
+
+#### Fixing broken patches:
+```bash
+patch-fixer fix original broken.patch fixed.patch
+```
+where:
+- `original` is the file or directory you were trying to patch
+- `broken.patch` is the malformed patch generated by the LLM
+- `fixed.patch` is the output file containing the (hopefully) fixed patch
+
+#### Splitting patches by file:
+```bash
+# Split with files specified on command line
+patch-fixer split input.patch included.patch excluded.patch -f file1.py file2.py
+
+# Split using a file list
+patch-fixer split input.patch included.patch excluded.patch -i files_to_include.txt
+```
+where:
+- `input.patch` is the patch file to split
+- `included.patch` will contain changes for the specified files
+- `excluded.patch` will contain changes for all other files
+- `-f` allows specifying files directly on the command line
+- `-i` reads the file list from a text file (one file per line)
+
+### Python API
+
+#### Fixing patches:
+```python
+from patch_fixer import fix_patch
+
+patch_file = "/path/to/broken.patch"
+original = "/path/to/original/state"    # file or directory being patched
+with open(patch_file, encoding="utf-8") as f:
+    patch_lines = f.readlines()
+    
+fixed_lines = fix_patch(patch_lines, original)
+output_file = "/path/to/fixed.patch"
+
+with open(output_file, 'w', encoding='utf-8') as f:
+    f.writelines(fixed_lines)
+```
+
+#### Splitting patches:
+```python
+from patch_fixer import split_patch
+
+with open("input.patch", encoding="utf-8") as f:
+    patch_lines = f.readlines()
+
+# split to include only specific files
+files_to_include = ["./src/main.py", "./src/utils.py"]
+included, excluded = split_patch(patch_lines, files_to_include)
+
+# write the split patches
+with open("included.patch", 'w', encoding='utf-8') as f:
+    f.writelines(included)
+    
+with open("excluded.patch", 'w', encoding='utf-8') as f:
+    f.writelines(excluded)
+```
+
+## Known Limitations
+
+- When fixing patches with missing `index` lines, the tool requires the files to be in a git repository to regenerate the index. This is only needed for file deletions and renames.
+- `patch-fixer` assumes the patch follows git's unified diff format.
+- Current implementation is not very robust to corrupted hunk content
+  - Much more comprehensive fuzzy string matching is planned
+
+## Local Testing
+```bash
+git clone https://github.com/ajcm474/patch-fixer.git
+cd patch-fixer
+pip install -e .[test]
+pytest
+```
+From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
+in bugfix versions as I like to use test-driven development to build out new features. 
+Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
+
+## License
+
+This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.

patch_fixer-0.3.4/patch_fixer/cli.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Command-line interface for patch-fixer."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .patch_fixer import fix_patch
+from .split import split_patch
+
+
+def fix_command(args):
+    """Handle the fix command."""
+    with open(args.broken_patch, encoding='utf-8') as f:
+        patch_lines = f.readlines()
+
+    fixed_lines = fix_patch(
+        patch_lines,
+        args.original,
+        fuzzy=args.fuzzy,
+        add_newline=args.add_newline
+    )
+
+    with open(args.output, 'w', encoding='utf-8') as f:
+        f.writelines(fixed_lines)
+
+    print(f"Fixed patch written to {args.output}")
+    return 0
+
+
+def split_command(args):
+    """Handle the split command."""
+    with open(args.patch_file, encoding='utf-8') as f:
+        patch_lines = f.readlines()
+
+    # read files to include from file or command line
+    if args.include_file:
+        with open(args.include_file, encoding='utf-8') as f:
+            files_to_include = [line.strip() for line in f if line.strip()]
+    else:
+        files_to_include = args.files or []
+
+    included, excluded = split_patch(patch_lines, files_to_include)
+
+    # write output files
+    with open(args.included_output, 'w', encoding='utf-8') as f:
+        f.writelines(included)
+
+    with open(args.excluded_output, 'w', encoding='utf-8') as f:
+        f.writelines(excluded)
+
+    print(f"Patch split into:")
+    print(f"  Included: {args.included_output} ({len(included)} lines)")
+    print(f"  Excluded: {args.excluded_output} ({len(excluded)} lines)")
+
+    return 0
+
+
+def main():
+    """Main entry point for the CLI."""
+    parser = argparse.ArgumentParser(
+        prog='patch-fixer',
+        description='Fix broken git patches or split them by file lists.'
+    )
+
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+
+    # fix command
+    fix_parser = subparsers.add_parser(
+        'fix',
+        help='Fix a broken patch file'
+    )
+    fix_parser.add_argument(
+        'original',
+        help='Original file or directory that the patch applies to'
+    )
+    fix_parser.add_argument(
+        'broken_patch',
+        help='Path to the broken patch file'
+    )
+    fix_parser.add_argument(
+        'output',
+        help='Path where the fixed patch will be written'
+    )
+    fix_parser.add_argument(
+        '--fuzzy',
+        action='store_true',
+        help='Enable fuzzy string matching when finding hunks in original files'
+    )
+    fix_parser.add_argument(
+        '--add-newline',
+        action='store_true',
+        help='Add final newline when processing "No newline at end of file" markers'
+    )
+
+    # split command
+    split_parser = subparsers.add_parser(
+        'split',
+        help='Split a patch file based on file lists'
+    )
+    split_parser.add_argument(
+        'patch_file',
+        help='Path to the patch file to split'
+    )
+    split_parser.add_argument(
+        'included_output',
+        help='Output file for included files'
+    )
+    split_parser.add_argument(
+        'excluded_output',
+        help='Output file for excluded files'
+    )
+    split_parser.add_argument(
+        '-f', '--files',
+        nargs='*',
+        help='Files to include (can specify multiple)'
+    )
+    split_parser.add_argument(
+        '-i', '--include-file',
+        help='File containing list of files to include (one per line)'
+    )
+
+    # parse arguments
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    # dispatch to appropriate command
+    try:
+        if args.command == 'fix':
+            return fix_command(args)
+        elif args.command == 'split':
+            return split_command(args)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{patch_fixer-0.3.2 → patch_fixer-0.3.4}/patch_fixer/patch_fixer.py

@@ -2,6 +2,7 @@
 import os
 import re
 import sys
+import warnings
 from pathlib import Path
 
 from git import Repo
@@ -61,7 +62,29 @@ def normalize_line(line):
     return core + "\n"
 
 
-def find_hunk_start(context_lines, original_lines):
+def fuzzy_line_similarity(line1, line2, threshold=0.8):
+    """Calculate similarity between two lines using a simple ratio."""
+    if not line1 or not line2:
+        return 0.0
+
+    l1, l2 = line1.strip(), line2.strip()
+
+    if l1 == l2:
+        return 1.0
+
+    if len(l1) == 0 or len(l2) == 0:
+        return 0.0
+
+    # count common characters
+    common = 0
+    for char in set(l1) & set(l2):
+        common += min(l1.count(char), l2.count(char))
+
+    total_chars = len(l1) + len(l2)
+    return (2.0 * common) / total_chars if total_chars > 0 else 0.0
+
+
+def find_hunk_start(context_lines, original_lines, fuzzy=False):
     """Search original_lines for context_lines and return start line index (0-based)."""
     ctx = []
     for line in context_lines:
@@ -74,11 +97,33 @@ def find_hunk_start(context_lines, original_lines):
             ctx.append(line)
     if not ctx:
         raise ValueError("Cannot search for empty hunk.")
+
+    # first try exact matching
     for i in range(len(original_lines) - len(ctx) + 1):
         # this part will fail if the diff is malformed beyond hunk header
-        equal_lines = [original_lines[i+j].strip() == ctx[j].strip() for j in range(len(ctx))]
+        equal_lines = [original_lines[i + j].strip() == ctx[j].strip() for j in range(len(ctx))]
         if all(equal_lines):
             return i
+
+    # if fuzzy matching is enabled and exact match failed, try fuzzy match
+    if fuzzy:
+        best_match_score = 0.0
+        best_match_pos = 0
+
+        for i in range(len(original_lines) - len(ctx) + 1):
+            total_similarity = 0.0
+            for j in range(len(ctx)):
+                similarity = fuzzy_line_similarity(original_lines[i + j], ctx[j])
+                total_similarity += similarity
+
+            avg_similarity = total_similarity / len(ctx)
+            if avg_similarity > best_match_score and avg_similarity > 0.6:
+                best_match_score = avg_similarity
+                best_match_pos = i
+
+        if best_match_score > 0.6:
+            return best_match_pos
+
     return 0
 
 
@@ -111,14 +156,14 @@ def reconstruct_file_header(diff_line, header_type):
             raise ValueError(f"Unsupported header type: {header_type}")
 
 
-def capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context):
+def capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context, fuzzy=False):
     # compute line counts
     old_count = sum(1 for l in current_hunk if l.startswith((' ', '-')))
     new_count = sum(1 for l in current_hunk if l.startswith((' ', '+')))
 
     if old_count > 0:
         # compute starting line in original file
-        old_start = find_hunk_start(current_hunk, original_lines) + 1
+        old_start = find_hunk_start(current_hunk, original_lines, fuzzy=fuzzy) + 1
 
         # if the line number descends, we either have a bad match or a new file
         if old_start < last_hunk:
@@ -147,7 +192,11 @@ def capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context):
 
 def regenerate_index(old_path, new_path, cur_dir):
     repo = Repo(cur_dir)
-    mode = " 100644"     # TODO: check if mode can be a different number
+
+    # Common git file modes: 100644 (regular file), 100755 (executable file),
+    # 120000 (symbolic link), 160000 (submodule), 040000 (tree/directory)
+    # TODO: guess mode based on above information
+    mode = " 100644"
 
     # file deletion
     if new_path == "/dev/null":
@@ -164,12 +213,15 @@ def regenerate_index(old_path, new_path, cur_dir):
     return f"index {old_sha}..{new_sha}{mode}\n"
 
 
-def fix_patch(patch_lines, original, remove_binary=False):
+def fix_patch(patch_lines, original, remove_binary=False, fuzzy=False, add_newline=False):
     dir_mode = os.path.isdir(original)
     original_path = Path(original).absolute()
 
     # make relative paths in the diff work
-    os.chdir(original_path)
+    if dir_mode:
+        os.chdir(original_path)
+    else:
+        os.chdir(original_path.parent)
 
     fixed_lines = []
     current_hunk = []
@@ -201,7 +253,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
                             fixed_header,
                             offset,
                             last_hunk
-                        ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
+                        ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context, fuzzy=fuzzy)
                     except MissingHunkError:
                         raise NotImplementedError(f"Could not find hunk in {current_file}:"
                                                   f"\n\n{''.join(current_hunk)}")
@@ -224,7 +276,12 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 last_mode = i
                 fixed_lines.append(normalize_line(line))
             case "INDEX_LINE":
-                # TODO: verify that mode is present for anything but deletion
+                # mode should be present in index line for all operations except file deletion
+                # for deletions, the mode is omitted since the file no longer exists
+                index_line = normalize_line(line).strip()
+                if not index_line.endswith("..0000000") and not re.search(r' [0-7]{6}$', index_line):
+                    # TODO: this is the right idea, but a poor implementation
+                    pass
                 last_index = i
                 similarity_index = match_groups[0]
                 if similarity_index:
@@ -238,7 +295,9 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 fixed_lines.append(normalize_line(line))
             case "RENAME_FROM":
                 if not look_for_rename:
-                    pass    # TODO: handle missing index line
+                    # handle case where rename from appears without corresponding index line
+                    # this may indicate a malformed patch, but we can try to continue
+                    warnings.warn(f"Warning: 'rename from' found without expected index line at line {i+1}")
                 if binary_file:
                     raise NotImplementedError("Renaming binary files not yet supported")
                 if last_index != i - 1:
@@ -252,7 +311,10 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 offset = 0
                 last_hunk = 0
                 if not Path.exists(current_path):
-                    # TODO: verify whether this block is necessary at all
+                    # this is meant to handle cases where the source file
+                    # doesn't exist (e.g., when applying a patch that renames
+                    # a file created earlier in the same patch)
+                    # TODO: but really, does that ever happen???
                     fixed_lines.append(normalize_line(line))
                     look_for_rename = True
                     file_loaded = False
@@ -273,7 +335,12 @@ def fix_patch(patch_lines, original, remove_binary=False):
                         last_index = i - 2
                     else:
                         raise NotImplementedError("Missing `rename from` header not yet supported.")
-                # TODO: do something sensible if `look_for_rename` is false
+                if not look_for_rename:
+                    # if we're not looking for a rename but encounter "rename to",
+                    # this indicates a malformed patch - log warning but continue
+                    warnings.warn(
+                        f"Warning: unexpected 'rename to' found at line {i + 1} without corresponding 'rename from'"
+                    )
                 current_file = match_groups[0]
                 current_path = Path(current_file).absolute()
                 if current_file and current_path.is_dir():
@@ -412,7 +479,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
                         fixed_header,
                         offset,
                         last_hunk
-                    ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
+                    ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context, fuzzy=fuzzy)
                 except MissingHunkError:
                     raise NotImplementedError(f"Could not find hunk in {current_file}:"
                                               f"\n\n{''.join(current_hunk)}")
@@ -421,10 +488,13 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 current_hunk = []
                 hunk_context = match_groups[4]
             case "END_LINE":
-                # TODO: add newline at end of file if user requests
-                fixed_lines.append(normalize_line(line))
+                # if user requested, add a newline at end of file when this marker is present
+                if add_newline:
+                    fixed_lines.append("\n")
+                else:
+                    fixed_lines.append(normalize_line(line))
             case _:
-                # TODO: fuzzy string matching
+                # TODO: fix fuzzy string matching to be less granular
                 # this is a normal line, add to current hunk
                 current_hunk.append(normalize_line(line))
 
@@ -434,7 +504,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
             fixed_header,
             offset,
             last_hunk
-        ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
+        ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context, fuzzy=fuzzy)
     except MissingHunkError:
         raise NotImplementedError(f"Could not find hunk in {current_file}:"
                                   f"\n\n{''.join(current_hunk)}")