auto-code-fixer 0.3.7__py3-none-any.whl → 0.4.0__py3-none-any.whl

auto_code_fixer/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.7"
+__version__ = "0.4.0"

auto_code_fixer/cli.py

@@ -9,11 +9,14 @@ from auto_code_fixer.runner import run_code
 from auto_code_fixer.fixer import fix_code_with_gpt
 from auto_code_fixer.installer import check_and_install_missing_lib
 from auto_code_fixer.utils import (
+    changed_py_files,
     discover_all_files,
     is_in_project,
     log,
     set_verbose,
+    snapshot_py_hashes,
 )
+from auto_code_fixer.reporting import FixReport, ReportAttempt, unified_diff
 from auto_code_fixer import __version__
 
 DEFAULT_MAX_RETRIES = 8  # can be overridden via CLI
@@ -42,6 +45,8 @@ def fix_file(
     fmt: str | None,
     lint: str | None,
     lint_fix: bool,
+    ruff_first: bool,
+    report: FixReport | None,
 ) -> bool:
     log(f"Processing entry file: {file_path}")
 
@@ -71,12 +76,54 @@ def fix_file(
 
     venv_python = create_venv(sandbox_root)
 
+    def _run_ruff_first_pass() -> bool:
+        """Best-effort: run ruff auto-fix + import sorting + formatting before the LLM.
+
+        Returns True if it likely made changes.
+        """
+
+        from auto_code_fixer.command_runner import run_command
+
+        before = snapshot_py_hashes(sandbox_root)
+
+        # 1) Fix lint issues (including isort rules). --select I makes import sorting run
+        # even without an explicit project config.
+        rc1, _out1, err1 = run_command(
+            "python -m ruff check . --fix --select I",
+            timeout_s=max(timeout_s, 60),
+            python_exe=venv_python,
+            cwd=sandbox_root,
+            extra_env={"PYTHONPATH": sandbox_root},
+        )
+        if rc1 != 0:
+            if "No module named" in (err1 or "") and "ruff" in (err1 or ""):
+                log("ruff not installed in sandbox venv; skipping ruff-first", "DEBUG")
+                return False
+
+        # 2) Format (ruff formatter). Ignore failures.
+        run_command(
+            "python -m ruff format .",
+            timeout_s=max(timeout_s, 60),
+            python_exe=venv_python,
+            cwd=sandbox_root,
+            extra_env={"PYTHONPATH": sandbox_root},
+        )
+
+        after = snapshot_py_hashes(sandbox_root)
+        ch = changed_py_files(before, after)
+        if ch:
+            changed_sandbox_files.update({os.path.abspath(p) for p in ch})
+            return True
+        return False
+
     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
 
+        before = snapshot_py_hashes(sandbox_root)
+
         if fmt == "black":
-            rc, out, err = run_command(
+            rc, _out, err = run_command(
                 "python -m black .",
                 timeout_s=max(timeout_s, 60),
                 python_exe=venv_python,
@@ -96,7 +143,7 @@ def fix_file(
             cmd = "python -m ruff check ."
             if lint_fix:
                 cmd += " --fix"
-            rc, out, err = run_command(
+            rc, _out, err = run_command(
                 cmd,
                 timeout_s=max(timeout_s, 60),
                 python_exe=venv_python,
@@ -111,11 +158,25 @@ def fix_file(
                 else:
                     log(f"ruff reported issues (rc={rc}): {err}", "DEBUG")
 
+        after = snapshot_py_hashes(sandbox_root)
+        ch = changed_py_files(before, after)
+        if ch:
+            changed_sandbox_files.update({os.path.abspath(p) for p in ch})
+
     changed_sandbox_files: set[str] = set()
 
     for attempt in range(max_retries):
         log(f"Run attempt #{attempt + 1}")
 
+        changed_before = set(changed_sandbox_files)
+
+        attempt_report: ReportAttempt | None = None
+        if report is not None:
+            attempt_report = ReportAttempt(
+                index=attempt + 1,
+                run_cmd=run_cmd or f"python {os.path.relpath(sandbox_entry, sandbox_root)}",
+            )
+
         # Ensure local modules resolve inside sandbox
         if run_cmd:
             from auto_code_fixer.command_runner import run_command
@@ -136,6 +197,11 @@ def fix_file(
                 extra_env={"PYTHONPATH": sandbox_root},
             )
 
+        if attempt_report is not None:
+            attempt_report.return_code = int(retcode)
+            attempt_report.stdout = stdout
+            attempt_report.stderr = stderr
+
         if verbose:
             if stdout:
                 log(f"STDOUT:\n{stdout}", "DEBUG")
@@ -145,6 +211,11 @@ def fix_file(
         if retcode == 0:
             log("Script executed successfully ✅")
 
+            if attempt_report is not None and report is not None:
+                delta = sorted({os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)})
+                attempt_report.changed_files = delta
+                report.attempts.append(attempt_report)
+
             # Apply sandbox changes back to project (only if we actually changed something)
             if attempt > 0 and is_in_project(file_path, project_root) and changed_sandbox_files:
                 rel_changes = [os.path.relpath(p, sandbox_root) for p in sorted(changed_sandbox_files)]
@@ -202,6 +273,24 @@ def fix_file(
                             log(f"Backup created: {bak}", "DEBUG")
 
                         os.makedirs(os.path.dirname(dst_real), exist_ok=True)
+
+                        if report is not None:
+                            try:
+                                old_text = ""
+                                if os.path.exists(dst_real):
+                                    old_text = open(dst_real, encoding="utf-8").read()
+                                new_text = open(p_real, encoding="utf-8").read()
+                                rel_report = os.path.relpath(dst_real, project_root)
+                                report.files_touched = sorted(set(report.files_touched + [rel_report]))
+                                report.diffs[rel_report] = unified_diff(
+                                    old=old_text,
+                                    new=new_text,
+                                    fromfile=f"a/{rel_report}",
+                                    tofile=f"b/{rel_report}",
+                                )
+                            except Exception:
+                                pass
+
                         shutil.copy(p_real, dst_real)
                         log(f"File updated: {dst_real}")
 
@@ -246,8 +335,55 @@ def fix_file(
         if check_and_install_missing_lib(stderr, python_exe=venv_python, project_root=sandbox_root):
             log("Missing dependency installed (venv), retrying…")
             time.sleep(1)
+            if attempt_report is not None and report is not None:
+                delta = sorted({os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)})
+                attempt_report.changed_files = delta
+                report.attempts.append(attempt_report)
             continue
 
+        # Optional: ruff-first pass before invoking the LLM.
+        if ruff_first:
+            changed = _run_ruff_first_pass()
+            if attempt_report is not None:
+                attempt_report.ruff_first_applied = bool(changed)
+
+            if changed:
+                # Re-run command after ruff fixes.
+                if run_cmd:
+                    from auto_code_fixer.command_runner import run_command
+
+                    rc_r, out_r, err_r = run_command(
+                        run_cmd,
+                        timeout_s=timeout_s,
+                        python_exe=venv_python,
+                        cwd=sandbox_root,
+                        extra_env={"PYTHONPATH": sandbox_root},
+                    )
+                else:
+                    rc_r, out_r, err_r = run_code(
+                        sandbox_entry,
+                        timeout_s=timeout_s,
+                        python_exe=venv_python,
+                        cwd=sandbox_root,
+                        extra_env={"PYTHONPATH": sandbox_root},
+                    )
+
+                if rc_r == 0:
+                    log("Ruff-first fixed the issue; continuing", "DEBUG")
+                    if attempt_report is not None and report is not None:
+                        attempt_report.return_code = int(rc_r)
+                        attempt_report.stdout = out_r
+                        attempt_report.stderr = err_r
+                        delta = sorted({os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)})
+                        attempt_report.changed_files = delta
+                        report.attempts.append(attempt_report)
+                    continue
+                else:
+                    # Use the updated stderr/stdout for the LLM selection.
+                    stdout = out_r
+                    stderr = err_r
+                    retcode = rc_r
+
         # Pick the most relevant local file from the traceback (entry or imported file)
         from auto_code_fixer.traceback_utils import pick_relevant_file
 
@@ -282,6 +418,12 @@ def fix_file(
         except Exception:
             pass
 
+        if attempt_report is not None:
+            try:
+                attempt_report.selected_file = os.path.relpath(target_file, sandbox_root)
+            except Exception:
+                attempt_report.selected_file = target_file
+
         log(f"Sending {os.path.relpath(target_file, sandbox_root)} + error to GPT 🧠", "DEBUG")
 
         applied_any = False
@@ -459,11 +601,379 @@ def fix_file(
             log("Code updated by GPT ✏️")
             time.sleep(1)
 
+        if attempt_report is not None and report is not None:
+            delta = sorted({os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)})
+            attempt_report.changed_files = delta
+            report.attempts.append(attempt_report)
+
     log("Failed to auto-fix file after max retries ❌", "ERROR")
     cleanup_sandbox()
     return False
 
 
+def fixpack(
+    target_path: str,
+    project_root: str,
+    api_key: str | None,
+    ask: bool,
+    verbose: bool,
+    *,
+    dry_run: bool,
+    model: str | None,
+    timeout_s: int,
+    max_retries: int,
+    run_cmd: str | None,
+    patch_protocol: bool,
+    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,
+    ruff_first: bool,
+    report: FixReport | None,
+) -> bool:
+    """Run a command (pytest by default) in a full-project sandbox and iteratively fix failures."""
+
+    from auto_code_fixer.sandbox import make_sandbox_project
+    from auto_code_fixer.venv_manager import create_venv
+
+    project_root = os.path.abspath(project_root)
+    target_path = os.path.abspath(target_path)
+
+    sandbox_root = make_sandbox_project(project_root=project_root)
+    if report is not None:
+        report.sandbox_root = sandbox_root
+
+    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)
+
+    venv_python = create_venv(sandbox_root)
+    changed_sandbox_files: set[str] = set()
+
+    from auto_code_fixer.command_runner import run_command
+
+    effective_cmd = run_cmd or "pytest -q"
+
+    for attempt in range(max_retries):
+        log(f"Fixpack attempt #{attempt + 1}: running `{effective_cmd}`")
+
+        changed_before = set(changed_sandbox_files)
+
+        attempt_report: ReportAttempt | None = None
+        if report is not None:
+            attempt_report = ReportAttempt(index=attempt + 1, run_cmd=effective_cmd)
+
+        rc, out, err = run_command(
+            effective_cmd,
+            timeout_s=timeout_s,
+            python_exe=venv_python,
+            cwd=sandbox_root,
+            extra_env={"PYTHONPATH": sandbox_root},
+        )
+
+        combined = (out or "") + "\n" + (err or "")
+
+        if attempt_report is not None:
+            attempt_report.return_code = int(rc)
+            attempt_report.stdout = out
+            attempt_report.stderr = err
+
+        if verbose:
+            if out:
+                log(f"STDOUT:\n{out}", "DEBUG")
+            if err:
+                log(f"STDERR:\n{err}", "DEBUG")
+
+        if rc == 0:
+            log("Fixpack command succeeded ✅")
+
+            if attempt_report is not None and report is not None:
+                attempt_report.changed_files = sorted(
+                    {os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)}
+                )
+                report.attempts.append(attempt_report)
+
+            # Apply all changed sandbox files back to the real project.
+            if changed_sandbox_files:
+                rel_changes = [os.path.relpath(p, sandbox_root) for p in sorted(changed_sandbox_files)]
+
+                if ask:
+                    confirm = input(
+                        "Overwrite original files with fixed versions?\n"
+                        + "\n".join(f"- {c}" for c in rel_changes)
+                        + "\n(y/n): "
+                    ).strip().lower()
+                    if confirm != "y":
+                        log("User declined overwrite", "WARN")
+                        cleanup_sandbox()
+                        return False
+
+                if dry_run:
+                    log("DRY RUN: would apply fixes:\n" + "\n".join(rel_changes), "WARN")
+                else:
+                    # Compute diffs for report before copying.
+                    for p in sorted(changed_sandbox_files):
+                        rel = os.path.relpath(p, sandbox_root)
+                        dst = os.path.join(project_root, rel)
+                        if report is not None:
+                            try:
+                                old_text = ""
+                                if os.path.exists(dst):
+                                    old_text = open(dst, encoding="utf-8").read()
+                                new_text = open(p, encoding="utf-8").read()
+                                report.files_touched = sorted(set(report.files_touched + [rel]))
+                                report.diffs[rel] = unified_diff(
+                                    old=old_text,
+                                    new=new_text,
+                                    fromfile=f"a/{rel}",
+                                    tofile=f"b/{rel}",
+                                )
+                            except Exception:
+                                pass
+
+                        os.makedirs(os.path.dirname(dst), exist_ok=True)
+                        shutil.copy(p, dst)
+                        log(f"File updated: {dst}")
+
+                    if post_apply_check:
+                        rc2, out2, err2 = run_command(
+                            effective_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", "ERROR")
+                            cleanup_sandbox()
+                            return False
+
+            cleanup_sandbox()
+            return True
+
+        log("Fixpack command failed ❌", "ERROR")
+        print(combined)
+
+        if check_and_install_missing_lib(combined, python_exe=venv_python, project_root=sandbox_root):
+            log("Missing dependency installed (venv), retrying…")
+            time.sleep(1)
+            if attempt_report is not None and report is not None:
+                attempt_report.changed_files = sorted(
+                    {os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)}
+                )
+                report.attempts.append(attempt_report)
+            continue
+
+        if ruff_first:
+            before = snapshot_py_hashes(sandbox_root)
+            rc_r1, _o1, _e1 = run_command(
+                "python -m ruff check . --fix --select I",
+                timeout_s=max(timeout_s, 60),
+                python_exe=venv_python,
+                cwd=sandbox_root,
+                extra_env={"PYTHONPATH": sandbox_root},
+            )
+            run_command(
+                "python -m ruff format .",
+                timeout_s=max(timeout_s, 60),
+                python_exe=venv_python,
+                cwd=sandbox_root,
+                extra_env={"PYTHONPATH": sandbox_root},
+            )
+            after = snapshot_py_hashes(sandbox_root)
+            ch = changed_py_files(before, after)
+            if ch:
+                changed_sandbox_files.update(ch)
+                if attempt_report is not None:
+                    attempt_report.ruff_first_applied = True
+
+                # Re-run after ruff
+                rc3, out3, err3 = run_command(
+                    effective_cmd,
+                    timeout_s=timeout_s,
+                    python_exe=venv_python,
+                    cwd=sandbox_root,
+                    extra_env={"PYTHONPATH": sandbox_root},
+                )
+                if rc3 == 0:
+                    if attempt_report is not None:
+                        attempt_report.return_code = int(rc3)
+                        attempt_report.stdout = out3
+                        attempt_report.stderr = err3
+                    if attempt_report is not None and report is not None:
+                        attempt_report.changed_files = sorted(
+                            {os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)}
+                        )
+                        report.attempts.append(attempt_report)
+                    continue
+                combined = (out3 or "") + "\n" + (err3 or "")
+
+        from auto_code_fixer.traceback_utils import pick_relevant_file
+
+        target_file = pick_relevant_file(combined, sandbox_root=sandbox_root)
+        if not target_file:
+            log("Could not determine failing file from output; stopping.", "ERROR")
+            cleanup_sandbox()
+            return False
+
+        # Ensure inside sandbox
+        sr = os.path.realpath(os.path.abspath(sandbox_root))
+        tf = os.path.realpath(os.path.abspath(target_file))
+        if not (tf.startswith(sr + os.sep) or tf == sr):
+            log("Suspicious target file path outside sandbox; stopping.", "ERROR")
+            cleanup_sandbox()
+            return False
+
+        if attempt_report is not None:
+            attempt_report.selected_file = os.path.relpath(tf, sandbox_root)
+
+        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, atomic_write_verified_sha256
+                from auto_code_fixer.utils import find_imports
+                from auto_code_fixer.approval import (
+                    PlannedChange,
+                    UserAbort,
+                    guard_planned_changes,
+                    prompt_approve_file_by_file,
+                )
+
+                hint_paths = [os.path.relpath(tf, sandbox_root)]
+
+                ctx_pairs: list[tuple[str, str]] = []
+                if context_files and context_files > 0:
+                    rels: list[str] = []
+                    for abs_p in find_imports(tf, sandbox_root):
+                        try:
+                            rels.append(os.path.relpath(abs_p, sandbox_root))
+                        except Exception:
+                            continue
+                    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=combined,
+                    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)
+                sha_by_rel = {pf.path: pf.sha256 for pf in patch_files}
+
+                planned: list[PlannedChange] = []
+                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
+                    rel = os.path.relpath(abs_path, sandbox_root)
+                    planned.append(
+                        PlannedChange(
+                            abs_path=abs_path,
+                            rel_path=rel,
+                            old_content=old,
+                            new_content=new_content,
+                        )
+                    )
+
+                if planned:
+                    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:
+                            planned = []
+
+                for chg in planned:
+                    expected_sha = sha_by_rel.get(chg.rel_path)
+                    if not expected_sha:
+                        raise ValueError(f"Missing sha256 for {chg.rel_path} in patch protocol payload")
+                    atomic_write_verified_sha256(chg.abs_path, chg.new_content, expected_sha)
+                    changed_sandbox_files.add(os.path.abspath(chg.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(tf, encoding="utf-8").read(),
+                error_log=combined,
+                api_key=api_key,
+                model=model,
+            )
+
+            from auto_code_fixer.patcher import safe_write
+
+            if fixed_code.strip() == open(tf, encoding="utf-8").read().strip():
+                log("GPT returned no changes. Stopping.", "WARN")
+                cleanup_sandbox()
+                return False
+
+            safe_write(tf, fixed_code)
+            changed_sandbox_files.add(os.path.abspath(tf))
+            applied_any = True
+
+        if applied_any:
+            log("Code updated by GPT ✏️")
+            time.sleep(1)
+
+        if attempt_report is not None and report is not None:
+            attempt_report.changed_files = sorted(
+                {os.path.relpath(p, sandbox_root) for p in (set(changed_sandbox_files) - changed_before)}
+            )
+            report.attempts.append(attempt_report)
+
+    log("Failed to fixpack after max retries ❌", "ERROR")
+    cleanup_sandbox()
+    return False
+
+
 def main():
     parser = argparse.ArgumentParser(
         description="Auto-fix Python code using OpenAI (advanced sandbox + retry loop)"
@@ -478,7 +988,7 @@ def main():
     parser.add_argument(
         "entry_file",
         nargs="?",
-        help="Path to the main Python file",
+        help="Path to the main Python file (or folder/package path if --fixpack)",
     )
 
     parser.add_argument("--project-root", default=".")
@@ -495,6 +1005,35 @@ def main():
             "If set, it runs inside the sandbox venv."
         ),
     )
+
+    parser.add_argument(
+        "--fixpack",
+        action="store_true",
+        help=(
+            "Fixpack mode: treat entry_file as a folder/package path, create a full-project sandbox, "
+            "run a command (default: pytest -q), and iteratively fix failing files until green or budget."
+        ),
+    )
+
+    parser.add_argument(
+        "--ruff-first",
+        action="store_true",
+        help=(
+            "Before calling the LLM, try best-effort Ruff auto-fixes (including import sorting) and Ruff formatting."
+        ),
+    )
+
+    parser.add_argument(
+        "--explain",
+        action="store_true",
+        help="Write a JSON report (report.json by default) with attempts, diffs, and final status.",
+    )
+
+    parser.add_argument(
+        "--report",
+        default=None,
+        help="Path to write the JSON report (implies --explain). Default: ./report.json",
+    )
     parser.add_argument(
         "--ai-plan",
         action="store_true",
@@ -638,29 +1177,75 @@ def main():
     else:
         post_apply_check = bool(args.run)
 
-    ok = fix_file(
-        args.entry_file,
-        args.project_root,
-        args.api_key,
-        ask,
-        verbose,
-        dry_run=args.dry_run,
-        model=args.model,
-        timeout_s=args.timeout,
-        max_retries=args.max_retries,
-        run_cmd=args.run,
-        patch_protocol=not args.legacy_mode,
-        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,
-    )
+    report_path = args.report or ("report.json" if args.explain else None)
+    report: FixReport | None = None
+    if report_path is not None:
+        report = FixReport(
+            version=__version__,
+            mode="fixpack" if args.fixpack else "file",
+            project_root=os.path.abspath(args.project_root),
+            target=os.path.abspath(args.entry_file),
+            run_cmd=args.run or ("pytest -q" if args.fixpack else None),
+        )
+
+    try:
+        if args.fixpack:
+            ok = fixpack(
+                args.entry_file,
+                args.project_root,
+                args.api_key,
+                ask,
+                verbose,
+                dry_run=args.dry_run,
+                model=args.model,
+                timeout_s=args.timeout,
+                max_retries=args.max_retries,
+                run_cmd=args.run,
+                patch_protocol=not args.legacy_mode,
+                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,
+                ruff_first=args.ruff_first,
+                report=report,
+            )
+        else:
+            ok = fix_file(
+                args.entry_file,
+                args.project_root,
+                args.api_key,
+                ask,
+                verbose,
+                dry_run=args.dry_run,
+                model=args.model,
+                timeout_s=args.timeout,
+                max_retries=args.max_retries,
+                run_cmd=args.run,
+                patch_protocol=not args.legacy_mode,
+                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,
+                ruff_first=args.ruff_first,
+                report=report,
+            )
+    finally:
+        if report is not None and report_path is not None:
+            import datetime as _dt
+
+            report.finished_at = _dt.datetime.now(tz=_dt.timezone.utc).isoformat()
+            report.ok = bool(locals().get("ok", False))
+            report.write_json(report_path)
+            log(f"Wrote report: {os.path.abspath(report_path)}", "DEBUG")
 
     raise SystemExit(0 if ok else 2)
 

auto_code_fixer/reporting.py

@@ -0,0 +1,61 @@
+import dataclasses
+import datetime as _dt
+import difflib
+import json
+import os
+from typing import Any
+
+
+def utc_now_iso() -> str:
+    return _dt.datetime.now(tz=_dt.timezone.utc).isoformat()
+
+
+def unified_diff(*, old: str, new: str, fromfile: str, tofile: str) -> str:
+    return "".join(
+        difflib.unified_diff(
+            (old or "").splitlines(keepends=True),
+            (new or "").splitlines(keepends=True),
+            fromfile=fromfile,
+            tofile=tofile,
+        )
+    )
+
+
+@dataclasses.dataclass
+class ReportAttempt:
+    index: int
+    run_cmd: str
+    return_code: int = 0
+    stdout: str | None = None
+    stderr: str | None = None
+    selected_file: str | None = None
+    ruff_first_applied: bool = False
+    changed_files: list[str] = dataclasses.field(default_factory=list)
+
+
+@dataclasses.dataclass
+class FixReport:
+    tool: str = "auto-code-fixer"
+    version: str | None = None
+    mode: str = "file"  # file|fixpack
+    project_root: str | None = None
+    sandbox_root: str | None = None
+    target: str | None = None
+    run_cmd: str | None = None
+    started_at: str = dataclasses.field(default_factory=utc_now_iso)
+    finished_at: str | None = None
+    ok: bool | None = None
+    attempts: list[ReportAttempt] = dataclasses.field(default_factory=list)
+    files_touched: list[str] = dataclasses.field(default_factory=list)
+    diffs: dict[str, str] = dataclasses.field(default_factory=dict)  # relpath -> unified diff
+
+    def to_dict(self) -> dict[str, Any]:
+        d = dataclasses.asdict(self)
+        # dataclasses.asdict converts nested dataclasses, OK
+        return d
+
+    def write_json(self, path: str) -> None:
+        os.makedirs(os.path.dirname(os.path.abspath(path)) or ".", exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.to_dict(), f, indent=2, sort_keys=False)
+            f.write("\n")

auto_code_fixer/sandbox.py

@@ -35,6 +35,41 @@ def make_sandbox(*, entry_file: str, project_root: str) -> tuple[str, str]:
     return sandbox_root, sandbox_entry
 
 
+def make_sandbox_project(*, project_root: str) -> str:
+    """Create a sandbox directory with a full copy of project_root.
+
+    This is used for "Fixpack" runs where we execute a command (e.g., pytest) across
+    a package/folder and iteratively fix failures.
+    """
+
+    project_root = os.path.abspath(project_root)
+    sandbox_root = tempfile.mkdtemp(prefix="codefix_sandbox_")
+
+    def _ignore(_dir: str, names: list[str]):
+        skip = {".git",
+            ".venv",
+            "__pycache__",
+            "build",
+            "dist",
+            ".mypy_cache",
+            ".ruff_cache",
+            ".pytest_cache",
+        }
+        return {n for n in names if n in skip}
+
+    # Copy everything into sandbox_root.
+    # Note: copytree requires dest not to exist; copy contents manually.
+    for item in os.listdir(project_root):
+        src = os.path.join(project_root, item)
+        dst = os.path.join(sandbox_root, item)
+        if os.path.isdir(src):
+            shutil.copytree(src, dst, ignore=_ignore)
+        else:
+            shutil.copy2(src, dst)
+
+    return sandbox_root
+
+
 def apply_sandbox_back(*, sandbox_root: str, project_root: str, changed_paths: list[str]) -> None:
     """Copy changed sandbox files back into project_root."""
 

auto_code_fixer/utils.py

@@ -104,3 +104,45 @@ def discover_all_files(entry_file: str) -> list[str]:
 
 def is_in_project(file_path: str, project_root: str) -> bool:
     return os.path.abspath(file_path).startswith(os.path.abspath(project_root))
+
+
+def sha256_text(text: str) -> str:
+    import hashlib
+
+    return hashlib.sha256((text or "").encode("utf-8")).hexdigest()
+
+
+def snapshot_py_hashes(root: str) -> dict[str, str]:
+    """Return mapping of absolute .py path -> sha256 of contents."""
+
+    import hashlib
+
+    out: dict[str, str] = {}
+    for dirpath, dirnames, filenames in os.walk(root):
+        # Keep the walk light.
+        dirnames[:] = [
+            d
+            for d in dirnames
+            if d not in {".git", ".venv", "__pycache__", "build", "dist", ".mypy_cache", ".ruff_cache"}
+        ]
+        for fn in filenames:
+            if not fn.endswith(".py"):
+                continue
+            ap = os.path.join(dirpath, fn)
+            try:
+                data = Path(ap).read_bytes()
+            except Exception:
+                continue
+            out[os.path.abspath(ap)] = hashlib.sha256(data).hexdigest()
+    return out
+
+
+def changed_py_files(before: dict[str, str], after: dict[str, str]) -> set[str]:
+    """Return absolute paths for .py files whose hash changed or were added/removed."""
+
+    changed: set[str] = set()
+    all_paths = set(before) | set(after)
+    for p in all_paths:
+        if before.get(p) != after.get(p):
+            changed.add(os.path.abspath(p))
+    return changed

{auto_code_fixer-0.3.7.dist-info → auto_code_fixer-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-code-fixer
-Version: 0.3.7
+Version: 0.4.0
 Summary: Automatically fix Python code using ChatGPT
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT
@@ -108,6 +108,15 @@ auto-code-fixer path/to/main.py --project-root . --dry-run
 
 ## Advanced options
 
+### Fixpack mode (folder/package runner)
+Fixpack runs a command (default: `pytest -q`) against a **full-project sandbox**, then iteratively fixes the failing file(s) until green or you hit `--max-retries`.
+
+```bash
+auto-code-fixer path/to/package --project-root . --fixpack --no-ask
+# equivalent explicit command:
+auto-code-fixer path/to/package --project-root . --fixpack --run "pytest -q" --no-ask
+```
+
 ### Run a custom command (pytest, etc.)
 Instead of `python main.py`, run tests:
 
@@ -156,6 +165,13 @@ To disable this and use legacy full-text mode only:
 auto-code-fixer main.py --legacy-mode
 ```
 
+### Ruff-first mode (best-effort)
+Before calling the LLM, you can try Ruff auto-fixes (including import sorting) and Ruff formatting:
+
+```bash
+auto-code-fixer path/to/package --project-root . --fixpack --ruff-first
+```
+
 ### Optional formatting / linting (best-effort)
 ```bash
 auto-code-fixer main.py --format black
@@ -163,6 +179,15 @@ auto-code-fixer main.py --lint ruff --fix
 ```
 These run inside the sandbox venv and are skipped if the tools are not installed.
 
+### JSON report (explain)
+Write a machine-readable report with attempts, files touched, and unified diffs:
+
+```bash
+auto-code-fixer main.py --explain
+# or
+auto-code-fixer main.py --report /tmp/report.json
+```
+
 ---
 
 ## Environment variables

{auto_code_fixer-0.3.7.dist-info → auto_code_fixer-0.4.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-auto_code_fixer/__init__.py,sha256=J0I0c7-a50EOnWXMryTu_E6xhXSYFBPjVpeYP_a3vRI,22
+auto_code_fixer/__init__.py,sha256=42STGor_9nKYXumfeV5tiyD_M8VdcddX7CEexmibPBk,22
 auto_code_fixer/approval.py,sha256=NPSLu54maAK2RAJF_t4fq7Bs_M8K026DhDwqBFJtiwQ,2832
-auto_code_fixer/cli.py,sha256=Dq-tVpLMU6wEnOw7ox0MaKNyig8j0q0fdTJGN1D3HyM,24087
+auto_code_fixer/cli.py,sha256=Dn9A2geL58lvVWLt6K0whZfZVcBN3zpWEM5OS38Q4Ik,47713
 auto_code_fixer/command_runner.py,sha256=6P8hGRavN5C39x-e03p02Vc805NnZH9U7e48ngb5jJI,1104
 auto_code_fixer/fixer.py,sha256=zcgw56pRTuOLvna09lTXatD0VWwjjzBVk0OyEKfgxDM,4691
 auto_code_fixer/installer.py,sha256=LC0jasSsPI7eHMeDxa622OoMCR1951HAXUZWp-kcmVY,1522
@@ -8,14 +8,15 @@ 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=BcQTnjWazdpuEXyR2AlumFBzIk_yIrO3fGTaIqpHuiU,1811
 auto_code_fixer/plan.py,sha256=jrZdG-f1RDxVB0tBLlTwKbCSEiOYI_RMetdzfBcyE4s,1762
+auto_code_fixer/reporting.py,sha256=bulUsP0DIfLBmtVjZ1YdTV7RAk8Aiy81ASavcr4iano,1887
 auto_code_fixer/runner.py,sha256=BvQm3CrwkQEDOw0tpiamSTcdu3OjbOgA801xW2zWdP8,970
-auto_code_fixer/sandbox.py,sha256=FWQcCxNDI4i7ckTKHuARSSIHCopBRqG16MVtx9s75R8,1628
+auto_code_fixer/sandbox.py,sha256=s36i7mzZFjuAWRUEumxtYfVwasFa8TehobzH-rE_kKA,2721
 auto_code_fixer/traceback_utils.py,sha256=sbSuLO-2UBk5QPJZYJunTK9WGOpEY8mxR6WRKbtCIoM,935
-auto_code_fixer/utils.py,sha256=YXCv3PcDo5NBM1odksBTWkHTEELRtEXfPDIORA5iYaM,3090
+auto_code_fixer/utils.py,sha256=JLagGVnUj67zZdpkKSHhVcqwob30f62SyS7IbH20sHs,4369
 auto_code_fixer/venv_manager.py,sha256=2ww8reYgLbLohh-moAD5YKM09qv_mC5yYzJRwm3XiXc,1202
-auto_code_fixer-0.3.7.dist-info/licenses/LICENSE,sha256=hgchJNa26tjXuLztwSUDbYQxNLnAPnLk6kDXNIkC8xc,1066
-auto_code_fixer-0.3.7.dist-info/METADATA,sha256=NzIeRiTntfsDkboP3rnY1VphzjJ6VDKQRFZW3yn-juw,4735
-auto_code_fixer-0.3.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-auto_code_fixer-0.3.7.dist-info/entry_points.txt,sha256=a-j2rkfwkrhXZ5Qbz_6_gwk6Bj7nijYR1DALjWp5Myk,61
-auto_code_fixer-0.3.7.dist-info/top_level.txt,sha256=qUk1qznb6Qxqmxy2A3z_5dpOZlmNKHwUiLuJwH-CrAk,16
-auto_code_fixer-0.3.7.dist-info/RECORD,,
+auto_code_fixer-0.4.0.dist-info/licenses/LICENSE,sha256=hgchJNa26tjXuLztwSUDbYQxNLnAPnLk6kDXNIkC8xc,1066
+auto_code_fixer-0.4.0.dist-info/METADATA,sha256=qyjUMCYrF1_wRp_4LQSa6t1btgwTNslKTl9rBNhSdZo,5570
+auto_code_fixer-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+auto_code_fixer-0.4.0.dist-info/entry_points.txt,sha256=a-j2rkfwkrhXZ5Qbz_6_gwk6Bj7nijYR1DALjWp5Myk,61
+auto_code_fixer-0.4.0.dist-info/top_level.txt,sha256=qUk1qznb6Qxqmxy2A3z_5dpOZlmNKHwUiLuJwH-CrAk,16
+auto_code_fixer-0.4.0.dist-info/RECORD,,