auto-code-fixer 0.2.5__tar.gz → 0.3.0__tar.gz

auto_code_fixer-0.3.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: auto-code-fixer
+Version: 0.3.0
+Summary: Automatically fix Python code using ChatGPT
+Author-email: Arif Shah <ashah7775@gmail.com>
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/auto-code-fixer/
+Project-URL: Source, https://bitbucket.org/arif_automation/auto_code_fixer
+Project-URL: Issues, https://bitbucket.org/arif_automation/auto_code_fixer/issues
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-decouple
+Dynamic: license-file
+
+# Auto Code Fixer
+
+Auto Code Fixer is a CLI tool that **detects runtime failures** and automatically fixes Python code using OpenAI.
+
+It is designed for real projects where an entry script imports multiple local modules. The tool runs your code in an **isolated sandbox + venv**, installs missing external dependencies, and applies fixes only after the code executes successfully.
+
+---
+
+## Installation
+
+```bash
+pip install auto-code-fixer
+```
+
+---
+
+## Quick start
+
+```bash
+auto-code-fixer path/to/main.py --project-root . --ask
+```
+
+If you want it to overwrite without asking:
+
+```bash
+auto-code-fixer path/to/main.py --project-root . --no-ask
+```
+
+---
+
+## What it fixes (core behavior)
+
+### ✅ Local/internal imports are treated as project code
+If your entry file imports something like:
+
+```py
+from mylib import add
+```
+
+…and `mylib.py` exists inside the project, Auto Code Fixer will:
+- copy `main.py` + `mylib.py` into a sandbox
+- execute inside the sandbox
+- if the traceback points to `mylib.py`, it will fix `mylib.py`
+- then apply the fix back to your repo (with backups)
+
+### ✅ External imports are auto-installed
+If execution fails with:
+
+```
+ModuleNotFoundError: No module named 'requests'
+```
+
+…it will run:
+
+```bash
+pip install requests
+```
+
+…but only inside the sandbox venv (so your system env isn’t polluted).
+
+---
+
+## Safety
+
+### Backups
+Before overwriting any file, it creates a backup:
+- `file.py.bak` (or `.bak1`, `.bak2`, ...)
+
+### Dry run
+```bash
+auto-code-fixer path/to/main.py --project-root . --dry-run
+```
+
+---
+
+## Advanced options
+
+### Run a custom command (pytest, etc.)
+Instead of `python main.py`, run tests:
+
+```bash
+auto-code-fixer . --project-root . --run "pytest -q" --no-ask
+```
+
+### Model selection
+```bash
+export AUTO_CODE_FIXER_MODEL=gpt-4.1-mini
+# or
+auto-code-fixer main.py --model gpt-4.1-mini
+```
+
+### Max retries / timeout
+```bash
+auto-code-fixer main.py --max-retries 8 --timeout 30
+```
+
+### Optional AI planning (which file to edit)
+```bash
+auto-code-fixer main.py --ai-plan
+```
+This enables a helper that can suggest which local file to edit. It is best-effort.
+
+---
+
+## Environment variables
+
+- `OPENAI_API_KEY` (required unless you always pass `--api-key`)
+- `AUTO_CODE_FIXER_MODEL` (default model)
+- `AUTO_CODE_FIXER_ASK=true|false`
+- `AUTO_CODE_FIXER_VERBOSE=true|false`
+
+---
+
+## Notes
+
+- This tool edits code. Use it on a git repo so you can review diffs.
+- For maximum safety, run with `--ask` and/or `--dry-run`.

auto_code_fixer-0.3.0/README.md

