autonomous-bug-fixing-agent / src /ui /streamlit_app.py
Muhammad Faraz Malik
feat(llm): add Amazon Bedrock Converse multi-cloud LLM provider alongside Groq
bd6aedd
Raw History Blame Contribute Delete
30.5 kB
"""Streamlit front-end for the Autonomous Bug-Fixing Agent.
Supports:
- **Live Agent (Groq LLM + Sandbox):** runs the real LangGraph pipeline against the built-in
sample buggy repo, any local repository path, or any GitHub repository URL (shallow-cloned
into an isolated temp workspace).
- **Scripted Demo Mode:** deterministic walkthrough with zero API calls.
Run: streamlit run src/ui/streamlit_app.py
"""
from __future__ import annotations
import importlib
import os
import sys
import time
import uuid
from pathlib import Path
from typing import Any
# Ensure `src/` is on sys.path when launched directly on Streamlit Community Cloud
_SRC_DIR = str(Path(__file__).resolve().parents[1])
if _SRC_DIR not in sys.path:
sys.path.insert(0, _SRC_DIR)
# Hot-reload guard for Streamlit Community Cloud: if an older commit's modules are cached
# in `sys.modules` across a live GitHub push, reload them in dependency order.
if "agent.state" in sys.modules and not hasattr(sys.modules["agent.state"], "RepoFinding"):
for _mod in (
"agent.state",
"tools.file_tools",
"tools.git_tools",
"agent.prompts",
"agent.llm",
"agent.nodes",
"agent.graph",
"ui.mock_graph",
"ui.report_pdf",
):
if _mod in sys.modules:
importlib.reload(sys.modules[_mod])
import streamlit as st
from langgraph.types import Command
from agent.graph import build_graph
from agent.llm import (
AVAILABLE_GROQ_MODELS,
default_groq_api_key,
load_dotenv_into_environ,
resolve_groq_model,
)
from agent.state import AgentState, FixAttempt, IssueInput, initial_state
from sandbox.docker_runner import DockerSandbox
from tools.aws_tools import (
archive_run_to_aws,
is_aws_configured,
list_runs_from_dynamodb,
)
from tools.file_tools import (
Workspace,
WorkspaceError,
clone_repo_to_temp,
create_repo_from_uploads,
)
from tools.git_tools import (
GitError,
create_github_pull_request,
fetch_github_issue,
parse_github_issue_url,
parse_github_owner_repo,
)
from ui.mock_graph import (
DEMO_ISSUE_BODY,
DEMO_ISSUE_TITLE,
build_mock_graph,
)
from ui.report_pdf import generate_pdf_report
def _load_streamlit_secrets() -> None:
"""Copy `st.secrets` keys (`GROQ_API_KEY`, `SANDBOX_BACKEND`, etc.) into `os.environ`."""
try:
for k in (
"GROQ_API_KEY",
"GROQ_MODEL",
"SANDBOX_BACKEND",
"CHECKPOINTER",
"DATABASE_URL",
"AWS_S3_BUCKET",
"AWS_DYNAMODB_TABLE",
"AWS_REGION",
):
if k in st.secrets and not os.environ.get(k):
os.environ[k] = str(st.secrets[k])
except Exception: # noqa: BLE001
pass
load_dotenv_into_environ()
_load_streamlit_secrets()
FIXTURE_REPO = Path(__file__).resolve().parents[2] / "tests" / "fixtures" / "buggy_repo"
STEP_LABELS = {
"ingest_issue": "Ingest issue & prepare workspace",
"inspect_repo": "Inspect repository & rank relevant files",
"write_repro_test": "Write reproduction test (Groq LLM)",
"run_repro_test": "Run reproduction test (expect failure)",
"propose_fix": "Propose code fix (Groq LLM)",
"apply_fix": "Apply search/replace edits & compute diff",
"run_tests": "Run test suite in sandbox",
"analyze_failure": "Analyze failure / reviewer feedback",
"human_approval": "Human-in-the-loop approval",
"commit_and_pr": "Commit approved patch",
"escalate": "Escalate",
}
@st.cache_resource
def get_live_graph(_version: str = "v3"):
return build_graph()
@st.cache_resource
def get_demo_graph(_version: str = "v3"):
return build_mock_graph()
def _active_graph():
return get_demo_graph() if st.session_state.get("run_mode") == "demo" else get_live_graph()
def _config() -> dict[str, Any]:
return {
"configurable": {
"thread_id": st.session_state.thread_id,
"delay": st.session_state.get("delay", 0.3),
"groq_model": st.session_state.get("groq_model"),
"groq_api_key": st.session_state.get("groq_api_key") or None,
"sandbox_backend": st.session_state.get("sandbox_backend", "auto"),
"commit_in_git": False,
}
}
# ------------------------------------------------------------------------ running
def advance(payload: AgentState | Command) -> None:
"""Stream the active graph until it pauses at `interrupt()` or finishes, then rerun."""
graph = _active_graph()
t0 = time.perf_counter()
try:
with st.status("Agent running...", expanded=True) as status:
for chunk in graph.stream(payload, _config(), stream_mode="updates"):
for node, update in chunk.items():
if node.startswith("__"):
continue
st.session_state.log.append((node, update or {}))
status.update(label=f"Ran: {STEP_LABELS.get(node, node)}")
st.write(f"βœ… {STEP_LABELS.get(node, node)}")
status.update(label="Agent paused or finished", state="complete", expanded=False)
except Exception as exc:
st.session_state.last_error = str(exc)
st.session_state.elapsed_s = round(
st.session_state.get("elapsed_s", 0.0) + (time.perf_counter() - t0), 2
)
st.rerun()
def start_run(
*,
mode: str,
repo_source: str,
repo_input: str,
uploaded_files: list[tuple[str, bytes]] | None = None,
issue_title: str,
issue_body: str,
issue_url: str | None = None,
issue_number: int | None = None,
) -> None:
st.session_state.last_error = None
st.session_state.run_mode = mode
st.session_state.thread_id = f"{mode}-{uuid.uuid4().hex[:8]}"
st.session_state.log = []
st.session_state.elapsed_s = 0.0
if mode == "demo":
issue = IssueInput(title=issue_title, body=issue_body, repo_path=Path("demo-repo"))
advance(initial_state(issue))
return
try:
if repo_source == "Built-in sample buggy repo":
target_path = FIXTURE_REPO
elif repo_source == "Upload .zip or .py files":
target_path = create_repo_from_uploads(uploaded_files or [])
elif repo_source == "GitHub URL (shallow clone)":
with st.spinner(f"Cloning {repo_input.strip()}..."):
target_path = clone_repo_to_temp(repo_input)
st.session_state.repo_github_url = repo_input.strip()
else:
st.session_state.repo_github_url = ""
target_path = Path(repo_input.strip()).expanduser().resolve()
if not target_path.is_dir():
raise WorkspaceError(f"Local folder does not exist: {target_path}")
if repo_source != "GitHub URL (shallow clone)":
st.session_state.repo_github_url = ""
except Exception as exc:
st.session_state.last_error = str(exc)
return
issue = IssueInput(
title=issue_title.strip(),
body=issue_body.strip(),
url=issue_url,
number=issue_number,
repo_path=target_path,
)
advance(initial_state(issue))
# ---------------------------------------------------------------------- rendering
def render_event(node: str, update: dict[str, Any]) -> None:
label = STEP_LABELS.get(node, node)
attempts: list[FixAttempt] = update.get("attempts", [])
if node == "propose_fix" and attempts:
a = attempts[-1]
with st.expander(f"πŸ› οΈ {label} (attempt {a.iteration})", expanded=False):
st.write(a.rationale)
if a.patches:
st.code("\n".join(p.unified_diff for p in a.patches), language="diff")
elif a.edits:
for edit in a.edits:
st.caption(f"Edit `{edit.path}`")
st.code(f"- {edit.search}\n+ {edit.replace}", language="diff")
elif node == "apply_fix" and attempts:
a = attempts[-1]
if a.patch_error:
st.write(f"⚠️ {label}: {a.patch_error}")
elif a.patches:
with st.expander(f"🩹 {label} (attempt {a.iteration})", expanded=False):
st.code("\n".join(p.unified_diff for p in a.patches), language="diff")
elif node == "run_tests" and attempts:
a = attempts[-1]
icon = "🟒" if a.result and a.result.passed else "πŸ”΄"
with st.expander(f"{icon} {label} (attempt {a.iteration})", expanded=False):
out = ""
if a.result:
out = (a.result.stdout + "\n" + a.result.stderr).strip()
st.code(out, language="text")
elif node == "write_repro_test" and "repro_test" in update:
with st.expander(f"πŸ§ͺ {label} (`{update['repro_test'].path}`)", expanded=False):
st.code(update["repro_test"].content, language="python")
elif node == "inspect_repo" and "repo" in update:
if "issue" in update:
det = update["issue"]
st.info(f"πŸ” **Auto-detected bug in repository:** {det.title}\n\n{det.body}")
with st.expander(f"πŸ”Ž {label}", expanded=False):
for path, src in update["repo"].relevant_files.items():
st.caption(path)
st.code(src, language="python")
elif node == "run_repro_test":
repro = update.get("repro_test")
ok = repro.confirmed_failing if repro else True
verdict = "bug reproduced (failed as expected)" if ok else "did not fail as expected"
st.write(f"βœ… {label}: {verdict}")
elif node == "analyze_failure":
diag = update.get("diagnosis") or "feeding the failure back into the next attempt"
st.write(f"πŸ” {label}: {diag}")
elif node == "human_approval":
approval = update.get("approval")
verdict = "approved" if approval and approval.approved else "changes requested / rejected"
st.write(f"πŸ§‘ {label}: {verdict}")
if approval and approval.feedback:
st.caption(f"Feedback: {approval.feedback}")
else:
st.write(f"βœ… {label}")
def _render_report_download(values: dict[str, Any], key_suffix: str) -> None:
try:
pdf_bytes = generate_pdf_report(values)
st.download_button(
"πŸ“„ Download PDF Bug & Fix Report",
data=pdf_bytes,
file_name="bugfix-report.pdf",
mime="application/pdf",
key=f"pdf-{key_suffix}",
)
if is_aws_configured() and st.session_state.get("thread_id"):
archive_key = f"aws_archive_{st.session_state.thread_id}_{values.get('status')}"
if archive_key not in st.session_state:
zip_bytes = None
ws_root = values.get("workspace_root")
if ws_root:
try:
zip_bytes = Workspace.open(ws_root).export_zip_bytes()
except Exception: # noqa: BLE001
zip_bytes = None
st.session_state[archive_key] = archive_run_to_aws(
st.session_state.thread_id,
values,
pdf_bytes=pdf_bytes,
zip_bytes=zip_bytes,
)
arc = st.session_state[archive_key]
if arc.s3_pdf_url:
st.caption(
f"☁️ Archived to Amazon S3 (`s3://{arc.s3_bucket}/{arc.s3_pdf_key}`) · "
f"[Open S3 Pre-Signed PDF Report]({arc.s3_pdf_url})"
)
if arc.dynamodb_saved:
st.caption("βœ… Run metadata persisted to Amazon DynamoDB (`BugFixAgentRuns`)")
except Exception as exc: # noqa: BLE001
st.caption(f"Could not generate PDF report: {exc}")
def _render_zip_download(values: dict[str, Any], key_suffix: str) -> None:
ws_root = values.get("workspace_root")
if not ws_root:
return
try:
zip_bytes = Workspace.open(ws_root).export_zip_bytes()
st.download_button(
"πŸ“¦ Download Fixed Repo (.zip)",
data=zip_bytes,
file_name="fixed-repository.zip",
mime="application/zip",
key=f"zip-{key_suffix}",
use_container_width=True,
)
except Exception as exc: # noqa: BLE001
st.caption(f"Could not export repository zip: {exc}")
def _split_diff_before_after(diff_text: str) -> tuple[str, str]:
"""Extract readable Before vs. After code blocks from a unified diff."""
before_lines: list[str] = []
after_lines: list[str] = []
for line in diff_text.splitlines():
if line.startswith(("---", "+++", "@@")):
continue
if line.startswith("-"):
before_lines.append(line[1:])
elif line.startswith("+"):
after_lines.append(line[1:])
elif line.startswith(" "):
before_lines.append(line[1:])
after_lines.append(line[1:])
else:
before_lines.append(line)
after_lines.append(line)
return "\n".join(before_lines), "\n".join(after_lines)
def _render_code_comparison(diff_text: str, values: dict[str, Any]) -> None:
"""Render tabbed Unified Diff + Side-by-Side Before/After view."""
tab_diff, tab_split = st.tabs(["πŸ”€ Unified Diff", "πŸ“Š Side-by-Side (Before vs. After)"])
with tab_diff:
st.code(diff_text, language="diff")
with tab_split:
ws_root = values.get("workspace_root")
rendered_files = False
if ws_root:
try:
ws = Workspace.open(ws_root)
for rel in ws.changed_files():
base_src = ws.read_baseline(rel)
if base_src is None:
continue # skip newly added test files; show modified source files
new_src = ws.read(rel)
st.caption(f"File: `{rel}`")
col_b, col_a = st.columns(2)
with col_b:
st.markdown("**Before (Baseline)**")
st.code(base_src, language="python")
with col_a:
st.markdown("**After (Fixed)**")
st.code(new_src, language="python")
rendered_files = True
except Exception: # noqa: BLE001
rendered_files = False
if not rendered_files:
before_txt, after_txt = _split_diff_before_after(diff_text)
col_b, col_a = st.columns(2)
with col_b:
st.markdown("**Before (Baseline)**")
st.code(before_txt, language="python")
with col_a:
st.markdown("**After (Fixed)**")
st.code(after_txt, language="python")
def _compute_telemetry(
values: dict[str, Any], log: list[tuple[str, dict[str, Any]]]
) -> dict[str, str]:
"""Compute live run telemetry (LLM calls, sandbox test runs, est. tokens, elapsed time)."""
llm_nodes = {"write_repro_test", "propose_fix", "analyze_failure"}
llm_calls = sum(1 for n, u in log if n in llm_nodes or (n == "inspect_repo" and "issue" in u))
sandbox_runs = sum(1 for n, _ in log if n in {"run_repro_test", "run_tests"})
total_chars = 0
if values.get("issue"):
total_chars += len(values["issue"].title) + len(values["issue"].body)
if values.get("repo"):
total_chars += sum(len(v) for v in values["repo"].relevant_files.values())
if values.get("repro_test"):
total_chars += len(values["repro_test"].content)
for att in values.get("attempts") or []:
total_chars += len(att.rationale) + sum(len(p.unified_diff) for p in att.patches)
est_tokens = max(120, (total_chars // 4) * max(1, llm_calls))
elapsed = st.session_state.get("elapsed_s", 0.0)
return {
"iterations": f"{values.get('iteration', 0)} / 8",
"llm_calls": str(llm_calls),
"sandbox_runs": str(sandbox_runs),
"est_tokens": f"~{est_tokens:,}",
"elapsed": f"{elapsed:.1f}s",
}
def render_approval(payload: dict[str, Any], values: dict[str, Any]) -> None:
st.subheader("⏸️ Waiting for your approval")
st.caption(
"The agent is paused by a LangGraph `interrupt()`. "
"Nothing is committed until you approve."
)
st.markdown(f"**Fix proposed (iteration {payload['iteration']}):** {payload['rationale']}")
_render_code_comparison(payload["diff"], values)
st.markdown("**Test results**")
st.code(payload["test_output"], language="text")
with st.expander("Reproduction test"):
st.code(payload["repro_test"], language="python")
dl1, dl2 = st.columns(2)
with dl1:
_render_report_download(values, key_suffix=f"approval-{payload['iteration']}")
with dl2:
_render_zip_download(values, key_suffix=f"approval-{payload['iteration']}")
feedback = st.text_area(
"Feedback for the agent (required to request changes)",
key=f"fb-{payload['iteration']}",
placeholder="e.g. handle the empty-list case",
)
approve, changes, reject = st.columns(3)
if approve.button("βœ… Approve", type="primary", use_container_width=True):
advance(Command(resume={"approved": True, "reviewer": "user"}))
if changes.button("✏️ Request changes", use_container_width=True):
if feedback.strip():
advance(
Command(
resume={
"approved": False,
"feedback": feedback.strip(),
"reviewer": "user",
}
)
)
else:
st.warning("Add feedback so the agent knows what to change.")
if reject.button("β›” Reject", use_container_width=True):
advance(Command(resume={"approved": False, "reviewer": "user"}))
def render_outcome(values: dict[str, Any]) -> None:
status = str(values.get("status"))
is_demo = st.session_state.get("run_mode") == "demo"
if status == "committed":
note = "Demo commit" if is_demo else "Approved commit"
st.success(
f"{note} `{values['commit_sha']}` on `{values['branch']}` "
"(download the fixed repository `.zip`, unified `.patch`, or PDF report below, "
"or push a Pull Request directly to GitHub)."
)
attempts: list[FixAttempt] = values["attempts"]
patch = "\n".join(p.unified_diff for p in attempts[-1].patches)
if values.get("workspace_root"):
try:
patch = Workspace.open(values["workspace_root"]).full_diff() or patch
except Exception: # noqa: BLE001
pass
col1, col2, col3 = st.columns(3)
with col1:
st.download_button(
"⬇️ Download patch (.patch)",
patch,
file_name="fix.patch",
use_container_width=True,
)
with col2:
_render_zip_download(values, key_suffix="committed")
with col3:
_render_report_download(values, key_suffix="committed")
# One-click GitHub Pull Request creation (for live runs)
if not is_demo and values.get("workspace_root"):
with st.expander("πŸš€ Push Branch & Open GitHub Pull Request", expanded=bool(st.session_state.get("repo_github_url"))):
default_gh_url = st.session_state.get("repo_github_url") or (values.get("issue").url if values.get("issue") else "") or ""
gh_url = st.text_input(
"Target GitHub Repository URL",
value=default_gh_url,
placeholder="https://github.com/owner/repo",
key="pr-repo-url",
)
gh_token = st.text_input(
"GitHub Personal Access Token (`repo` scope β€” session-only, never stored)",
value=os.environ.get("GITHUB_TOKEN", ""),
type="password",
placeholder="ghp_... or github_pat_...",
key="pr-gh-token",
)
if st.button("πŸš€ Create Branch & Open Pull Request on GitHub", type="primary"):
if not parse_github_owner_repo(gh_url):
st.error("Please enter a valid GitHub repository URL (`https://github.com/owner/repo`).")
elif not gh_token.strip():
st.error("Please enter a GitHub Personal Access Token with write access to the repository.")
else:
try:
with st.spinner("Creating branch, committing files, and opening Pull Request..."):
ws = Workspace.open(values["workspace_root"])
issue_obj = values["issue"]
pr_res = create_github_pull_request(
ws,
repo_url=gh_url,
github_token=gh_token,
issue_title=issue_obj.title,
issue_body=issue_obj.body,
rationale=attempts[-1].rationale,
)
st.success(f"πŸŽ‰ Pull Request opened on `{pr_res.branch}`: {pr_res.pr_url}")
if pr_res.pr_url:
st.link_button("πŸ”— View Pull Request on GitHub", pr_res.pr_url)
except GitError as exc:
st.error(f"GitHub PR error: {exc}")
elif status == "escalated":
st.error(f"Escalated: {values.get('error')}")
_render_report_download(values, key_suffix="escalated")
def _render_findings_report(values: dict[str, Any]) -> None:
"""Render the complete multi-issue repository audit report covering all detected issues."""
repo_ctx = values.get("repo")
findings = list(repo_ctx.findings) if repo_ctx and getattr(repo_ctx, "findings", None) else []
if not findings:
return
badge_map = {
"Critical": "πŸ”΄ **CRITICAL**",
"High": "🟠 **HIGH**",
"Medium": "🟑 **MEDIUM**",
"Low": "πŸ”΅ **LOW**",
}
st.subheader(f"πŸ“‹ Repository Issues Report ({len(findings)} Issue(s) Found)")
for idx, f in enumerate(findings, start=1):
badge = badge_map.get(f.severity, f"🟠 **{f.severity.upper()}**")
with st.expander(f"Issue #{idx}: {badge} β€” `{f.file_path}` Β· {f.title}", expanded=True):
st.markdown(f"**Root Cause / Details:** {f.description}")
if f.suggested_fix:
st.markdown(f"**Recommended Fix:** {f.suggested_fix}")
_render_report_download(values, key_suffix="audit-top")
st.divider()
# --------------------------------------------------------------------------- page
def main() -> None:
st.set_page_config(page_title="Autonomous Bug-Fixing Agent", page_icon="🐞", layout="wide")
st.session_state.setdefault("thread_id", None)
st.session_state.setdefault("log", [])
st.session_state.setdefault("delay", 0.3)
st.session_state.setdefault("run_mode", "demo")
st.session_state.setdefault("last_error", None)
st.session_state.setdefault("groq_model", resolve_groq_model())
st.session_state.setdefault("groq_api_key", "")
st.session_state.setdefault("sandbox_backend", "auto")
st.title("🐞 Autonomous Bug-Fixing Agent")
docker_up = DockerSandbox.is_available()
has_env_key = bool(default_groq_api_key())
has_any_key = has_env_key or bool(st.session_state.get("groq_api_key", "").strip())
with st.sidebar:
st.header("Scan GitHub Repository")
repo_input = st.text_input(
"GitHub Repository URL",
placeholder="https://github.com/owner/repo",
help="Paste any public GitHub repository URL. Leave blank to scan the built-in sample buggy repository.",
)
with st.expander("βš™οΈ Advanced Settings", expanded=False):
mode_choice = st.radio(
"Agent backend",
options=["Live Groq Agent", "Scripted Demo (no API calls)"],
index=0 if has_any_key else 1,
)
is_demo_choice = mode_choice.startswith("Scripted")
model_options = list(AVAILABLE_GROQ_MODELS)
default_idx = (
model_options.index(st.session_state.groq_model)
if st.session_state.groq_model in model_options
else 0
)
st.session_state.groq_model = st.selectbox(
"LLM Model (Groq or AWS Bedrock)",
options=model_options,
index=default_idx,
)
st.session_state.groq_api_key = st.text_input(
"Groq API Key override (optional if set in .env or using Bedrock)",
value=st.session_state.groq_api_key,
type="password",
placeholder="Using GROQ_API_KEY from .env" if has_env_key else "gsk_...",
)
st.session_state.sandbox_backend = st.selectbox(
"Sandbox backend",
options=["auto", "local", "docker"],
index=0,
help=f"Docker daemon reachable: {docker_up}",
)
st.slider("Demo step delay (s)", 0.0, 1.5, key="delay", step=0.1)
is_bedrock_model = str(st.session_state.get("groq_model", "")).startswith("bedrock/")
if not is_demo_choice and not has_any_key and not is_bedrock_model:
st.session_state.groq_api_key = st.text_input(
"πŸ”‘ Groq API Key (required for Live Groq mode)",
value=st.session_state.groq_api_key,
type="password",
placeholder="gsk_...",
)
if st.button("▢️ Start run", type="primary", use_container_width=True):
clean_url = repo_input.strip()
effective_source = (
"GitHub URL (shallow clone)" if clean_url else "Built-in sample buggy repo"
)
effective_repo_input = clean_url
effective_title = (
"Auto-detect all issues in repository" if clean_url else DEMO_ISSUE_TITLE
)
effective_body = (
"Scan repository files, report all bugs and defects found across the repository, "
"write a failing pytest reproduction test for the primary bug, and fix it."
if clean_url
else DEMO_ISSUE_BODY
)
effective_url: str | None = None
effective_num: int | None = None
if clean_url and not is_demo_choice:
try:
fetched = fetch_github_issue(clean_url)
effective_repo_input = fetched.repo_clone_url
effective_url = fetched.html_url
effective_num = fetched.number
if not fetched.auto_detect and fetched.title:
effective_title = fetched.title
effective_body = fetched.body or fetched.title
except Exception: # noqa: BLE001
pass
start_run(
mode="demo" if is_demo_choice else "live",
repo_source=effective_source,
repo_input=effective_repo_input,
issue_title=effective_title,
issue_body=effective_body,
issue_url=effective_url,
issue_number=effective_num,
)
if is_aws_configured():
with st.expander("☁️ AWS Cloud History (DynamoDB & S3)", expanded=False):
runs = list_runs_from_dynamodb(limit=8)
if not runs:
st.caption("No past runs logged in DynamoDB yet.")
for r in runs:
st.markdown(
f"**`{r['run_id']}`** Β· `{r['status']}` ({r['findings_count']} issues)\n\n"
f"<small>{r['issue_title'][:60]}</small>",
unsafe_allow_html=True,
)
if r.get("s3_pdf_url"):
st.markdown(f"[πŸ“„ S3 PDF Report]({r['s3_pdf_url']})")
st.divider()
if is_demo_choice:
st.warning(
"**Demo mode selected.** Runs the deterministic scripted agent (no LLM calls, no "
"commits). Open **βš™οΈ Advanced Settings** and switch to **Live Groq Agent** to scan any GitHub URL."
)
else:
sandbox_note = (
"Docker container sandbox"
if docker_up and st.session_state.sandbox_backend != "local"
else "Local subprocess sandbox (secrets scrubbed, not container-isolated)"
)
st.info(
f"**Live Groq mode (`{st.session_state.groq_model}`).** "
f"Paste a GitHub repository URL in the sidebar and click **Start run** to scan all issues and generate a full report. "
f"Tests execute in: **{sandbox_note}**."
)
if st.session_state.last_error:
st.error(f"Run error: {st.session_state.last_error}")
if st.session_state.thread_id is None:
st.info("Paste a GitHub repository URL in the sidebar and press **Start run**.")
return
snap = _active_graph().get_state(_config())
values = snap.values
telemetry = _compute_telemetry(values, st.session_state.log)
m1, m2, m3, m4, m5 = st.columns(5)
m1.metric("Fix iterations", telemetry["iterations"])
m2.metric("LLM calls", telemetry["llm_calls"])
m3.metric("Sandbox runs", telemetry["sandbox_runs"])
m4.metric("Est. tokens", telemetry["est_tokens"])
m5.metric("Elapsed time", telemetry["elapsed"])
_render_findings_report(values)
st.subheader("Timeline")
for node, update in st.session_state.log:
render_event(node, update)
interrupt_payload = None
if snap.tasks and snap.tasks[0].interrupts:
interrupt_payload = snap.tasks[0].interrupts[0].value
if interrupt_payload is not None: # paused at human_approval
render_approval(interrupt_payload, values)
else:
render_outcome(values)
main()