auto-code-fixer 0.3.6__tar.gz → 0.3.7__tar.gz

{auto_code_fixer-0.3.6 → auto_code_fixer-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-code-fixer
-Version: 0.3.6
+Version: 0.3.7
 Summary: Automatically fix Python code using ChatGPT
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT
@@ -87,6 +87,18 @@ pip install requests
 Before overwriting any file, it creates a backup:
 - `file.py.bak` (or `.bak1`, `.bak2`, ...)
 
+### Approval mode (diff review)
+```bash
+auto-code-fixer path/to/main.py --project-root . --approve
+```
+In patch-protocol mode, approvals are **file-by-file** (apply/skip).
+
+### Diff / size guards
+To prevent huge edits from being applied accidentally:
+- `--max-diff-lines` limits unified-diff size per file
+- `--max-file-bytes` limits the proposed new content size per file
+- `--max-total-bytes` limits total proposed new content across all files
+
 ### Dry run
 ```bash
 auto-code-fixer path/to/main.py --project-root . --dry-run
@@ -103,6 +115,16 @@ Instead of `python main.py`, run tests:
 auto-code-fixer . --project-root . --run "pytest -q" --no-ask
 ```
 
+When you use `--run`, the tool (by default) also performs a **post-apply check**:
+after copying fixes back to your project, it re-runs the same command against the real project files
+(using the sandbox venv for dependencies).
+
+You can disable that extra check with:
+
+```bash
+auto-code-fixer . --project-root . --run "pytest -q" --no-post-apply-check
+```
+
 ### Model selection
 ```bash
 export AUTO_CODE_FIXER_MODEL=gpt-4.1-mini
@@ -121,13 +143,18 @@ auto-code-fixer main.py --ai-plan
 ```
 This enables a helper that can suggest which local file to edit. It is best-effort.
 
-### Optional structured patch protocol (JSON + sha256)
+### Structured patch protocol (JSON + sha256) (default)
+By default, Auto Code Fixer uses a structured **patch protocol** where the model returns strict JSON:
+
+`{ "files": [ {"path": "...", "new_content": "...", "sha256": "..."}, ... ] }`
+
+The tool verifies the SHA-256 hash of `new_content` before applying edits.
+
+To disable this and use legacy full-text mode only:
+
 ```bash
-auto-code-fixer main.py --patch-protocol
+auto-code-fixer main.py --legacy-mode
 ```
-When enabled, the model is asked to return strict JSON with `{files:[{path,new_content,sha256}]}`.
-The tool verifies the SHA-256 hash of `new_content` before applying edits, and falls back to the
-legacy full-text mode if parsing/validation fails.
 
 ### Optional formatting / linting (best-effort)
 ```bash

{auto_code_fixer-0.3.6 → auto_code_fixer-0.3.7}/README.md

@@ -66,6 +66,18 @@ pip install requests
 Before overwriting any file, it creates a backup:
 - `file.py.bak` (or `.bak1`, `.bak2`, ...)
 
+### Approval mode (diff review)
+```bash
+auto-code-fixer path/to/main.py --project-root . --approve
+```
+In patch-protocol mode, approvals are **file-by-file** (apply/skip).
+
+### Diff / size guards
+To prevent huge edits from being applied accidentally:
+- `--max-diff-lines` limits unified-diff size per file
+- `--max-file-bytes` limits the proposed new content size per file
+- `--max-total-bytes` limits total proposed new content across all files
+
 ### Dry run
 ```bash
 auto-code-fixer path/to/main.py --project-root . --dry-run
@@ -82,6 +94,16 @@ Instead of `python main.py`, run tests:
 auto-code-fixer . --project-root . --run "pytest -q" --no-ask
 ```
 
+When you use `--run`, the tool (by default) also performs a **post-apply check**:
+after copying fixes back to your project, it re-runs the same command against the real project files
+(using the sandbox venv for dependencies).
+
+You can disable that extra check with:
+
+```bash
+auto-code-fixer . --project-root . --run "pytest -q" --no-post-apply-check
+```
+
 ### Model selection
 ```bash
 export AUTO_CODE_FIXER_MODEL=gpt-4.1-mini
@@ -100,13 +122,18 @@ auto-code-fixer main.py --ai-plan
 ```
 This enables a helper that can suggest which local file to edit. It is best-effort.
 
-### Optional structured patch protocol (JSON + sha256)
+### Structured patch protocol (JSON + sha256) (default)
+By default, Auto Code Fixer uses a structured **patch protocol** where the model returns strict JSON:
+
+`{ "files": [ {"path": "...", "new_content": "...", "sha256": "..."}, ... ] }`
+
+The tool verifies the SHA-256 hash of `new_content` before applying edits.
+
+To disable this and use legacy full-text mode only:
+
 ```bash
-auto-code-fixer main.py --patch-protocol
+auto-code-fixer main.py --legacy-mode
 ```
-When enabled, the model is asked to return strict JSON with `{files:[{path,new_content,sha256}]}`.
-The tool verifies the SHA-256 hash of `new_content` before applying edits, and falls back to the
-legacy full-text mode if parsing/validation fails.
 
 ### Optional formatting / linting (best-effort)
 ```bash

auto_code_fixer-0.3.7/auto_code_fixer/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.7"

auto_code_fixer-0.3.7/auto_code_fixer/approval.py

@@ -0,0 +1,114 @@
+import difflib
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class PlannedChange:
+    abs_path: str
+    rel_path: str
+    old_content: str
+    new_content: str
+
+
+class UserAbort(Exception):
+    pass
+
+
+def unified_diff_text(rel_path: str, old: str, new: str) -> str:
+    return "".join(
+        difflib.unified_diff(
+            (old or "").splitlines(keepends=True),
+            (new or "").splitlines(keepends=True),
+            fromfile=rel_path + " (before)",
+            tofile=rel_path + " (after)",
+        )
+    )
+
+
+def guard_planned_changes(
+    planned: list[PlannedChange],
+    *,
+    max_file_bytes: int,
+    max_total_bytes: int,
+    max_diff_lines: int,
+) -> None:
+    """Safety guards against huge edits.
+
+    Raises ValueError when limits are exceeded.
+    """
+
+    if max_file_bytes <= 0 or max_total_bytes <= 0 or max_diff_lines <= 0:
+        raise ValueError("Guard limits must be positive")
+
+    total = 0
+
+    for ch in planned:
+        b = len((ch.new_content or "").encode("utf-8"))
+        total += b
+        if b > max_file_bytes:
+            raise ValueError(
+                f"Proposed content for {ch.rel_path} is {b} bytes, exceeding --max-file-bytes={max_file_bytes}"
+            )
+
+        diff = unified_diff_text(ch.rel_path, ch.old_content, ch.new_content)
+        diff_lines = len(diff.splitlines())
+        if diff_lines > max_diff_lines:
+            raise ValueError(
+                f"Diff for {ch.rel_path} is {diff_lines} lines, exceeding --max-diff-lines={max_diff_lines}"
+            )
+
+    if total > max_total_bytes:
+        raise ValueError(
+            f"Total proposed content is {total} bytes, exceeding --max-total-bytes={max_total_bytes}"
+        )
+
+
+def prompt_approve_file_by_file(
+    planned: list[PlannedChange],
+    *,
+    input_fn=input,
+    print_fn=print,
+) -> list[PlannedChange]:
+    """Interactive approval per file.
+
+    Commands:
+      y = apply this change
+      n = skip this change
+      a = apply this and all remaining
+      q = abort
+    """
+
+    if not planned:
+        return []
+
+    out: list[PlannedChange] = []
+    apply_all = False
+
+    for ch in planned:
+        diff = unified_diff_text(ch.rel_path, ch.old_content, ch.new_content)
+        print_fn("\nPROPOSED CHANGE:")
+        print_fn(diff)
+
+        if apply_all:
+            out.append(ch)
+            continue
+
+        ans = (
+            input_fn(f"Apply change for {ch.rel_path}? (y/n/a/q): ")
+            .strip()
+            .lower()
+        )
+        if ans == "y":
+            out.append(ch)
+        elif ans == "n":
+            continue
+        elif ans == "a":
+            out.append(ch)
+            apply_all = True
+        elif ans == "q":
+            raise UserAbort("User aborted approvals")
+        else:
+            # default: be safe
+            continue
+
+    return out

{auto_code_fixer-0.3.6 → auto_code_fixer-0.3.7}/auto_code_fixer/cli.py

@@ -35,6 +35,10 @@ def fix_file(
     max_files_changed: int,
     context_files: int,
     approve: bool,
+    max_diff_lines: int,
+    max_file_bytes: int,
+    max_total_bytes: int,
+    post_apply_check: bool,
     fmt: str | None,
     lint: str | None,
     lint_fix: bool,
@@ -163,6 +167,8 @@ def fix_file(
                     sr = os.path.realpath(os.path.abspath(sandbox_root))
                     pr = os.path.realpath(os.path.abspath(project_root))
 
+                    backups: dict[str, str] = {}
+
                     for p in sorted(changed_sandbox_files):
                         p_real = os.path.realpath(os.path.abspath(p))
 
@@ -192,12 +198,44 @@ def fix_file(
 
                         if os.path.exists(dst_real):
                             bak = backup_file(dst_real)
+                            backups[dst_real] = bak
                             log(f"Backup created: {bak}", "DEBUG")
 
                         os.makedirs(os.path.dirname(dst_real), exist_ok=True)
                         shutil.copy(p_real, dst_real)
                         log(f"File updated: {dst_real}")
 
+                    # Optional post-apply verification: run the same command against the real project files,
+                    # using the sandbox venv for dependencies.
+                    if post_apply_check and run_cmd and changed_sandbox_files:
+                        from auto_code_fixer.command_runner import run_command
+
+                        rc2, out2, err2 = run_command(
+                            run_cmd,
+                            timeout_s=timeout_s,
+                            python_exe=venv_python,
+                            cwd=project_root,
+                            extra_env={"PYTHONPATH": project_root},
+                        )
+                        if verbose:
+                            if out2:
+                                log(f"POST-APPLY STDOUT:\n{out2}", "DEBUG")
+                            if err2:
+                                log(f"POST-APPLY STDERR:\n{err2}", "DEBUG")
+
+                        if rc2 != 0:
+                            log(
+                                "Post-apply command failed; restoring backups (best-effort).",
+                                "ERROR",
+                            )
+                            for dst_real, bak in backups.items():
+                                try:
+                                    shutil.copy(bak, dst_real)
+                                except Exception as e:
+                                    log(f"WARN: failed to restore {dst_real} from {bak}: {e}")
+                            cleanup_sandbox()
+                            return False
+
             cleanup_sandbox()
             log(f"Fix completed in {attempt + 1} attempt(s) 🎉")
             return True
@@ -302,7 +340,14 @@ def fix_file(
                 # Prepare diffs / approvals and apply atomically.
                 sha_by_rel = {pf.path: pf.sha256 for pf in patch_files}
 
-                planned: list[tuple[str, str, str, str]] = []  # (abs_path, rel, old, new)
+                from auto_code_fixer.approval import (
+                    PlannedChange,
+                    UserAbort,
+                    guard_planned_changes,
+                    prompt_approve_file_by_file,
+                )
+
+                planned: list[PlannedChange] = []
                 for abs_path, new_content in resolved:
                     old = ""
                     if os.path.exists(abs_path):
@@ -310,7 +355,14 @@ def fix_file(
                     if new_content.strip() == (old or "").strip():
                         continue
                     rel = os.path.relpath(abs_path, sandbox_root)
-                    planned.append((abs_path, rel, old, new_content))
+                    planned.append(
+                        PlannedChange(
+                            abs_path=abs_path,
+                            rel_path=rel,
+                            old_content=old,
+                            new_content=new_content,
+                        )
+                    )
 
                 if planned:
                     if len(planned) > max_files_changed:
@@ -318,32 +370,28 @@ def fix_file(
                             f"Patch would change {len(planned)} files, exceeding --max-files-changed={max_files_changed}"
                         )
 
-                    if approve:
-                        print("\nPROPOSED CHANGES (patch protocol):")
-                        for _, rel, old, new in planned:
-                            diff = "".join(
-                                difflib.unified_diff(
-                                    (old or "").splitlines(keepends=True),
-                                    (new or "").splitlines(keepends=True),
-                                    fromfile=rel + " (before)",
-                                    tofile=rel + " (after)",
-                                )
-                            )
-                            print(diff)
+                    guard_planned_changes(
+                        planned,
+                        max_file_bytes=max_file_bytes,
+                        max_total_bytes=max_total_bytes,
+                        max_diff_lines=max_diff_lines,
+                    )
 
-                        confirm = input("Apply these changes in the sandbox? (y/n): ").strip().lower()
-                        if confirm != "y":
-                            log("User declined patch application", "WARN")
+                    if approve:
+                        try:
+                            planned = prompt_approve_file_by_file(planned)
+                        except UserAbort:
+                            log("User aborted patch application", "WARN")
                             planned = []
 
-                for abs_path, rel, old, new_content in planned:
-                    expected_sha = sha_by_rel.get(rel)
+                for ch in planned:
+                    expected_sha = sha_by_rel.get(ch.rel_path)
                     if not expected_sha:
                         # Shouldn't happen; keep safe.
-                        raise ValueError(f"Missing sha256 for {rel} in patch protocol payload")
+                        raise ValueError(f"Missing sha256 for {ch.rel_path} in patch protocol payload")
 
-                    atomic_write_verified_sha256(abs_path, new_content, expected_sha)
-                    changed_sandbox_files.add(os.path.abspath(abs_path))
+                    atomic_write_verified_sha256(ch.abs_path, ch.new_content, expected_sha)
+                    changed_sandbox_files.add(os.path.abspath(ch.abs_path))
                     applied_any = True
 
             except Exception as e:
@@ -361,29 +409,48 @@ def fix_file(
                 log("GPT returned no changes. Stopping.", "WARN")
                 break
 
-            if approve:
-                import difflib
+            from auto_code_fixer.approval import (
+                PlannedChange,
+                UserAbort,
+                guard_planned_changes,
+                prompt_approve_file_by_file,
+            )
 
-                old = open(target_file, encoding="utf-8").read()
-                diff = "".join(
-                    difflib.unified_diff(
-                        (old or "").splitlines(keepends=True),
-                        (fixed_code or "").splitlines(keepends=True),
-                        fromfile=os.path.relpath(target_file, sandbox_root) + " (before)",
-                        tofile=os.path.relpath(target_file, sandbox_root) + " (after)",
-                    )
+            old = open(target_file, encoding="utf-8").read()
+            rel = os.path.relpath(target_file, sandbox_root)
+
+            planned = [
+                PlannedChange(
+                    abs_path=target_file,
+                    rel_path=rel,
+                    old_content=old,
+                    new_content=fixed_code,
                 )
-                print("\nPROPOSED CHANGES (legacy mode):")
-                print(diff)
-                confirm = input("Apply this change in the sandbox? (y/n): ").strip().lower()
-                if confirm != "y":
+            ]
+
+            guard_planned_changes(
+                planned,
+                max_file_bytes=max_file_bytes,
+                max_total_bytes=max_total_bytes,
+                max_diff_lines=max_diff_lines,
+            )
+
+            if approve:
+                try:
+                    planned = prompt_approve_file_by_file(planned)
+                except UserAbort:
                     log("User declined patch application", "WARN")
                     cleanup_sandbox()
                     return False
 
+            if not planned:
+                log("No legacy changes approved", "WARN")
+                cleanup_sandbox()
+                return False
+
             from auto_code_fixer.patcher import safe_write
 
-            safe_write(target_file, fixed_code)
+            safe_write(target_file, planned[0].new_content)
             changed_sandbox_files.add(os.path.abspath(target_file))
             applied_any = True
 
@@ -463,7 +530,44 @@ def main():
     parser.add_argument(
         "--approve",
         action="store_true",
-        help="Show diffs for proposed changes and ask for approval before applying them in the sandbox",
+        help=(
+            "Show diffs for proposed changes and ask for approval before applying them in the sandbox. "
+            "In patch-protocol mode, approvals are file-by-file."
+        ),
+    )
+
+    parser.add_argument(
+        "--max-diff-lines",
+        type=int,
+        default=4000,
+        help="Safety guard: maximum unified-diff lines to display/apply per file (default: 4000)",
+    )
+    parser.add_argument(
+        "--max-file-bytes",
+        type=int,
+        default=200_000,
+        help="Safety guard: maximum size (bytes) of proposed new content per file (default: 200000)",
+    )
+    parser.add_argument(
+        "--max-total-bytes",
+        type=int,
+        default=1_000_000,
+        help="Safety guard: maximum total bytes of proposed new content across all files (default: 1000000)",
+    )
+
+    post_apply_group = parser.add_mutually_exclusive_group()
+    post_apply_group.add_argument(
+        "--post-apply-check",
+        action="store_true",
+        help=(
+            "If using --run, re-run the command against the real project files after applying fixes "
+            "(uses sandbox venv for deps)."
+        ),
+    )
+    post_apply_group.add_argument(
+        "--no-post-apply-check",
+        action="store_true",
+        help="Disable the post-apply re-run check (even if --run is set).",
     )
 
     parser.add_argument(
@@ -527,6 +631,13 @@ def main():
     if args.ai_plan:
         os.environ["AUTO_CODE_FIXER_AI_PLAN"] = "1"
 
+    if args.no_post_apply_check:
+        post_apply_check = False
+    elif args.post_apply_check:
+        post_apply_check = True
+    else:
+        post_apply_check = bool(args.run)
+
     ok = fix_file(
         args.entry_file,
         args.project_root,
@@ -542,6 +653,10 @@ def main():
         max_files_changed=args.max_files_changed,
         context_files=args.context_files,
         approve=args.approve,
+        max_diff_lines=args.max_diff_lines,
+        max_file_bytes=args.max_file_bytes,
+        max_total_bytes=args.max_total_bytes,
+        post_apply_check=post_apply_check,
         fmt=args.format,
         lint=args.lint,
         lint_fix=args.fix,

{auto_code_fixer-0.3.6 → auto_code_fixer-0.3.7}/auto_code_fixer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-code-fixer
-Version: 0.3.6
+Version: 0.3.7
 Summary: Automatically fix Python code using ChatGPT
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT
@@ -87,6 +87,18 @@ pip install requests
 Before overwriting any file, it creates a backup:
 - `file.py.bak` (or `.bak1`, `.bak2`, ...)
 
+### Approval mode (diff review)
+```bash
+auto-code-fixer path/to/main.py --project-root . --approve
+```
+In patch-protocol mode, approvals are **file-by-file** (apply/skip).
+
+### Diff / size guards
+To prevent huge edits from being applied accidentally:
+- `--max-diff-lines` limits unified-diff size per file
+- `--max-file-bytes` limits the proposed new content size per file
+- `--max-total-bytes` limits total proposed new content across all files
+
 ### Dry run
 ```bash
 auto-code-fixer path/to/main.py --project-root . --dry-run
@@ -103,6 +115,16 @@ Instead of `python main.py`, run tests:
 auto-code-fixer . --project-root . --run "pytest -q" --no-ask
 ```
 
+When you use `--run`, the tool (by default) also performs a **post-apply check**:
+after copying fixes back to your project, it re-runs the same command against the real project files
+(using the sandbox venv for dependencies).
+
+You can disable that extra check with:
+
+```bash
+auto-code-fixer . --project-root . --run "pytest -q" --no-post-apply-check
+```
+
 ### Model selection
 ```bash
 export AUTO_CODE_FIXER_MODEL=gpt-4.1-mini
@@ -121,13 +143,18 @@ auto-code-fixer main.py --ai-plan
 ```
 This enables a helper that can suggest which local file to edit. It is best-effort.
 
-### Optional structured patch protocol (JSON + sha256)
+### Structured patch protocol (JSON + sha256) (default)
+By default, Auto Code Fixer uses a structured **patch protocol** where the model returns strict JSON:
+
+`{ "files": [ {"path": "...", "new_content": "...", "sha256": "..."}, ... ] }`
+
+The tool verifies the SHA-256 hash of `new_content` before applying edits.
+
+To disable this and use legacy full-text mode only:
+
 ```bash
-auto-code-fixer main.py --patch-protocol
+auto-code-fixer main.py --legacy-mode
 ```
-When enabled, the model is asked to return strict JSON with `{files:[{path,new_content,sha256}]}`.
-The tool verifies the SHA-256 hash of `new_content` before applying edits, and falls back to the
-legacy full-text mode if parsing/validation fails.
 
 ### Optional formatting / linting (best-effort)
 ```bash

{auto_code_fixer-0.3.6 → auto_code_fixer-0.3.7}/auto_code_fixer.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 auto_code_fixer/__init__.py
+auto_code_fixer/approval.py
 auto_code_fixer/cli.py
 auto_code_fixer/command_runner.py
 auto_code_fixer/fixer.py
@@ -21,6 +22,7 @@ auto_code_fixer.egg-info/dependency_links.txt
 auto_code_fixer.egg-info/entry_points.txt
 auto_code_fixer.egg-info/requires.txt
 auto_code_fixer.egg-info/top_level.txt
+tests/test_approval_and_guards.py
 tests/test_atomic_write.py
 tests/test_fix_imported_file.py
 tests/test_internal_imports.py

{auto_code_fixer-0.3.6 → auto_code_fixer-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "auto-code-fixer"
-version = "0.3.6"
+version = "0.3.7"
 description = "Automatically fix Python code using ChatGPT"
 readme = "README.md"
 

auto_code_fixer-0.3.7/tests/test_approval_and_guards.py

@@ -0,0 +1,55 @@
+import pytest
+
+from auto_code_fixer.approval import (
+    PlannedChange,
+    UserAbort,
+    guard_planned_changes,
+    prompt_approve_file_by_file,
+)
+
+
+def test_guard_planned_changes_rejects_big_file():
+    planned = [
+        PlannedChange(
+            abs_path="/tmp/a.py",
+            rel_path="a.py",
+            old_content="",
+            new_content="x" * 11,
+        )
+    ]
+    with pytest.raises(ValueError, match="max-file-bytes"):
+        guard_planned_changes(planned, max_file_bytes=10, max_total_bytes=100, max_diff_lines=100)
+
+
+def test_guard_planned_changes_rejects_total_bytes():
+    planned = [
+        PlannedChange("/tmp/a.py", "a.py", "", "x" * 6),
+        PlannedChange("/tmp/b.py", "b.py", "", "x" * 6),
+    ]
+    with pytest.raises(ValueError, match="max-total-bytes"):
+        guard_planned_changes(planned, max_file_bytes=100, max_total_bytes=10, max_diff_lines=100)
+
+
+def test_prompt_approve_file_by_file_apply_skip():
+    planned = [
+        PlannedChange("/tmp/a.py", "a.py", "print(1)\n", "print(2)\n"),
+        PlannedChange("/tmp/b.py", "b.py", "print(1)\n", "print(3)\n"),
+    ]
+
+    answers = iter(["y", "n"])
+
+    def _input(_prompt: str) -> str:
+        return next(answers)
+
+    chosen = prompt_approve_file_by_file(planned, input_fn=_input, print_fn=lambda *_: None)
+    assert [c.rel_path for c in chosen] == ["a.py"]
+
+
+def test_prompt_approve_file_by_file_abort():
+    planned = [PlannedChange("/tmp/a.py", "a.py", "", "x")]
+
+    def _input(_prompt: str) -> str:
+        return "q"
+
+    with pytest.raises(UserAbort):
+        prompt_approve_file_by_file(planned, input_fn=_input, print_fn=lambda *_: None)

auto_code_fixer-0.3.6/auto_code_fixer/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.6"