@@ -0,0 +1,117 @@
+# Auto Code Fixer
+
+Auto Code Fixer is a CLI tool that **detects runtime failures** and automatically fixes Python code using OpenAI.
+
+It is designed for real projects where an entry script imports multiple local modules. The tool runs your code in an **isolated sandbox + venv**, installs missing external dependencies, and applies fixes only after the code executes successfully.
+
+---
+
+## Installation
+
+```bash
+pip install auto-code-fixer
+```
+
+---
+
+## Quick start
+
+```bash
+auto-code-fixer path/to/main.py --project-root . --ask
+```
+
+If you want it to overwrite without asking:
+
+```bash
+auto-code-fixer path/to/main.py --project-root . --no-ask
+```
+
+---
+
+## What it fixes (core behavior)
+
+### ✅ Local/internal imports are treated as project code
+If your entry file imports something like:
+
+```py
+from mylib import add
+```
+
+…and `mylib.py` exists inside the project, Auto Code Fixer will:
+- copy `main.py` + `mylib.py` into a sandbox
+- execute inside the sandbox
+- if the traceback points to `mylib.py`, it will fix `mylib.py`
+- then apply the fix back to your repo (with backups)
+
+### ✅ External imports are auto-installed
+If execution fails with:
+
+```
+ModuleNotFoundError: No module named 'requests'
+```
+
+…it will run:
+
+```bash
+pip install requests
+```
+
+…but only inside the sandbox venv (so your system env isn’t polluted).
+
+---
+
+## Safety
+
+### Backups
+Before overwriting any file, it creates a backup:
+- `file.py.bak` (or `.bak1`, `.bak2`, ...)
+
+### Dry run
+```bash
+auto-code-fixer path/to/main.py --project-root . --dry-run
+```
+
+---
+
+## Advanced options
+
+### Run a custom command (pytest, etc.)
+Instead of `python main.py`, run tests:
+
+```bash
+auto-code-fixer . --project-root . --run "pytest -q" --no-ask
+```
+
+### Model selection
+```bash
+export AUTO_CODE_FIXER_MODEL=gpt-4.1-mini
+# or
+auto-code-fixer main.py --model gpt-4.1-mini
+```
+
+### Max retries / timeout
+```bash
+auto-code-fixer main.py --max-retries 8 --timeout 30
+```
+
+### Optional AI planning (which file to edit)
+```bash
+auto-code-fixer main.py --ai-plan
+```
+This enables a helper that can suggest which local file to edit. It is best-effort.
+
+---
+
+## Environment variables
+
+- `OPENAI_API_KEY` (required unless you always pass `--api-key`)
+- `AUTO_CODE_FIXER_MODEL` (default model)
+- `AUTO_CODE_FIXER_ASK=true|false`
+- `AUTO_CODE_FIXER_VERBOSE=true|false`
+
+---
+
+## Notes
+
+- This tool edits code. Use it on a git repo so you can review diffs.
+- For maximum safety, run with `--ask` and/or `--dry-run`.

auto_code_fixer-0.3.0/auto_code_fixer/__init__.py

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

auto_code_fixer-0.3.0/auto_code_fixer/cli.py

