Muhammad Faraz Malik
feat: streamline UI to single GitHub Repository URL input and generate full multi-issue repository audit report
89076a2 Download src/agent/nodes.py from MF180/autonomous-bug-fixing-agent: direct link, hf CLI and curl.
- Browser
- Download file 15.4 kB
-
https://huggingface.co/MF180/autonomous-bug-fixing-agent/resolve/main/src/agent/nodes.py
- Command line
-
hf download hf://MF180/autonomous-bug-fixing-agent/src/agent/nodes.py
-
curl -L -o nodes.py https://huggingface.co/MF180/autonomous-bug-fixing-agent/resolve/main/src/agent/nodes.py
15.4 kB
| """Production LangGraph node functions (`src/agent/nodes.py`). | |
| Every node takes `(state: AgentState, config: RunnableConfig)` and returns a partial | |
| state update dict. Dependencies (`llm`, `sandbox_backend`, `commit_in_git`) are read | |
| from `config["configurable"]`, with sensible defaults so tests can inject fakes while | |
| production uses Groq + auto sandbox selection. | |
| """ | |
| from __future__ import annotations | |
| import logging | |
| import re | |
| from typing import Any | |
| from langchain_core.language_models.chat_models import BaseChatModel | |
| from langchain_core.messages import HumanMessage, SystemMessage | |
| from langchain_core.runnables import RunnableConfig | |
| from langgraph.types import interrupt | |
| from agent.llm import ( | |
| DetectedBugProposal, | |
| FixProposal, | |
| ReproTestProposal, | |
| create_groq_llm, | |
| invoke_structured, | |
| invoke_with_backoff, | |
| ) | |
| from agent.prompts import ( | |
| ANALYZE_SYSTEM_PROMPT, | |
| DETECT_BUG_SYSTEM_PROMPT, | |
| FIX_SYSTEM_PROMPT, | |
| REPRO_SYSTEM_PROMPT, | |
| build_fix_user_prompt, | |
| build_repro_user_prompt, | |
| ) | |
| from agent.state import ( | |
| AgentState, | |
| AgentStatus, | |
| ApprovalDecision, | |
| FilePatch, | |
| FixAttempt, | |
| RepoContext, | |
| RepoFinding, | |
| ReproTest, | |
| RunBudget, | |
| SandboxResult, | |
| ) | |
| from sandbox.base import Sandbox | |
| from sandbox.factory import create_sandbox | |
| from tools.file_tools import ( | |
| EditError, | |
| PathEscapeError, | |
| Workspace, | |
| validate_repro_path, | |
| ) | |
| from tools.git_tools import apply_workspace_to_repo | |
| logger = logging.getLogger(__name__) | |
| MAX_RELEVANT_FILES = 4 | |
| MAX_FILE_SNIPPET_CHARS = 2200 | |
| def _get_llm(config: RunnableConfig) -> BaseChatModel: | |
| cfg = config.get("configurable", {}) | |
| if "llm" in cfg and cfg["llm"] is not None: | |
| return cfg["llm"] | |
| return create_groq_llm( | |
| model=cfg.get("groq_model"), | |
| api_key=cfg.get("groq_api_key"), | |
| ) | |
| def _run_in_sandbox(ws: Workspace, command: str, config: RunnableConfig) -> SandboxResult: | |
| cfg = config.get("configurable", {}) | |
| injected: Sandbox | None = cfg.get("sandbox") | |
| if injected is not None: | |
| return injected.run_tests(command) | |
| backend = cfg.get("sandbox_backend", "auto") | |
| with create_sandbox(backend) as sb: | |
| sb.start(ws.work) | |
| return sb.run_tests(command) | |
| def _extract_tokens(text: str) -> list[str]: | |
| words = re.findall(r"[A-Za-z_][A-Za-z0-9_]{2,}", text) | |
| stop = {"the", "and", "for", "with", "that", "this", "from", "returns", "instead", "should", "when"} | |
| return [w for w in dict.fromkeys(words) if w.lower() not in stop] | |
| # --------------------------------------------------------------------------- nodes | |
| def ingest_issue(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Validate issue input, initialize workspace copy and budget.""" | |
| issue = state["issue"] | |
| budget = state.get("budget") or RunBudget() | |
| ws_root = state.get("workspace_root") | |
| if not ws_root: | |
| ws = Workspace.create(issue.repo_path) | |
| ws_root = str(ws.root) | |
| return { | |
| "budget": budget, | |
| "iteration": state.get("iteration", 0), | |
| "repro_attempts": state.get("repro_attempts", 0), | |
| "workspace_root": ws_root, | |
| "status": AgentStatus.INGESTED, | |
| } | |
| def inspect_repo(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Build directory tree and pick the top relevant Python files for the issue.""" | |
| ws = Workspace.open(state["workspace_root"]) | |
| issue = state["issue"] | |
| tree = ws.list_tree() | |
| tokens = _extract_tokens(f"{issue.title}\n{issue.body}") | |
| grep_hits = ws.grep_counts(tokens) | |
| py_files = ws.list_python_files() | |
| # Prefer source files over tests when ranking relevance, then fall back to all .py files | |
| ranked = sorted( | |
| py_files, | |
| key=lambda p: ( | |
| 0 if not (p.startswith("test") or "/test" in p or p.endswith("_test.py")) else 1, | |
| -grep_hits.get(p, 0), | |
| len(p), | |
| ), | |
| ) | |
| selected = ranked[:MAX_RELEVANT_FILES] | |
| relevant = {p: ws.read(p, max_chars=MAX_FILE_SNIPPET_CHARS) for p in selected} | |
| repo = RepoContext( | |
| tree=tree, | |
| relevant_files=relevant, | |
| test_command="pytest -q -p no:cacheprovider", | |
| language="python", | |
| ) | |
| # If the user left the default calc.py sample issue on a custom repository that has no calc.py, | |
| # or requested auto-detection, let the LLM audit the repo and formulate a real testable issue. | |
| updates: dict[str, Any] = {"repo": repo, "status": AgentStatus.INSPECTED} | |
| has_calc = any(p.endswith("calc.py") for p in py_files) | |
| is_default_calc_issue = "average()" in issue.title and "calc.average" in issue.body | |
| wants_auto = issue.title.strip().lower().startswith("auto") or ( | |
| is_default_calc_issue and not has_calc and bool(relevant) | |
| ) | |
| if wants_auto: | |
| try: | |
| llm = _get_llm(config) | |
| files_block = "\n\n".join( | |
| f"### File: `{p}`\n```python\n{src}\n```" for p, src in relevant.items() | |
| ) | |
| detected = invoke_structured( | |
| llm, | |
| DetectedBugProposal, | |
| DETECT_BUG_SYSTEM_PROMPT, | |
| f"Repository Tree:\n```\n{tree}\n```\n\nSource Files:\n{files_block}", | |
| ) | |
| updates["issue"] = issue.model_copy( | |
| update={"title": detected.title, "body": detected.body} | |
| ) | |
| if detected.file_path in py_files and detected.file_path not in relevant: | |
| relevant[detected.file_path] = ws.read( | |
| detected.file_path, max_chars=MAX_FILE_SNIPPET_CHARS | |
| ) | |
| findings = list(detected.findings) if detected.findings else [ | |
| RepoFinding( | |
| severity="High", | |
| file_path=detected.file_path, | |
| title=detected.title, | |
| description=detected.body, | |
| suggested_fix="Apply automated search/replace fix verified by pytest.", | |
| ) | |
| ] | |
| repo = repo.model_copy(update={"relevant_files": relevant, "findings": findings}) | |
| updates["repo"] = repo | |
| except Exception as exc: # noqa: BLE001 | |
| logger.warning("Auto-detect bug fallback skipped: %s", exc) | |
| if not updates["repo"].findings: | |
| primary_file = next(iter(relevant.keys()), "repository") | |
| updates["repo"] = updates["repo"].model_copy( | |
| update={ | |
| "findings": [ | |
| RepoFinding( | |
| severity="High", | |
| file_path=primary_file, | |
| title=updates.get("issue", issue).title, | |
| description=updates.get("issue", issue).body, | |
| suggested_fix="Apply targeted code fix and verify with regression test.", | |
| ) | |
| ] | |
| } | |
| ) | |
| return updates | |
| def write_repro_test(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Ask the LLM to write a minimal failing pytest reproduction test.""" | |
| ws = Workspace.open(state["workspace_root"]) | |
| llm = _get_llm(config) | |
| prev_out = "" | |
| if state.get("repro_result") is not None: | |
| r = state["repro_result"] | |
| prev_out = f"{r.stdout}\n{r.stderr}".strip() | |
| user_prompt = build_repro_user_prompt(state, last_repro_stdout=prev_out) | |
| proposal = invoke_structured(llm, ReproTestProposal, REPRO_SYSTEM_PROMPT, user_prompt) | |
| try: | |
| rel_path = validate_repro_path(proposal.path) | |
| except PathEscapeError: | |
| rel_path = "test_repro_bug.py" | |
| ws.write(rel_path, proposal.content) | |
| repro = ReproTest(path=rel_path, content=proposal.content, confirmed_failing=False) | |
| return { | |
| "repro_test": repro, | |
| "repro_attempts": state.get("repro_attempts", 0) + 1, | |
| "status": AgentStatus.REPRO_WRITTEN, | |
| } | |
| def run_repro_test(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Run the reproduction test in the sandbox. We expect it to FAIL on buggy code.""" | |
| ws = Workspace.open(state["workspace_root"]) | |
| repro = state["repro_test"] | |
| cmd = f"pytest -q -p no:cacheprovider {repro.path}" | |
| res = _run_in_sandbox(ws, cmd, config) | |
| # Exit code 1 = tests collected and failed (desired). Exit codes 2/3/4 = syntax/import error. | |
| confirmed = (not res.passed) and (not res.timed_out) and res.exit_code == 1 | |
| updated = repro.model_copy(update={"confirmed_failing": confirmed}) | |
| return { | |
| "repro_test": updated, | |
| "repro_result": res, | |
| "status": AgentStatus.REPRO_CONFIRMED if confirmed else AgentStatus.REPRO_WRITTEN, | |
| } | |
| def propose_fix(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Reset working copy to baseline and ask the LLM for search/replace edits.""" | |
| ws = Workspace.open(state["workspace_root"]) | |
| ws.reset() # Always propose edits against clean baseline files | |
| current_files = { | |
| p: ws.read(p, max_chars=MAX_FILE_SNIPPET_CHARS) | |
| for p in state["repo"].relevant_files | |
| if ws.exists(p) | |
| } | |
| llm = _get_llm(config) | |
| user_prompt = build_fix_user_prompt(state, current_files) | |
| proposal = invoke_structured(llm, FixProposal, FIX_SYSTEM_PROMPT, user_prompt) | |
| next_iter = state.get("iteration", 0) + 1 | |
| attempt = FixAttempt( | |
| iteration=next_iter, | |
| rationale=proposal.rationale, | |
| edits=proposal.edits, | |
| ) | |
| return { | |
| "attempts": [attempt], | |
| "status": AgentStatus.FIXING, | |
| } | |
| def apply_fix(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Apply the latest attempt's search/replace edits in the workspace and compute unified diffs.""" | |
| ws = Workspace.open(state["workspace_root"]) | |
| ws.reset() | |
| latest = state["attempts"][-1] | |
| repro = state.get("repro_test") | |
| for edit in latest.edits: | |
| if repro and edit.path.replace("\\", "/") == repro.path: | |
| updated = latest.model_copy( | |
| update={"patch_error": f"Refusing to modify reproduction test {repro.path!r}"} | |
| ) | |
| return {"attempts": [updated], "iteration": latest.iteration} | |
| try: | |
| modified = ws.apply_edits(latest.edits) | |
| except (EditError, PathEscapeError) as exc: | |
| updated = latest.model_copy(update={"patch_error": str(exc)}) | |
| return {"attempts": [updated], "iteration": latest.iteration} | |
| patches = [ | |
| FilePatch(path=rel, unified_diff=ws.diff(rel)) | |
| for rel in modified | |
| if ws.diff(rel).strip() | |
| ] | |
| if not patches: | |
| updated = latest.model_copy(update={"patch_error": "Edits produced no net change."}) | |
| return {"attempts": [updated], "iteration": latest.iteration} | |
| updated = latest.model_copy(update={"patches": patches, "patch_error": None}) | |
| return {"attempts": [updated]} | |
| def run_tests(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Run the reproduction test + full test suite inside the sandbox.""" | |
| ws = Workspace.open(state["workspace_root"]) | |
| latest = state["attempts"][-1] | |
| res = _run_in_sandbox(ws, state["repo"].test_command, config) | |
| updated = latest.model_copy(update={"result": res}) | |
| return { | |
| "attempts": [updated], | |
| "iteration": latest.iteration, | |
| "status": AgentStatus.TESTS_PASSING if res.passed else AgentStatus.FIXING, | |
| } | |
| def analyze_failure(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Produce a short failure diagnosis for the next `propose_fix` iteration.""" | |
| approval = state.get("approval") | |
| if approval and not approval.approved and approval.feedback: | |
| return { | |
| "diagnosis": f"Reviewer requested changes: {approval.feedback}", | |
| "approval": None, | |
| } | |
| latest = state["attempts"][-1] | |
| if latest.patch_error: | |
| return { | |
| "diagnosis": ( | |
| f"Attempt {latest.iteration} edits could not be applied: {latest.patch_error}. " | |
| "Copy `search` blocks verbatim from the baseline file." | |
| ) | |
| } | |
| out = "" | |
| if latest.result: | |
| out = (latest.result.stdout + "\n" + latest.result.stderr).strip()[ | |
| -state["budget"].max_tool_output_chars : | |
| ] | |
| try: | |
| llm = _get_llm(config) | |
| msg = invoke_with_backoff( | |
| llm, | |
| [ | |
| SystemMessage(content=ANALYZE_SYSTEM_PROMPT), | |
| HumanMessage( | |
| content=( | |
| f"Issue: {state['issue'].title}\n" | |
| f"Attempt {latest.iteration} rationale: {latest.rationale}\n" | |
| f"Test output:\n{out}" | |
| ) | |
| ), | |
| ], | |
| ) | |
| text = msg.content if isinstance(msg.content, str) else str(msg.content) | |
| except Exception: # noqa: BLE001 | |
| text = f"Attempt {latest.iteration} failed tests; inspect assertion output and adjust logic." | |
| return {"diagnosis": text.strip()[:600]} | |
| def human_approval(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Pause the graph with `interrupt()` for human review before any git commit.""" | |
| attempt = state["attempts"][-1] | |
| decision = interrupt( | |
| { | |
| "iteration": attempt.iteration, | |
| "rationale": attempt.rationale, | |
| "diff": "\n".join(p.unified_diff for p in attempt.patches), | |
| "test_output": (attempt.result.stdout + "\n" + attempt.result.stderr).strip() | |
| if attempt.result | |
| else "", | |
| "repro_test": state["repro_test"].content, | |
| } | |
| ) | |
| approval = ApprovalDecision.model_validate(decision) | |
| return { | |
| "approval": approval, | |
| "status": AgentStatus.APPROVED if approval.approved else AgentStatus.REJECTED, | |
| } | |
| def commit_and_pr(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Commit approved changes (reachable ONLY after `human_approval`).""" | |
| ws = Workspace.open(state["workspace_root"]) | |
| issue = state["issue"] | |
| cfg = config.get("configurable", {}) | |
| commit_in_git = bool(cfg.get("commit_in_git", False)) | |
| slug = f"agent/fix-{issue.number or 'issue'}" | |
| msg = f"Fix: {issue.title}" | |
| res = apply_workspace_to_repo( | |
| ws, | |
| issue.repo_path, | |
| branch_name=slug, | |
| commit_message=msg, | |
| commit_in_git=commit_in_git, | |
| ) | |
| return { | |
| "branch": res.branch, | |
| "commit_sha": res.commit_sha, | |
| "pr_url": res.pr_url, | |
| "status": AgentStatus.COMMITTED, | |
| } | |
| def escalate(state: AgentState, config: RunnableConfig) -> dict[str, Any]: | |
| """Terminal failure handler when reproduction or fix iterations are exhausted, or rejected.""" | |
| approval = state.get("approval") | |
| repro = state.get("repro_test") | |
| if approval is not None and not approval.approved and not approval.feedback: | |
| reason = "Human reviewer rejected the proposed fix." | |
| elif repro is not None and not repro.confirmed_failing: | |
| reason = ( | |
| f"Could not reproduce the bug with a failing pytest test after " | |
| f"{state.get('repro_attempts', 0)} attempt(s)." | |
| ) | |
| else: | |
| reason = ( | |
| f"Exhausted {state.get('iteration', 0)}/{state['budget'].max_iterations} " | |
| "fix iterations without all tests passing." | |
| ) | |
| return {"error": reason, "status": AgentStatus.ESCALATED} | |