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

auto_code_fixer/__init__.py

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

auto_code_fixer/cli.py

@@ -19,7 +19,23 @@ from auto_code_fixer import __version__
 DEFAULT_MAX_RETRIES = 8  # can be overridden via CLI
 
 
-def fix_file(file_path, project_root, api_key, ask, verbose, *, dry_run: bool, model: str | None, timeout_s: int, max_retries: int, run_cmd: str | None) -> bool:
+def fix_file(
+    file_path,
+    project_root,
+    api_key,
+    ask,
+    verbose,
+    *,
+    dry_run: bool,
+    model: str | None,
+    timeout_s: int,
+    max_retries: int,
+    run_cmd: str | None,
+    patch_protocol: bool,
+    fmt: str | None,
+    lint: str | None,
+    lint_fix: bool,
+) -> bool:
     log(f"Processing entry file: {file_path}")
 
     project_root = os.path.abspath(project_root)
@@ -29,12 +45,65 @@ def fix_file(file_path, project_root, api_key, ask, verbose, *, dry_run: bool, m
     from auto_code_fixer.sandbox import make_sandbox
     sandbox_root, sandbox_entry = make_sandbox(entry_file=file_path, project_root=project_root)
 
+    # Always delete temp sandbox (best-effort). Also register atexit cleanup in case of crashes.
+    import atexit
+
+    def cleanup_sandbox() -> None:
+        try:
+            shutil.rmtree(sandbox_root)
+        except FileNotFoundError:
+            return
+        except Exception as e:
+            log(f"WARN: failed to delete sandbox dir {sandbox_root}: {e}")
+
+    atexit.register(cleanup_sandbox)
+
     # Create isolated venv in sandbox
     from auto_code_fixer.venv_manager import create_venv
     from auto_code_fixer.patcher import backup_file
 
     venv_python = create_venv(sandbox_root)
 
+    def _run_optional_formatters_and_linters() -> None:
+        # Best-effort formatting/linting (only if tools are installed in the sandbox venv).
+        from auto_code_fixer.command_runner import run_command
+
+        if fmt == "black":
+            rc, out, err = run_command(
+                "python -m black .",
+                timeout_s=max(timeout_s, 60),
+                python_exe=venv_python,
+                cwd=sandbox_root,
+                extra_env={"PYTHONPATH": sandbox_root},
+            )
+            if rc == 0:
+                log("Formatted with black", "DEBUG")
+            else:
+                # If black isn't installed, ignore.
+                if "No module named" in (err or "") and "black" in (err or ""):
+                    log("black not installed in sandbox venv; skipping format", "DEBUG")
+                else:
+                    log(f"black failed (rc={rc}): {err}", "DEBUG")
+
+        if lint == "ruff":
+            cmd = "python -m ruff check ."
+            if lint_fix:
+                cmd += " --fix"
+            rc, out, err = run_command(
+                cmd,
+                timeout_s=max(timeout_s, 60),
+                python_exe=venv_python,
+                cwd=sandbox_root,
+                extra_env={"PYTHONPATH": sandbox_root},
+            )
+            if rc == 0:
+                log("ruff check passed", "DEBUG")
+            else:
+                if "No module named" in (err or "") and "ruff" in (err or ""):
+                    log("ruff not installed in sandbox venv; skipping lint", "DEBUG")
+                else:
+                    log(f"ruff reported issues (rc={rc}): {err}", "DEBUG")
+
     changed_sandbox_files: set[str] = set()
 
     for attempt in range(max_retries):
@@ -82,7 +151,7 @@ def fix_file(file_path, project_root, api_key, ask, verbose, *, dry_run: bool, m
 
                     if confirm != "y":
                         log("User declined overwrite", "WARN")
-                        shutil.rmtree(sandbox_root)
+                        cleanup_sandbox()
                         return False
 
                 if dry_run:
@@ -126,7 +195,7 @@ def fix_file(file_path, project_root, api_key, ask, verbose, *, dry_run: bool, m
                         shutil.copy(p_real, dst_real)
                         log(f"File updated: {dst_real}")
 
-            shutil.rmtree(sandbox_root)
+            cleanup_sandbox()
             log(f"Fix completed in {attempt + 1} attempt(s) 🎉")
             return True
 
@@ -174,27 +243,68 @@ def fix_file(file_path, project_root, api_key, ask, verbose, *, dry_run: bool, m
 
         log(f"Sending {os.path.relpath(target_file, sandbox_root)} + error to GPT 🧠", "DEBUG")
 
-        fixed_code = fix_code_with_gpt(
-            original_code=open(target_file, encoding="utf-8").read(),
-            error_log=stderr,
-            api_key=api_key,
-            model=model,
-        )
+        applied_any = False
+
+        if patch_protocol:
+            try:
+                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
+
+                hint_paths = [os.path.relpath(target_file, sandbox_root)]
+                raw = fix_code_with_gpt_patch_protocol(
+                    sandbox_root=sandbox_root,
+                    error_log=stderr,
+                    api_key=api_key,
+                    model=model,
+                    hint_paths=hint_paths,
+                )
+
+                patch_files = parse_patch_protocol_response(raw)
+                resolved = validate_and_resolve_patch_files(patch_files, sandbox_root=sandbox_root)
+
+                # Apply patches (only if they change content)
+                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)
+                    changed_sandbox_files.add(os.path.abspath(abs_path))
+                    applied_any = True
+
+            except Exception as e:
+                log(f"Patch protocol failed ({e}); falling back to full-text mode", "WARN")
+
+        if not applied_any:
+            fixed_code = fix_code_with_gpt(
+                original_code=open(target_file, encoding="utf-8").read(),
+                error_log=stderr,
+                api_key=api_key,
+                model=model,
+            )
 
-        if fixed_code.strip() == open(target_file, encoding="utf-8").read().strip():
-            log("GPT returned no changes. Stopping.", "WARN")
-            break
+            if fixed_code.strip() == open(target_file, encoding="utf-8").read().strip():
+                log("GPT returned no changes. Stopping.", "WARN")
+                break
 
-        with open(target_file, "w", encoding="utf-8") as f:
-            f.write(fixed_code)
+            with open(target_file, "w", encoding="utf-8") as f:
+                f.write(fixed_code)
 
-        changed_sandbox_files.add(os.path.abspath(target_file))
+            changed_sandbox_files.add(os.path.abspath(target_file))
+            applied_any = True
 
-        log("Code updated by GPT ✏️")
-        time.sleep(1)
+        if applied_any:
+            _run_optional_formatters_and_linters()
+            log("Code updated by GPT ✏️")
+            time.sleep(1)
 
     log("Failed to auto-fix file after max retries ❌", "ERROR")
-    shutil.rmtree(sandbox_root)
+    cleanup_sandbox()
     return False
 
 
@@ -235,6 +345,33 @@ def main():
         help="Optional: use AI to suggest which file to edit (AUTO_CODE_FIXER_AI_PLAN=1)",
     )
 
+    parser.add_argument(
+        "--patch-protocol",
+        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)"
+        ),
+    )
+
+    parser.add_argument(
+        "--format",
+        default=None,
+        choices=["black"],
+        help="Optional: run formatter in sandbox (best-effort). Currently supported: black",
+    )
+    parser.add_argument(
+        "--lint",
+        default=None,
+        choices=["ruff"],
+        help="Optional: run linter in sandbox (best-effort). Currently supported: ruff",
+    )
+    parser.add_argument(
+        "--fix",
+        action="store_true",
+        help="If used with --lint ruff, apply fixes (ruff --fix) (best-effort)",
+    )
+
     # ✅ Proper boolean flags
     ask_group = parser.add_mutually_exclusive_group()
     ask_group.add_argument(
@@ -289,6 +426,10 @@ def main():
         timeout_s=args.timeout,
         max_retries=args.max_retries,
         run_cmd=args.run,
+        patch_protocol=args.patch_protocol,
+        fmt=args.format,
+        lint=args.lint,
+        lint_fix=args.fix,
     )
 
     raise SystemExit(0 if ok else 2)

