auto-code-fixer 0.2.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

auto_code_fixer/__init__.py

@@ -1,2 +1 @@
-__version__ = "0.2.5"
-
+__version__ = "0.3.0"

auto_code_fixer/cli.py

@@ -1,8 +1,8 @@
 import argparse
+import os
 import shutil
 import tempfile
 import time
-import os
 from decouple import config
 
 from auto_code_fixer.runner import run_code
@@ -14,32 +14,51 @@ from auto_code_fixer.utils import (
     log,
     set_verbose,
 )
-from auto_code_fixer.guard import import_hijacked
 from auto_code_fixer import __version__
 
-MAX_RETRIES = 5
+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}")
 
-def fix_file(file_path, project_root, api_key, ask, verbose):
-    log(f"Processing file: {file_path}")
+    project_root = os.path.abspath(project_root)
+    file_path = os.path.abspath(file_path)
 
-    with open(file_path) as f:
-        current_code = f.read()   # 🔑 SOURCE OF TRUTH
+    # 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)
 
-    temp_dir = tempfile.mkdtemp(prefix="codefix_")
-    temp_file = os.path.join(temp_dir, "temp.py")
+    # Create isolated venv in sandbox
+    from auto_code_fixer.venv_manager import create_venv
+    from auto_code_fixer.patcher import backup_file
 
-    # write initial code to temp
-    with open(temp_file, "w") as f:
-        f.write(current_code)
+    venv_python = create_venv(sandbox_root)
 
-    for attempt in range(MAX_RETRIES):
+    changed_sandbox_files: set[str] = set()
+
+    for attempt in range(max_retries):
         log(f"Run attempt #{attempt + 1}")
 
-        retcode, stdout, stderr = run_code(
-            temp_file,
-            project_root=project_root,
-        )
+        # 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:
@@ -50,90 +69,101 @@ def fix_file(file_path, project_root, api_key, ask, verbose):
         if retcode == 0:
             log("Script executed successfully ✅")
 
-            if attempt > 0 and is_in_project(file_path, project_root):
+            # 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(
-                        f"Overwrite original file '{file_path}' with fixed version? (y/n): "
+                        "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(temp_dir)
-                        return
-
-                # ✅ WRITE FROM MEMORY, NOT TEMP FILE
-                with open(file_path, "w") as f:
-                    f.write(current_code)
-
-                log(f"File updated: {file_path}")
-
-            shutil.rmtree(temp_dir)
+                        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
+            return True
 
         log("Error detected ❌", "ERROR")
         print(stderr)
 
-        if check_and_install_missing_lib(stderr, project_root):
-            log("Missing dependency installed, retrying…")
+        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
 
-        log("Sending code & error to GPT 🧠", "DEBUG")
-
-        fixed_code = fix_code_with_gpt(
-            current_code,
-            stderr,
-            api_key,
-        )
-
-        if import_hijacked(current_code, fixed_code):
-            log(
-                "GPT attempted to hijack local imports. Rejecting fix.",
-                "ERROR",
-            )
-            break
-
-        if fixed_code.strip() == current_code.strip():
-            log("GPT returned no changes. Stopping.", "WARN")
-            break
+        # Pick the most relevant local file from the traceback (entry or imported file)
+        from auto_code_fixer.traceback_utils import pick_relevant_file
 
-        import ast
+        target_file = pick_relevant_file(stderr, sandbox_root=sandbox_root) or sandbox_entry
 
-        # Validate GPT output BEFORE accepting it
+        # Optional AI fix plan can override file selection
         try:
-            ast.parse(fixed_code)
-        except SyntaxError:
-            log(
-                "GPT returned invalid or empty Python code. Rejecting fix.",
-                "ERROR",
-            )
-            break
+            from auto_code_fixer.plan import ask_ai_for_fix_plan
 
