auto-code-fixer 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

auto_code_fixer/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.5"
+__version__ = "0.3.6"

auto_code_fixer/cli.py

@@ -32,6 +32,9 @@ def fix_file(
     max_retries: int,
     run_cmd: str | None,
     patch_protocol: bool,
+    max_files_changed: int,
+    context_files: int,
+    approve: bool,
     fmt: str | None,
     lint: str | None,
     lint_fix: bool,
@@ -247,33 +250,99 @@ def fix_file(
 
         if patch_protocol:
             try:
+                import difflib
+
                 from auto_code_fixer.fixer import fix_code_with_gpt_patch_protocol
                 from auto_code_fixer.patch_protocol import (
                     parse_patch_protocol_response,
                     validate_and_resolve_patch_files,
                 )
-                from auto_code_fixer.patcher import safe_read, safe_write
+                from auto_code_fixer.patcher import safe_read, atomic_write_verified_sha256
+                from auto_code_fixer.utils import find_imports
 
                 hint_paths = [os.path.relpath(target_file, sandbox_root)]
+
+                # Add a few related local files as read-only context to reduce back-and-forth.
+                ctx_pairs: list[tuple[str, str]] = []
+                if context_files and context_files > 0:
+                    rels: list[str] = []
+                    for abs_p in find_imports(target_file, sandbox_root):
+                        try:
+                            rels.append(os.path.relpath(abs_p, sandbox_root))
+                        except Exception:
+                            continue
+                    # drop duplicates and the target itself
+                    rels = [r for r in rels if r not in hint_paths]
+                    for rel in rels[:context_files]:
+                        abs_p = os.path.join(sandbox_root, rel)
+                        if os.path.exists(abs_p):
+                            try:
+                                ctx_pairs.append((rel, safe_read(abs_p)))
+                            except Exception:
+                                pass
+
                 raw = fix_code_with_gpt_patch_protocol(
                     sandbox_root=sandbox_root,
                     error_log=stderr,
                     api_key=api_key,
                     model=model,
                     hint_paths=hint_paths,
+                    context_files=ctx_pairs,
                 )
 
                 patch_files = parse_patch_protocol_response(raw)
+
+                if len(patch_files) > max_files_changed:
+                    raise ValueError(
+                        f"Patch wants to change {len(patch_files)} files, exceeding --max-files-changed={max_files_changed}"
+                    )
+
                 resolved = validate_and_resolve_patch_files(patch_files, sandbox_root=sandbox_root)
 
-                # Apply patches (only if they change content)
+                # 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)
                 for abs_path, new_content in resolved:
                     old = ""
                     if os.path.exists(abs_path):
                         old = safe_read(abs_path)
                     if new_content.strip() == (old or "").strip():
                         continue
-                    safe_write(abs_path, new_content)
+                    rel = os.path.relpath(abs_path, sandbox_root)
+                    planned.append((abs_path, rel, old, new_content))
+
+                if planned:
+                    if len(planned) > max_files_changed:
+                        raise ValueError(
+                            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)
+
+                        confirm = input("Apply these changes in the sandbox? (y/n): ").strip().lower()
+                        if confirm != "y":
+                            log("User declined patch application", "WARN")
+                            planned = []
+
+                for abs_path, rel, old, new_content in planned:
+                    expected_sha = sha_by_rel.get(rel)
+                    if not expected_sha:
+                        # Shouldn't happen; keep safe.
+                        raise ValueError(f"Missing sha256 for {rel} in patch protocol payload")
+
+                    atomic_write_verified_sha256(abs_path, new_content, expected_sha)
                     changed_sandbox_files.add(os.path.abspath(abs_path))
                     applied_any = True
 
@@ -292,9 +361,29 @@ def fix_file(
                 log("GPT returned no changes. Stopping.", "WARN")
                 break
 
-            with open(target_file, "w", encoding="utf-8") as f:
-                f.write(fixed_code)
+            if approve:
+                import difflib
+
+                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)",
+                    )
+                )
+                print("\nPROPOSED CHANGES (legacy mode):")
+                print(diff)
+                confirm = input("Apply this change in the sandbox? (y/n): ").strip().lower()
+                if confirm != "y":
+                    log("User declined patch application", "WARN")
+                    cleanup_sandbox()
+                    return False
+
+            from auto_code_fixer.patcher import safe_write
 
+            safe_write(target_file, fixed_code)
             changed_sandbox_files.add(os.path.abspath(target_file))
             applied_any = True
 
@@ -346,14 +435,37 @@ def main():
     )
 
     parser.add_argument(
-        "--patch-protocol",
+        "--legacy-mode",
         action="store_true",
         help=(
-            "Optional: ask the model for a strict JSON patch protocol with sha256 verification "
-            "(falls back to full-text mode if parsing/validation fails)"
+            "Disable the default JSON patch protocol and use legacy full-text edit mode only. "
+            "(Not recommended; patch protocol is safer and supports multi-file fixes.)"
         ),
     )
 