auto_code_fixer/fixer.py

@@ -77,3 +77,67 @@ def fix_code_with_gpt(
                 text += getattr(c, "text", "") or ""
 
     return _strip_code_fences(text)
+
+
+def fix_code_with_gpt_patch_protocol(
+    *,
+    sandbox_root: str,
+    error_log: str,
+    api_key: str | None = None,
+    model: str | None = None,
+    hint_paths: list[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.
+    """
+
+    client = get_openai_client(api_key)
+    model = model or os.getenv("AUTO_CODE_FIXER_MODEL") or "gpt-4.1-mini"
+
+    schema = {
+        "files": [
+            {
+                "path": "relative/path/from/sandbox_root.py",
+                "new_content": "FULL new file contents",
+                "sha256": "sha256 hex of new_content encoded as utf-8",
+            }
+        ]
+    }
+
+    hints = ""
+    if hint_paths:
+        hints = "\n\nCANDIDATE FILES (relative paths; edit one or more if needed):\n" + "\n".join(
+            f"- {p}" for p in hint_paths
+        )
+
+    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
+        + "\n\nSANDBOX ROOT:\n"
+        + sandbox_root
+        + "\n\nERROR LOG:\n"
+        + error_log
+    )
+
+    resp = client.responses.create(
+        model=model,
+        input=[
+            {"role": "system", "content": "You output strict JSON patches for code fixes."},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0.2,
+        max_output_tokens=3000,
+    )
+
+    text = ""
+    for item in resp.output or []:
+        for c in item.content or []:
+            if getattr(c, "type", None) in ("output_text", "text"):
+                text += getattr(c, "text", "") or ""
+
+    return _strip_code_fences(text)

auto_code_fixer/patch_protocol.py

@@ -0,0 +1,102 @@
+import hashlib
+import json
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class PatchFile:
+    """A single file edit from the structured patch protocol."""
+
+    path: str
+    new_content: str
+    sha256: str
+
+
+def strip_code_fences(text: str) -> str:
+    text = (text or "").strip()
+    if text.startswith("```"):
+        text = "\n".join(text.split("\n")[1:])
+    if text.endswith("```"):
+        text = "\n".join(text.split("\n")[:-1])
+    return text.strip()
+
+
+def compute_sha256_utf8(content: str) -> str:
+    return hashlib.sha256((content or "").encode("utf-8")).hexdigest()
+
+
+def parse_patch_protocol_response(text: str) -> list[PatchFile]:
+    """Parse model output for the patch protocol.
+
+    Expected JSON schema:
+      {"files": [{"path": "...", "new_content": "...", "sha256": "..."}, ...]}
+
+    Raises ValueError on invalid input.
+    """
+
+    cleaned = strip_code_fences(text)
+
+    try:
+        payload = json.loads(cleaned)
+    except Exception as e:  # pragma: no cover
+        raise ValueError(f"Invalid JSON: {e}")
+
+    if not isinstance(payload, dict):
+        raise ValueError("Patch protocol JSON must be an object")
+
+    files = payload.get("files")
+    if not isinstance(files, list) or not files:
+        raise ValueError("Patch protocol JSON must contain non-empty 'files' list")
+
+    out: list[PatchFile] = []
+    for i, f in enumerate(files):
+        if not isinstance(f, dict):
+            raise ValueError(f"files[{i}] must be an object")
+
+        path = f.get("path")
+        new_content = f.get("new_content")
+        sha256 = f.get("sha256")
+
+        if not isinstance(path, str) or not path.strip():
+            raise ValueError(f"files[{i}].path must be a non-empty string")
+        if not isinstance(new_content, str):
+            raise ValueError(f"files[{i}].new_content must be a string")
+        if not isinstance(sha256, str) or len(sha256.strip()) != 64:
+            raise ValueError(f"files[{i}].sha256 must be a 64-char hex string")
+
+        out.append(PatchFile(path=path, new_content=new_content, sha256=sha256.strip().lower()))
+
+    return out
+
+
+def validate_and_resolve_patch_files(
+    patch_files: list[PatchFile], *, sandbox_root: str
+) -> list[tuple[str, str]]:
+    """Validate patch files and return a list of (abs_path, new_content).
+
+    Safety:
+    - paths must be relative and remain within sandbox_root
+    - sha256 must match new_content (utf-8)
+    """
+
+    sr = os.path.realpath(os.path.abspath(sandbox_root))
+    resolved: list[tuple[str, str]] = []
+
+    for pf in patch_files:
+        if os.path.isabs(pf.path):
+            raise ValueError(f"Absolute path not allowed in patch protocol: {pf.path}")
+
+        # Normalize and resolve against sandbox_root
+        abs_path = os.path.realpath(os.path.abspath(os.path.join(sr, pf.path)))
+
+        if not (abs_path.startswith(sr + os.sep) or abs_path == sr):
+            raise ValueError(f"Patch path escapes sandbox root: {pf.path}")
+
+        got = compute_sha256_utf8(pf.new_content)
+        if got != pf.sha256:
+            raise ValueError(f"sha256 mismatch for {pf.path}: expected {pf.sha256}, got {got}")
+
+        resolved.append((abs_path, pf.new_content))
+
+    return resolved

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-code-fixer
-Version: 0.3.3
+Version: 0.3.5
 Summary: Automatically fix Python code using ChatGPT
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT
@@ -121,6 +121,21 @@ 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)
+```bash
+auto-code-fixer main.py --patch-protocol
+```
+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 main.py --format black
+auto-code-fixer main.py --lint ruff --fix
+```
+These run inside the sandbox venv and are skipped if the tools are not installed.
+
 ---
 
 ## Environment variables

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

@@ -1,9 +1,10 @@
-auto_code_fixer/__init__.py,sha256=8KcCYTXH99C2-gCLuPILJvtT9YftRWJsartIx6TQ2ZY,22
-auto_code_fixer/cli.py,sha256=Fsty_FJC7sm7mJCnXFQpwdF7N-fFxkJkgjhHFrGr0OA,10453
+auto_code_fixer/__init__.py,sha256=ThnCuF3X7rsQSd5PAea_jfYA70ZmhLvkFcLBxBPwZnY,22
+auto_code_fixer/cli.py,sha256=0UszYX0cmDQIQpuLYrRa_tJCklnzUiqDAAauOfsboeg,15307
 auto_code_fixer/command_runner.py,sha256=6P8hGRavN5C39x-e03p02Vc805NnZH9U7e48ngb5jJI,1104
-auto_code_fixer/fixer.py,sha256=DlAOVbw9AImEKJy8llisVCtss0tXKHMnioYeFBQGXlE,2293
+auto_code_fixer/fixer.py,sha256=s4owenfSKpoutzXyhVJ2fVecHp12ioQf5s8uPYdWbN0,4180
 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/plan.py,sha256=jrZdG-f1RDxVB0tBLlTwKbCSEiOYI_RMetdzfBcyE4s,1762
 auto_code_fixer/runner.py,sha256=BvQm3CrwkQEDOw0tpiamSTcdu3OjbOgA801xW2zWdP8,970
@@ -11,9 +12,9 @@ auto_code_fixer/sandbox.py,sha256=FWQcCxNDI4i7ckTKHuARSSIHCopBRqG16MVtx9s75R8,16
 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.3.dist-info/licenses/LICENSE,sha256=hgchJNa26tjXuLztwSUDbYQxNLnAPnLk6kDXNIkC8xc,1066
-auto_code_fixer-0.3.3.dist-info/METADATA,sha256=JBkdvGh27MLYWEGNX_NS46dnoVtidUhPyAn7uflcgZ8,3290
-auto_code_fixer-0.3.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-auto_code_fixer-0.3.3.dist-info/entry_points.txt,sha256=a-j2rkfwkrhXZ5Qbz_6_gwk6Bj7nijYR1DALjWp5Myk,61
-auto_code_fixer-0.3.3.dist-info/top_level.txt,sha256=qUk1qznb6Qxqmxy2A3z_5dpOZlmNKHwUiLuJwH-CrAk,16
-auto_code_fixer-0.3.3.dist-info/RECORD,,
+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,,