-        if not fixed_code.strip():
-            log(
-                "GPT returned empty code. Rejecting fix.",
-                "ERROR",
+            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
 
-        # ✅ SAFE: update memory only after validation
-        current_code = fixed_code
+        with open(target_file, "w", encoding="utf-8") as f:
+            f.write(fixed_code)
 
-        # then update temp file for next execution
-        with open(temp_file, "w") as f:
-            f.write(current_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(temp_dir)
-
+    shutil.rmtree(sandbox_root)
+    return False
 
 
 def main():
     parser = argparse.ArgumentParser(
-        description="Auto-fix Python code using ChatGPT"
+        description="Auto-fix Python code using OpenAI (advanced sandbox + retry loop)"
     )
 
     parser.add_argument(
@@ -150,24 +180,53 @@ def main():
 
     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")
-    ask_group.add_argument("--no-ask", action="store_true")
+    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")
+    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")
 
-    # 🔑 NORMALIZE ROOT PATH ONCE
-    project_root = os.path.abspath(args.project_root)
-
+    # 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:
@@ -178,6 +237,25 @@ def main():
     verbose = args.verbose or env_verbose
     set_verbose(verbose)
 
-    files = discover_all_files(args.entry_file)
-    for file in files:
-        fix_file(file, project_root, args.api_key, ask, 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/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/fixer.py

@@ -1,60 +1,79 @@
-from openai import OpenAI
+import json
+import os
 from decouple import config
+from openai import OpenAI
 
-client = OpenAI(api_key=config("chat_gpt_secret_key"))
 
+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 fix_code_with_gpt(original_code: str, error_log: str, api_key: str | None):
-    """
-    Send code + error to GPT and return fixed code.
-    Enforces strict rules to prevent semantic-breaking fixes.
+
+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
     """
 
-    system_prompt = """
-You are a senior Python engineer fixing code.
-
-STRICT RULES (DO NOT VIOLATE):
-- NEVER replace or wrap local imports with try/except.
-- NEVER inline, duplicate, or redefine code from other local files.
-- NEVER change import statements for local modules.
-- Assume all local imports are valid and must remain unchanged.
-- If an import fails, assume environment configuration is incorrect.
-- Only fix syntax errors or runtime errors in the current file.
-- Return ONLY valid Python code. No markdown. No explanation.
-"""
-
-    user_prompt = f"""
-The following Python code has an error.
-
-CODE:
-{original_code}
-
-ERROR:
-{error_log}
-
-Fix the code according to the rules.
-"""
-
-    try:
-        response = client.chat.completions.create(
-            model="gpt-5",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
-            ],
-            max_completion_tokens=1500,
-        )
+    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).",
+        ],
+    }
 
-        fixed_code = response.choices[0].message.content.strip()
+    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
+    )
 
-        # strip accidental markdown fences
-        if fixed_code.startswith("```"):
-            fixed_code = "\n".join(fixed_code.splitlines()[1:])
-        if fixed_code.endswith("```"):
-            fixed_code = "\n".join(fixed_code.splitlines()[:-1])
+    # 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,
+    )
 
-        return fixed_code.strip()
+    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 ""
 
-    except Exception as e:
-        print(f"Error calling OpenAI API: {e}")
-        return original_code
+    return _strip_code_fences(text)

auto_code_fixer/installer.py

@@ -1,25 +1,47 @@
-import os
 import re
-import sys
 import subprocess
 
 
-def check_and_install_missing_lib(stderr, project_root):
-    match = re.search(r"No module named '([^']+)'", stderr)
-    if not match:
-        return False
+_MISSING_RE = re.compile(r"No module named '([^']+)'")
 
-    missing = match.group(1)
 
-    # 🔒 CRITICAL: skip local project modules
-    local_file = os.path.join(project_root, f"{missing}.py")
-    if os.path.exists(local_file):
-        return False
+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(
-            [sys.executable, "-m", "pip", "install", missing]
-        )
+        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/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

auto_code_fixer/patcher.py