@@ -0,0 +1,261 @@
+import argparse
+import os
+import shutil
+import tempfile
+import time
+from decouple import config
+
+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 (
+    discover_all_files,
+    is_in_project,
+    log,
+    set_verbose,
+)
+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:
+    log(f"Processing entry file: {file_path}")
+
+    project_root = os.path.abspath(project_root)
+    file_path = os.path.abspath(file_path)
+
+    # Build sandbox with entry + imported local files
+    from auto_code_fixer.sandbox import make_sandbox
+    sandbox_root, sandbox_entry = make_sandbox(entry_file=file_path, project_root=project_root)
+
+    # 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)
+
+    changed_sandbox_files: set[str] = set()
+
+    for attempt in range(max_retries):
+        log(f"Run attempt #{attempt + 1}")
+
+        # Ensure local modules resolve inside sandbox
+        if run_cmd:
+            from auto_code_fixer.command_runner import run_command
+
+            retcode, stdout, stderr = run_command(
+                run_cmd,
+                timeout_s=timeout_s,
+                python_exe=venv_python,
+                cwd=sandbox_root,
+                extra_env={"PYTHONPATH": sandbox_root},
+            )
+        else:
+            retcode, stdout, stderr = run_code(
+                sandbox_entry,
+                timeout_s=timeout_s,
+                python_exe=venv_python,
+                cwd=sandbox_root,
+                extra_env={"PYTHONPATH": sandbox_root},
+            )
+
+        if verbose:
+            if stdout:
+                log(f"STDOUT:\n{stdout}", "DEBUG")
+            if stderr:
+                log(f"STDERR:\n{stderr}", "DEBUG")
+
+        if retcode == 0:
+            log("Script executed successfully ✅")
+
+            # 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)]
+
+                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")
+                        shutil.rmtree(sandbox_root)
+                        return False
+
+                if dry_run:
+                    log("DRY RUN: would apply fixes:\n" + "\n".join(rel_changes), "WARN")
+                else:
+                    for p in sorted(changed_sandbox_files):
+                        rel = os.path.relpath(p, sandbox_root)
+                        dst = os.path.join(project_root, rel)
+                        if os.path.exists(dst):
+                            bak = backup_file(dst)
+                            log(f"Backup created: {bak}", "DEBUG")
+                        os.makedirs(os.path.dirname(dst), exist_ok=True)
+                        shutil.copy(p, dst)
+                        log(f"File updated: {dst}")
+
+            shutil.rmtree(sandbox_root)
+            log(f"Fix completed in {attempt + 1} attempt(s) 🎉")
+            return True
+
+        log("Error detected ❌", "ERROR")
+        print(stderr)
+
+        if check_and_install_missing_lib(stderr, python_exe=venv_python, project_root=sandbox_root):
+            log("Missing dependency installed (venv), retrying…")
+            time.sleep(1)
+            continue
+
+        # Pick the most relevant local file from the traceback (entry or imported file)
+        from auto_code_fixer.traceback_utils import pick_relevant_file
+
+        target_file = pick_relevant_file(stderr, sandbox_root=sandbox_root) or sandbox_entry
+
+        # Optional AI fix plan can override file selection
+        try:
+            from auto_code_fixer.plan import ask_ai_for_fix_plan
+
+            plan = ask_ai_for_fix_plan(
+                sandbox_root=sandbox_root,
+                stderr=stderr,
+                api_key=api_key,
+                model=model,
+            )
+            if plan and plan.target_files:
+                # Use the first suggested file that exists
+                for rel in plan.target_files:
+                    cand = os.path.abspath(os.path.join(sandbox_root, rel))
+                    if cand.startswith(os.path.abspath(sandbox_root)) and os.path.exists(cand):
+                        target_file = cand
+                        break
+        except Exception:
+            pass
+
+        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,
+        )
+
+        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)
+
+        changed_sandbox_files.add(os.path.abspath(target_file))
+
+        log("Code updated by GPT ✏️")
+        time.sleep(1)
+
+    log("Failed to auto-fix file after max retries ❌", "ERROR")
+    shutil.rmtree(sandbox_root)
+    return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Auto-fix Python code using OpenAI (advanced sandbox + retry loop)"
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    parser.add_argument(
+        "entry_file",
+        nargs="?",
+        help="Path to the main Python file",
+    )
+
+    parser.add_argument("--project-root", default=".")
+    parser.add_argument("--api-key")
+    parser.add_argument("--model", default=None, help="OpenAI model (default: AUTO_CODE_FIXER_MODEL or gpt-4.1-mini)")
+    parser.add_argument("--timeout", type=int, default=30, help="Execution timeout seconds (default: 30)")
+    parser.add_argument("--dry-run", action="store_true", help="Do not overwrite files; just report what would change")
+    parser.add_argument("--max-retries", type=int, default=DEFAULT_MAX_RETRIES, help="Max fix attempts (default: 8)")
+    parser.add_argument(
+        "--run",
+        default=None,
+        help=(
+            "Optional command to run instead of `python entry.py`. Examples: 'pytest -q', 'python -m module'. "
+            "If set, it runs inside the sandbox venv."
+        ),
+    )
+    parser.add_argument(
+        "--ai-plan",
+        action="store_true",
+        help="Optional: use AI to suggest which file to edit (AUTO_CODE_FIXER_AI_PLAN=1)",
+    )
+
+    # ✅ Proper boolean flags
+    ask_group = parser.add_mutually_exclusive_group()
+    ask_group.add_argument(
+        "--ask",
+        action="store_true",
+        help="Ask before overwriting files",
+    )
+    ask_group.add_argument(
+        "--no-ask",
+        action="store_true",
+        help="Do not ask before overwriting files",
+    )
+
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose/debug output",
+    )
+
+    args = parser.parse_args()
+
+    if not args.entry_file:
+        parser.error("the following arguments are required: entry_file")
+
+    # ENV defaults
+    env_ask = config("AUTO_CODE_FIXER_ASK", default=False, cast=bool)
+    env_verbose = config("AUTO_CODE_FIXER_VERBOSE", default=False, cast=bool)
+
+    # Final ask resolution (CLI overrides ENV)
+    if args.ask:
+        ask = True
+    elif args.no_ask:
+        ask = False
+    else:
+        ask = env_ask
+
+    verbose = args.verbose or env_verbose
+    set_verbose(verbose)
+
+    # Optional: enable AI planning helper
+    if args.ai_plan:
+        os.environ["AUTO_CODE_FIXER_AI_PLAN"] = "1"
+
+    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,
+    )
+
+    raise SystemExit(0 if ok else 2)
+
+
+if __name__ == "__main__":
+    main()

auto_code_fixer-0.3.0/auto_code_fixer/command_runner.py