+    parser.add_argument(
+        "--max-files-changed",
+        type=int,
+        default=20,
+        help="Safety guard: maximum number of files the model may change per attempt (default: 20)",
+    )
+
+    parser.add_argument(
+        "--context-files",
+        type=int,
+        default=3,
+        help=(
+            "Include up to N related local files (imports) as read-only context in the LLM prompt "
+            "when using patch protocol (default: 3)"
+        ),
+    )
+
+    parser.add_argument(
+        "--approve",
+        action="store_true",
+        help="Show diffs for proposed changes and ask for approval before applying them in the sandbox",
+    )
+
     parser.add_argument(
         "--format",
         default=None,
@@ -426,7 +538,10 @@ def main():
         timeout_s=args.timeout,
         max_retries=args.max_retries,
         run_cmd=args.run,
-        patch_protocol=args.patch_protocol,
+        patch_protocol=not args.legacy_mode,
+        max_files_changed=args.max_files_changed,
+        context_files=args.context_files,
+        approve=args.approve,
         fmt=args.format,
         lint=args.lint,
         lint_fix=args.fix,

auto_code_fixer/fixer.py

@@ -86,12 +86,13 @@ def fix_code_with_gpt_patch_protocol(
     api_key: str | None = None,
     model: str | None = None,
     hint_paths: list[str] | None = None,
+    context_files: list[tuple[str, str]] | None = None,
 ) -> str:
     """Ask the model for structured edits (patch protocol).
 
     Returns raw model text (expected JSON). Parsing/validation happens elsewhere.
 
-    The protocol is optional and should be enabled explicitly by the caller.
+    context_files: optional list of (relative_path, content) to include as read-only context.
     """
 
     client = get_openai_client(api_key)
@@ -113,11 +114,23 @@ def fix_code_with_gpt_patch_protocol(
             f"- {p}" for p in hint_paths
         )
 
+    ctx = ""
+    if context_files:
+        # Keep it readable and avoid enormous prompts.
+        blocks: list[str] = []
+        for rel, content in context_files:
+            snippet = content
+            if len(snippet) > 4000:
+                snippet = snippet[:4000] + "\n... (truncated)"
+            blocks.append(f"--- FILE: {rel} ---\n{snippet}\n")
+        ctx = "\n\nREAD-ONLY CONTEXT FILES:\n" + "\n".join(blocks)
+
     prompt = (
         "You are a senior Python engineer. Fix the project so it runs without errors.\n"
         "Return ONLY valid JSON that matches this schema (no markdown, no commentary):\n"
         + json.dumps(schema)
         + hints
+        + ctx
         + "\n\nSANDBOX ROOT:\n"
         + sandbox_root
         + "\n\nERROR LOG:\n"

auto_code_fixer/patcher.py

@@ -1,6 +1,9 @@
 import os
+import tempfile
 from dataclasses import dataclass
 
+from auto_code_fixer.patch_protocol import compute_sha256_utf8
+
 
 @dataclass
 class FileEdit:
@@ -8,10 +11,43 @@ class FileEdit:
     new_content: str
 
 
+def _atomic_write(path: str, content: str) -> None:
+    """Atomically write text content to path.
+
+    Writes to a temp file in the same directory then os.replace() to avoid partial writes.
+    """
+
+    dir_name = os.path.dirname(path) or "."
+    os.makedirs(dir_name, exist_ok=True)
+
+    fd, tmp_path = tempfile.mkstemp(prefix=".acf_", suffix=".tmp", dir=dir_name)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    finally:
+        try:
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+        except Exception:
+            pass
+
+
+def atomic_write_verified_sha256(path: str, content: str, expected_sha256: str) -> None:
+    """Atomically write text content, verifying sha256(content) before commit."""
+
+    got = compute_sha256_utf8(content)
+    if got != (expected_sha256 or "").strip().lower():
+        raise ValueError(f"sha256 mismatch for {path}: expected {expected_sha256}, got {got}")
+
+    _atomic_write(path, content)
+
+
 def safe_write(path: str, content: str) -> None:
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
+    # Backwards-compatible name; now atomic.
+    _atomic_write(path, content)
 
 
 def safe_read(path: str) -> str:

{auto_code_fixer-0.3.5.dist-info → auto_code_fixer-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-code-fixer
-Version: 0.3.5
+Version: 0.3.6
 Summary: Automatically fix Python code using ChatGPT
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT

{auto_code_fixer-0.3.5.dist-info → auto_code_fixer-0.3.6.dist-info}/RECORD

@@ -1,20 +1,20 @@
-auto_code_fixer/__init__.py,sha256=ThnCuF3X7rsQSd5PAea_jfYA70ZmhLvkFcLBxBPwZnY,22
-auto_code_fixer/cli.py,sha256=0UszYX0cmDQIQpuLYrRa_tJCklnzUiqDAAauOfsboeg,15307
+auto_code_fixer/__init__.py,sha256=W_9dCm49nLvZulVAvvsafxLJjVBSKDBHz9K7szFZllo,22
+auto_code_fixer/cli.py,sha256=lFIGgrMQaqAoNtGRlkKXE1Lzk4l74XwsYjdxnrlF6lI,20304
 auto_code_fixer/command_runner.py,sha256=6P8hGRavN5C39x-e03p02Vc805NnZH9U7e48ngb5jJI,1104
-auto_code_fixer/fixer.py,sha256=s4owenfSKpoutzXyhVJ2fVecHp12ioQf5s8uPYdWbN0,4180
+auto_code_fixer/fixer.py,sha256=zcgw56pRTuOLvna09lTXatD0VWwjjzBVk0OyEKfgxDM,4691
 auto_code_fixer/installer.py,sha256=LC0jasSsPI7eHMeDxa622OoMCR1951HAXUZWp-kcmVY,1522
 auto_code_fixer/models.py,sha256=JLBJutOoiOjjlT_RMPUPhWlmm1yc_nGcQqv5tY72Al0,317
 auto_code_fixer/patch_protocol.py,sha256=8l1E9o-3jkO4VAI7Ulrf-1MbAshNzjQXtUkmH-0hYio,3216
-auto_code_fixer/patcher.py,sha256=WDYrkl12Dm3fpWppxWRszDGyD0-Sty3ud6mIZhjAMBU,686
+auto_code_fixer/patcher.py,sha256=BcQTnjWazdpuEXyR2AlumFBzIk_yIrO3fGTaIqpHuiU,1811
 auto_code_fixer/plan.py,sha256=jrZdG-f1RDxVB0tBLlTwKbCSEiOYI_RMetdzfBcyE4s,1762
 auto_code_fixer/runner.py,sha256=BvQm3CrwkQEDOw0tpiamSTcdu3OjbOgA801xW2zWdP8,970
 auto_code_fixer/sandbox.py,sha256=FWQcCxNDI4i7ckTKHuARSSIHCopBRqG16MVtx9s75R8,1628
 auto_code_fixer/traceback_utils.py,sha256=sbSuLO-2UBk5QPJZYJunTK9WGOpEY8mxR6WRKbtCIoM,935
 auto_code_fixer/utils.py,sha256=YXCv3PcDo5NBM1odksBTWkHTEELRtEXfPDIORA5iYaM,3090
 auto_code_fixer/venv_manager.py,sha256=2ww8reYgLbLohh-moAD5YKM09qv_mC5yYzJRwm3XiXc,1202
-auto_code_fixer-0.3.5.dist-info/licenses/LICENSE,sha256=hgchJNa26tjXuLztwSUDbYQxNLnAPnLk6kDXNIkC8xc,1066
-auto_code_fixer-0.3.5.dist-info/METADATA,sha256=e2BJl84gGASwLXcrv3B1AjeTg8dVqnQcgOAN4KRCRb8,3870
-auto_code_fixer-0.3.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-auto_code_fixer-0.3.5.dist-info/entry_points.txt,sha256=a-j2rkfwkrhXZ5Qbz_6_gwk6Bj7nijYR1DALjWp5Myk,61
-auto_code_fixer-0.3.5.dist-info/top_level.txt,sha256=qUk1qznb6Qxqmxy2A3z_5dpOZlmNKHwUiLuJwH-CrAk,16
-auto_code_fixer-0.3.5.dist-info/RECORD,,
+auto_code_fixer-0.3.6.dist-info/licenses/LICENSE,sha256=hgchJNa26tjXuLztwSUDbYQxNLnAPnLk6kDXNIkC8xc,1066
+auto_code_fixer-0.3.6.dist-info/METADATA,sha256=R6geFjh2cpLvAzuR1KQRcAJyryQgClYYB1wWmD1o2Qk,3870
+auto_code_fixer-0.3.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+auto_code_fixer-0.3.6.dist-info/entry_points.txt,sha256=a-j2rkfwkrhXZ5Qbz_6_gwk6Bj7nijYR1DALjWp5Myk,61
+auto_code_fixer-0.3.6.dist-info/top_level.txt,sha256=qUk1qznb6Qxqmxy2A3z_5dpOZlmNKHwUiLuJwH-CrAk,16
+auto_code_fixer-0.3.6.dist-info/RECORD,,