@@ -0,0 +1,31 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class FileEdit:
+    path: str
+    new_content: str
+
+
+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)
+
+
+def safe_read(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def backup_file(path: str) -> str:
+    bak = path + ".bak"
+    # Avoid overwriting an existing bak
+    i = 1
+    while os.path.exists(bak):
+        bak = f"{path}.bak{i}"
+        i += 1
+    with open(path, "rb") as src, open(bak, "wb") as dst:
+        dst.write(src.read())
+    return bak

auto_code_fixer/plan.py

@@ -0,0 +1,61 @@
+import json
+import os
+from dataclasses import dataclass
+
+from auto_code_fixer.fixer import get_openai_client
+
+
+@dataclass
+class FixPlan:
+    target_files: list[str]
+    reason: str
+
+
+def ask_ai_for_fix_plan(*, sandbox_root: str, stderr: str, api_key: str | None, model: str | None) -> FixPlan | None:
+    """Optional: let AI propose which file to edit.
+
+    This is a best-effort helper; errors should be ignored by caller.
+    """
+
+    if os.getenv("AUTO_CODE_FIXER_AI_PLAN", "0").lower() not in {"1", "true", "yes"}:
+        return None
+
+    client = get_openai_client(api_key)
+    model = model or os.getenv("AUTO_CODE_FIXER_MODEL") or "gpt-4.1-mini"
+
+    prompt = (
+        "Given this Python traceback, decide which local file(s) should be edited to fix it.\n"
+        "Return ONLY JSON with keys: target_files (list of relative paths), reason (string).\n"
+        f"Sandbox root: {sandbox_root}\n\n"
+        "Traceback:\n" + (stderr or "")
+    )
+
+    resp = client.responses.create(
+        model=model,
+        input=[{"role": "user", "content": prompt}],
+        temperature=0.0,
+        max_output_tokens=600,
+    )
+
+    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 ""
+
+    text = (text or "").strip()
+    if not text:
+        return None
+
+    data = json.loads(text)
+    if not isinstance(data, dict):
+        return None
+
+    target_files = data.get("target_files") or []
+    if not isinstance(target_files, list):
+        return None
+
+    target_files = [str(x) for x in target_files if x]
+    reason = str(data.get("reason") or "")
+
+    return FixPlan(target_files=target_files, reason=reason)

auto_code_fixer/runner.py

@@ -1,30 +1,38 @@
-import subprocess
 import os
+import subprocess
 import sys
 
 
-def run_code(script_path, project_root):
-    env = os.environ.copy()
-
-    script_dir = os.path.dirname(script_path)
+def run_code(
+    path_to_code: str,
+    *,
+    timeout_s: int = 30,
+    python_exe: str | None = None,
+    cwd: str | None = None,
+    extra_env: dict | None = None,
+):
+    """Run a python file and capture output.
 
-    # 🔑 CRITICAL: include BOTH project root and script dir
-    paths = [project_root, script_dir]
+    python_exe: allow running inside a venv interpreter.
+    cwd: working directory (important for relative imports/files)
+    extra_env: extra environment variables (merged)
+    """
 
-    existing = env.get("PYTHONPATH", "")
-    if existing:
-        paths.append(existing)
-
-    env["PYTHONPATH"] = os.pathsep.join(paths)
+    exe = python_exe or sys.executable
+    env = {**os.environ}
+    if extra_env:
+        env.update({k: str(v) for k, v in extra_env.items()})
 
     try:
         result = subprocess.run(
-            [sys.executable, script_path],
+            [exe, path_to_code],
             capture_output=True,
             text=True,
-            timeout=15,
+            timeout=timeout_s,
             env=env,
+            cwd=cwd,
         )
         return result.returncode, result.stdout, result.stderr
     except subprocess.TimeoutExpired:
         return -1, "", "TimeoutExpired: Code took too long to run."
+

auto_code_fixer/sandbox.py

@@ -0,0 +1,49 @@
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+
+def make_sandbox(*, entry_file: str, project_root: str) -> tuple[str, str]:
+    """Create a sandbox directory containing entry_file and discovered local imports.
+
+    Returns (sandbox_root, sandbox_entry_path).
+
+    Files are copied preserving relative paths from project_root.
+    """
+
+    from auto_code_fixer.utils import discover_all_files
+
+    project_root = os.path.abspath(project_root)
+    entry_file = os.path.abspath(entry_file)
+
+    sandbox_root = tempfile.mkdtemp(prefix="codefix_sandbox_")
+
+    files = discover_all_files(entry_file)
+
+    for src in files:
+        src = os.path.abspath(src)
+        if not src.startswith(project_root):
+            # Skip anything outside the project
+            continue
+        rel = os.path.relpath(src, project_root)
+        dst = os.path.join(sandbox_root, rel)
+        os.makedirs(os.path.dirname(dst), exist_ok=True)
+        shutil.copy(src, dst)
+
+    sandbox_entry = os.path.join(sandbox_root, os.path.relpath(entry_file, project_root))
+    return sandbox_root, sandbox_entry
+
+
+def apply_sandbox_back(*, sandbox_root: str, project_root: str, changed_paths: list[str]) -> None:
+    """Copy changed sandbox files back into project_root."""
+
+    project_root = os.path.abspath(project_root)
+    for p in changed_paths:
+        p = os.path.abspath(p)
+        if not p.startswith(os.path.abspath(sandbox_root)):
+            continue
+        rel = os.path.relpath(p, sandbox_root)
+        dst = os.path.join(project_root, rel)
+        os.makedirs(os.path.dirname(dst), exist_ok=True)
+        shutil.copy(p, dst)

auto_code_fixer/traceback_utils.py

@@ -0,0 +1,27 @@
+import os
+import re
+
+_FILE_RE = re.compile(r"File \"([^\"]+)\", line (\d+)")
+
+
+def pick_relevant_file(stderr: str, *, sandbox_root: str) -> str | None:
+    """Pick the most relevant python file from a traceback.
+
+    Strategy: return the last file path that lives inside sandbox_root.
+    """
+
+    if not stderr:
+        return None
+
+    sandbox_root = os.path.abspath(sandbox_root)
+    matches = _FILE_RE.findall(stderr)
+    if not matches:
+        return None
+
+    chosen = None
+    for path, _lineno in matches:
+        ap = os.path.abspath(path)
+        if ap.startswith(sandbox_root):
+            chosen = ap
+
+    return chosen

auto_code_fixer/utils.py

@@ -1,6 +1,8 @@
+import ast
 import os
 import re
 from datetime import datetime
+from pathlib import Path
 
 
 VERBOSE = False
@@ -19,26 +21,73 @@ def log(message, level="INFO"):
     print(f"[{timestamp}] {level}: {message}")
 
 
-def find_imports(file_path, project_root):
-    import_pattern = re.compile(r'^\s*(?:from|import)\s+([a-zA-Z0-9_\.]+)')
-    found = set()
+def _module_to_candidate_paths(project_root: str, module: str) -> list[str]:
+    """Resolve a module name to potential local file paths."""
+    base = Path(project_root)
+    parts = module.split(".")
+
+    # module.py
+    p1 = base.joinpath(*parts).with_suffix(".py")
+    # module/__init__.py
+    p2 = base.joinpath(*parts, "__init__.py")
+    return [str(p1), str(p2)]
+
+
+def find_imports(file_path: str, project_root: str) -> list[str]:
+    """AST-based import discovery for local files.
+
+    This is more accurate than regex scanning and supports:
+    - import x
+    - import x.y
+    - from x import y
+    - from x.y import z
+
+    Only resolves modules that map to a file under project_root.
+    """
+
+    found: set[str] = set()
+
+    try:
+        src = Path(file_path).read_text(encoding="utf-8")
+        tree = ast.parse(src)
+    except Exception:
+        # Fallback to regex if parsing fails
+        import_pattern = re.compile(r"^\s*(?:from|import)\s+([a-zA-Z0-9_\.]+)")
+        for line in src.splitlines() if 'src' in locals() else Path(file_path).read_text(encoding='utf-8').splitlines():
+            m = import_pattern.match(line)
+            if not m:
+                continue
+            mod = m.group(1)
+            for c in _module_to_candidate_paths(project_root, mod):
+                if os.path.isfile(c):
+                    found.add(os.path.abspath(c))
+        return sorted(found)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                mod = alias.name
+                for c in _module_to_candidate_paths(project_root, mod):
+                    if os.path.isfile(c):
+                        found.add(os.path.abspath(c))
+
+        if isinstance(node, ast.ImportFrom):
+            if not node.module:
+                continue
+            mod = node.module
+            for c in _module_to_candidate_paths(project_root, mod):
+                if os.path.isfile(c):
+                    found.add(os.path.abspath(c))
+
+    return sorted(found)
+
+
+def discover_all_files(entry_file: str) -> list[str]:
+    """Discover all local python files imported from entry_file."""
 
-    with open(file_path) as f:
-        for line in f:
-            match = import_pattern.match(line)
-            if match:
-                module = match.group(1).split('.')[0]
-                candidate = os.path.join(project_root, module + ".py")
-                if os.path.isfile(candidate):
-                    found.add(os.path.abspath(candidate))
-
-    return list(found)
-
-
-def discover_all_files(entry_file):
     project_root = os.path.dirname(os.path.abspath(entry_file))
     stack = [os.path.abspath(entry_file)]
-    discovered = set()
+    discovered: set[str] = set()
 
     while stack:
         current = stack.pop()
@@ -50,8 +99,8 @@ def discover_all_files(entry_file):
             if f not in discovered:
                 stack.append(f)
 
-    return list(discovered)
+    return sorted(discovered)
 
 
-def is_in_project(file_path, project_root):
+def is_in_project(file_path: str, project_root: str) -> bool:
     return os.path.abspath(file_path).startswith(os.path.abspath(project_root))

auto_code_fixer/venv_manager.py

@@ -0,0 +1,33 @@
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def create_venv(dir_path: str) -> str:
+    """Create a venv and return path to its python executable."""
+    venv_dir = Path(dir_path) / ".venv"
+    if not venv_dir.exists():
+        subprocess.check_call([sys.executable, "-m", "venv", str(venv_dir)])
+
+    # Linux/mac
+    py = venv_dir / "bin" / "python"
+    if py.exists():
+        # ensure pip exists
+        subprocess.check_call([str(py), "-m", "pip", "install", "-U", "pip"], stdout=subprocess.DEVNULL)
+        return str(py)
+
+    # Windows fallback
+    py = venv_dir / "Scripts" / "python.exe"
+    if py.exists():
+        subprocess.check_call([str(py), "-m", "pip", "install", "-U", "pip"], stdout=subprocess.DEVNULL)
+        return str(py)
+
+    raise RuntimeError(f"Could not locate venv python in {venv_dir}")
+
+
+def install_editable(project_root: str, *, python_exe: str) -> None:
+    """Install project (editable) into venv for proper imports."""
+    # Avoid user site-packages contamination
+    env = {**os.environ, "PIP_DISABLE_PIP_VERSION_CHECK": "1"}
+    subprocess.check_call([python_exe, "-m", "pip", "install", "-e", project_root], env=env, stdout=subprocess.DEVNULL)

auto_code_fixer-0.3.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,19 @@
+auto_code_fixer/__init__.py,sha256=VrXpHDu3erkzwl_WXrqINBm9xWkcyUy53IQOj042dOs,22
+auto_code_fixer/cli.py,sha256=tQeFO9ou5JVqM6twFYmG2WQGqI_6ohFRb2qarUpQY1A,8735
+auto_code_fixer/command_runner.py,sha256=6P8hGRavN5C39x-e03p02Vc805NnZH9U7e48ngb5jJI,1104
+auto_code_fixer/fixer.py,sha256=DlAOVbw9AImEKJy8llisVCtss0tXKHMnioYeFBQGXlE,2293
+auto_code_fixer/installer.py,sha256=x5aE-tUGTNoDUCAjtKcv-kKXsExaO7w8L7WoM8bxz9k,1358
+auto_code_fixer/models.py,sha256=JLBJutOoiOjjlT_RMPUPhWlmm1yc_nGcQqv5tY72Al0,317
+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
+auto_code_fixer/sandbox.py,sha256=FWQcCxNDI4i7ckTKHuARSSIHCopBRqG16MVtx9s75R8,1628
+auto_code_fixer/traceback_utils.py,sha256=caxexcBuNj19P0RG-3MtkT4XQeMcFkkgxIzzpG6SGCU,633
+auto_code_fixer/utils.py,sha256=YXCv3PcDo5NBM1odksBTWkHTEELRtEXfPDIORA5iYaM,3090
+auto_code_fixer/venv_manager.py,sha256=2ww8reYgLbLohh-moAD5YKM09qv_mC5yYzJRwm3XiXc,1202
+auto_code_fixer-0.3.0.dist-info/licenses/LICENSE,sha256=hgchJNa26tjXuLztwSUDbYQxNLnAPnLk6kDXNIkC8xc,1066
+auto_code_fixer-0.3.0.dist-info/METADATA,sha256=SUMX84ekb--wwYeNTqL0vw--yyLLRXu5njKNBX189V4,3290
+auto_code_fixer-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+auto_code_fixer-0.3.0.dist-info/entry_points.txt,sha256=a-j2rkfwkrhXZ5Qbz_6_gwk6Bj7nijYR1DALjWp5Myk,61
+auto_code_fixer-0.3.0.dist-info/top_level.txt,sha256=qUk1qznb6Qxqmxy2A3z_5dpOZlmNKHwUiLuJwH-CrAk,16
+auto_code_fixer-0.3.0.dist-info/RECORD,,

auto_code_fixer/guard.py

@@ -1,19 +0,0 @@
-def import_hijacked(original_code: str, fixed_code: str) -> bool:
-    """
-    Detects GPT cheating by replacing imports with try/except fallbacks
-    or inlining local module logic.
-    """
-
-    if "from " not in original_code:
-        return False
-
-    # common cheating patterns
-    bad_patterns = [
-        "try:",
-        "except ImportError",
-        "except ModuleNotFoundError",
-        "def greet(",
-        "def add(",
-    ]
-
-    return any(p in fixed_code for p in bad_patterns)

auto_code_fixer-0.2.5.dist-info/METADATA

@@ -1,51 +0,0 @@
-Metadata-Version: 2.4
-Name: auto-code-fixer
-Version: 0.2.5
-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 automatically detects runtime errors in Python code and fixes them using ChatGPT.
-
-It:
-- Recursively discovers imported local Python files
-- Runs code in an isolated temp environment
-- Auto-installs missing dependencies
-- Iteratively fixes errors using GPT
-- Safely updates files only after successful execution
-
----
-
-## ✨ Features
-
-- 🔍 Recursive import discovery
-- 🧠 GPT-powered auto-fixing
-- 📦 Auto-install missing Python libraries
-- 🔁 Retry & fix loop
-- 🛠 CLI-based (works from anywhere)
-- 🔐 Safe overwrite handling
-
----
-
-## 📦 Installation
-
-### ✅ Recommended (Install from PyPI)
-
-```bash
-pip install auto-code-fixer

auto_code_fixer-0.2.5.dist-info/RECORD

@@ -1,13 +0,0 @@
-auto_code_fixer/__init__.py,sha256=S5Nlc-a2E4VkueiTguk-_xKzhUnSyTj5fGeoME1VKts,23
-auto_code_fixer/cli.py,sha256=cg86GiEuihOHnzqlP0ocEdmpgFtDigQ20pY7oazH-_c,5049
-auto_code_fixer/fixer.py,sha256=Lqb9IQiSvXIo168wv9cE3uyM3F_FVmu681PnnAmCFLI,1767
-auto_code_fixer/guard.py,sha256=Qfyqj2H1VeqBHFQxBkMy-L7Rz6ULXMV3uPAz7IMyTRs,489
-auto_code_fixer/installer.py,sha256=FYPD2r3zJ24MOPDlB_HWOTr2lTXKFLc73vMiQIChsCk,599
-auto_code_fixer/runner.py,sha256=EOQERj9lspNHpDd5QOvoB0XqbCRCed1vu1EAb6nJZsE,763
-auto_code_fixer/utils.py,sha256=ovWyNf3B7xMVq8qjylrPzNhrmLFaHKFF1G0vIp_GGSI,1425
-auto_code_fixer-0.2.5.dist-info/licenses/LICENSE,sha256=hgchJNa26tjXuLztwSUDbYQxNLnAPnLk6kDXNIkC8xc,1066
-auto_code_fixer-0.2.5.dist-info/METADATA,sha256=fJDgSRlKDTuBPzlNwpK3BIMwk1l7_uSwnTujsv3ex9c,1522
-auto_code_fixer-0.2.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-auto_code_fixer-0.2.5.dist-info/entry_points.txt,sha256=a-j2rkfwkrhXZ5Qbz_6_gwk6Bj7nijYR1DALjWp5Myk,61
-auto_code_fixer-0.2.5.dist-info/top_level.txt,sha256=qUk1qznb6Qxqmxy2A3z_5dpOZlmNKHwUiLuJwH-CrAk,16
-auto_code_fixer-0.2.5.dist-info/RECORD,,