@@ -0,0 +1,45 @@
+import os
+import shlex
+import subprocess
+
+
+def run_command(
+    cmd: str,
+    *,
+    timeout_s: int,
+    python_exe: str,
+    cwd: str,
+    extra_env: dict | None = None,
+):
+    """Run an arbitrary command inside the sandbox.
+
+    If cmd starts with 'python', replace with the sandbox venv python.
+    If cmd starts with 'pytest', run as `python -m pytest ...`.
+    """
+
+    parts = shlex.split(cmd)
+    if not parts:
+        return -1, "", "Empty command"
+
+    if parts[0] == "python" or parts[0] == "python3":
+        parts[0] = python_exe
+
+    if parts[0] == "pytest":
+        parts = [python_exe, "-m", "pytest", *parts[1:]]
+
+    env = {**os.environ}
+    if extra_env:
+        env.update({k: str(v) for k, v in extra_env.items()})
+
+    try:
+        r = subprocess.run(
+            parts,
+            capture_output=True,
+            text=True,
+            timeout=timeout_s,
+            cwd=cwd,
+            env=env,
+        )
+        return r.returncode, r.stdout, r.stderr
+    except subprocess.TimeoutExpired:
+        return -1, "", f"TimeoutExpired: Command took too long to run ({timeout_s}s)."

auto_code_fixer-0.3.0/auto_code_fixer/fixer.py

@@ -0,0 +1,79 @@
+import json
+import os
+from decouple import config
+from openai import OpenAI
+
+
+def get_openai_client(api_key: str | None = None) -> OpenAI:
+    key = api_key or os.getenv("OPENAI_API_KEY") or config("OPENAI_API_KEY", default=None)
+    if not key:
+        raise RuntimeError(
+            "OpenAI API key not found. Set OPENAI_API_KEY env var or .env file or pass --api-key"
+        )
+    return OpenAI(api_key=key)
+
+
+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 fix_code_with_gpt(
+    *,
+    original_code: str,
+    error_log: str,
+    api_key: str | None = None,
+    model: str | None = None,
+) -> str:
+    """Fix code using OpenAI. Returns full corrected code.
+
+    Model can be set via:
+      - --model
+      - AUTO_CODE_FIXER_MODEL env
+      - default fallback
+    """
+
+    client = get_openai_client(api_key)
+    model = model or os.getenv("AUTO_CODE_FIXER_MODEL") or "gpt-4.1-mini"
+
+    instructions = {
+        "task": "Fix Python code to run without errors.",
+        "requirements": [
+            "Preserve existing behavior unless required to fix the crash.",
+            "Do not remove functionality.",
+            "Return ONLY the full corrected Python source code (no markdown).",
+        ],
+    }
+
+    prompt = (
+        "You are a senior Python engineer. Fix the following Python code so it runs without errors.\n\n"
+        "INSTRUCTIONS (JSON):\n"
+        + json.dumps(instructions)
+        + "\n\nCODE:\n"
+        + original_code
+        + "\n\nERROR LOG:\n"
+        + error_log
+    )
+
+    # Use Responses API (openai>=1) for forward compatibility
+    resp = client.responses.create(
+        model=model,
+        input=[
+            {"role": "system", "content": "You fix broken Python code."},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0.2,
+        max_output_tokens=2000,
+    )
+
+    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-0.3.0/auto_code_fixer/installer.py

@@ -0,0 +1,47 @@
+import re
+import subprocess
+
+
+_MISSING_RE = re.compile(r"No module named '([^']+)'")
+
+
+def parse_missing_module(stderr: str) -> str | None:
+    m = _MISSING_RE.search(stderr or "")
+    if not m:
+        return None
+    return m.group(1)
+
+
+def install_package(package: str, *, python_exe: str) -> bool:
+    try:
+        subprocess.check_call([python_exe, "-m", "pip", "install", package])
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def is_local_module(module: str, *, project_root: str) -> bool:
+    """Return True if `module` can be resolved to a local file/package under project_root."""
+    import os
+    from pathlib import Path
+
+    base = Path(project_root)
+    parts = module.split(".")
+    candidates = [
+        base.joinpath(*parts).with_suffix(".py"),
+        base.joinpath(*parts, "__init__.py"),
+    ]
+    return any(os.path.isfile(str(p)) for p in candidates)
+
+
+def check_and_install_missing_lib(stderr: str, *, python_exe: str, project_root: str) -> bool:
+    lib = parse_missing_module(stderr)
+    if not lib:
+        return False
+
+    # ✅ Important: do NOT pip install if it's a local module.
+    if is_local_module(lib, project_root=project_root):
+        return False
+
+    # naive mapping; user can always fix the requirement name manually.
+    return install_package(lib, python_exe=python_exe)

auto_code_fixer-0.3.0/auto_code_fixer/models.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RunResult:
+    returncode: int
+    stdout: str
+    stderr: str
+
+
+@dataclass
+class FixResult:
+    success: bool
+    attempts: int
+    changed_files: list[str]
+    last_error: str | None = None
+    sandbox_root: str | None = None