@ranger1/dx 0.1.29 → 0.1.30

package/@opencode/agents/pr_context.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+# PR context builder (deterministic).
+# - Reads PR metadata + recent comments via gh
+# - Reads changed files via git diff (no patch)
+# - Writes Markdown context file to ~/.opencode/cache/
+# - Prints exactly one JSON object to stdout
+
+import argparse
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+CACHE_DIR = Path.home() / ".opencode" / "cache"
+MARKER_SUBSTR = "<!-- pr-review-loop-marker"
+
+
+def _json_out(obj):
+    sys.stdout.write(json.dumps(obj, ensure_ascii=True))
+    sys.stdout.write("\n")
+
+
+def _run_capture(cmd):
+    p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    return p.returncode, p.stdout, p.stderr
+
+
+def _clip(s, n):
+    if s is None:
+        return ""
+    s = str(s)
+    return s if len(s) <= n else (s[:n] + "...")
+
+
+def _safe_basename(name):
+    if not name:
+        return None
+    base = os.path.basename(name.strip())
+    if base != name.strip():
+        return None
+    if base in (".", ".."):
+        return None
+    return base
+
+
+def _git_fetch_origin(ref):
+    subprocess.run(["git", "fetch", "origin", ref], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def _git_numstat(base_ref):
+    # Prefer origin/<base>...HEAD; fallback to <base>...HEAD.
+    for lhs in (f"origin/{base_ref}...HEAD", f"{base_ref}...HEAD"):
+        rc, out, _ = _run_capture(["git", "diff", "--numstat", lhs])
+        if rc == 0:
+            return out
+    return ""
+
+
+def _parse_numstat(numstat_text):
+    rows = []
+    for line in (numstat_text or "").splitlines():
+        parts = line.split("\t")
+        if len(parts) < 3:
+            continue
+        add_s, del_s, path = parts[0].strip(), parts[1].strip(), parts[2].strip()
+        if not path:
+            continue
+        rows.append((add_s, del_s, path))
+    return rows
+
+
+def main(argv):
+    class _ArgParser(argparse.ArgumentParser):
+        def error(self, message):
+            raise ValueError(message)
+
+    parser = _ArgParser(add_help=False)
+    parser.add_argument("--pr", type=int, required=True)
+    parser.add_argument("--round", type=int, default=1)
+    try:
+        args = parser.parse_args(argv)
+    except ValueError:
+        _json_out({"error": "INVALID_ARGS"})
+        return 2
+
+    pr_number = int(args.pr)
+    round_num = int(args.round)
+
+    # Preconditions: be in a git repo and gh is authenticated.
+    rc, out, _ = _run_capture(["git", "rev-parse", "--is-inside-work-tree"])
+    if rc != 0 or out.strip() != "true":
+        _json_out({"error": "NOT_A_GIT_REPO"})
+        return 1
+
+    if subprocess.run(["gh", "auth", "status"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode != 0:
+        _json_out({"error": "GH_NOT_AUTHENTICATED"})
+        return 1
+
+    rc, owner_repo, _ = _run_capture(["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"])
+    owner_repo = owner_repo.strip() if rc == 0 else ""
+    if not owner_repo:
+        _json_out({"error": "REPO_NOT_FOUND"})
+        return 1
+
+    fields = "number,url,title,body,isDraft,labels,baseRefName,headRefName,baseRefOid,headRefOid,comments"
+    rc, pr_json, _ = _run_capture(["gh", "pr", "view", str(pr_number), "--repo", owner_repo, "--json", fields])
+    if rc != 0:
+        _json_out({"error": "PR_NOT_FOUND_OR_NO_ACCESS"})
+        return 1
+    try:
+        pr = json.loads(pr_json)
+    except Exception:
+        _json_out({"error": "PR_NOT_FOUND_OR_NO_ACCESS"})
+        return 1
+
+    head_oid = (pr.get("headRefOid") or "").strip()
+    base_ref = (pr.get("baseRefName") or "").strip() or "main"
+    head_ref = (pr.get("headRefName") or "").strip()
+    url = (pr.get("url") or "").strip()
+
+    seed = f"{pr_number}:{round_num}:{head_oid}".encode("utf-8")
+    run_id = hashlib.sha1(seed).hexdigest()[:12]
+
+    _git_fetch_origin(base_ref)
+    file_rows = _parse_numstat(_git_numstat(base_ref))
+
+    labels = []
+    for l in (pr.get("labels") or []):
+        if isinstance(l, dict) and l.get("name"):
+            labels.append(str(l.get("name")))
+
+    comments = pr.get("comments") or []
+    recent = comments[-10:] if isinstance(comments, list) else []
+    marker_count = 0
+    for c in recent:
+        if not isinstance(c, dict):
+            continue
+        body = c.get("body") or ""
+        if isinstance(body, str) and MARKER_SUBSTR in body:
+            marker_count += 1
+
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    context_file = f"pr-context-pr{pr_number}-r{round_num}-{run_id}.md"
+    context_path = CACHE_DIR / context_file
+
+    with open(context_path, "w", encoding="utf-8", newline="\n") as fp:
+        fp.write("# PR Context\n\n")
+        fp.write(f"- Repo: {owner_repo}\n")
+        fp.write(f"- PR: #{pr_number} {url}\n")
+        fp.write(f"- Round: {round_num}\n")
+        fp.write(f"- RunId: {run_id}\n")
+        fp.write(f"- Base: {base_ref}\n")
+        fp.write(f"- Head: {head_ref}\n")
+        fp.write(f"- HeadOid: {head_oid}\n")
+        fp.write(f"- Draft: {pr.get('isDraft')}\n")
+        fp.write(f"- Labels: {', '.join(labels) if labels else '(none)'}\n")
+        fp.write(f"- ExistingLoopMarkers: {marker_count}\n\n")
+
+        fp.write("## Title\n\n")
+        fp.write(_clip(pr.get("title") or "", 200) + "\n\n")
+
+        fp.write("## Body (excerpt)\n\n")
+        fp.write(_clip(pr.get("body") or "", 2000) or "(empty)")
+        fp.write("\n\n")
+
+        fp.write(f"## Changed Files ({len(file_rows)})\n\n")
+        if file_rows:
+            for add_s, del_s, path in file_rows:
+                fp.write(f"- +{add_s} -{del_s} {path}\n")
+        else:
+            fp.write("(none)\n")
+        fp.write("\n")
+
+        fp.write("## Recent Comments (excerpt)\n\n")
+        if recent:
+            for c in recent:
+                if not isinstance(c, dict):
+                    continue
+                author = None
+                if isinstance(c.get("author"), dict):
+                    author = (c.get("author") or {}).get("login")
+                fp.write(f"- {author or 'unknown'}: {_clip(c.get('body') or '', 300)}\n")
+        else:
+            fp.write("(none)\n")
+
+    _json_out(
+        {
+            "agent": "pr-context",
+            "prNumber": pr_number,
+            "round": round_num,
+            "runId": run_id,
+            "repo": {"nameWithOwner": owner_repo},
+            "headOid": head_oid,
+            "existingMarkerCount": marker_count,
+            "contextFile": context_file,
+        }
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main(sys.argv[1:]))
+    except SystemExit:
+        raise
+    except Exception:
+        _json_out({"error": "PR_CONTEXT_SCRIPT_FAILED"})
+        raise SystemExit(1)

package/@opencode/agents/pr_precheck.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+# PR precheck workflow (all handled by this script):
+# - Verify running inside a git repo
+# - Verify GitHub auth (gh)
+# - Read PR info (headRefName/baseRefName/mergeable)
+# - Checkout PR branch (gh pr checkout) if needed
+# - Fetch base branch (origin/<base>, fallback main/master)
+# - If mergeable == CONFLICTING: return {"error":"PR_MERGE_CONFLICTS_UNRESOLVED"}
+# - Run dx cache clear
+# - Run dx lint and dx build all concurrently
+# - On failure, write fixFile to ~/.opencode/cache/ and return {"ok":false,"fixFile":"..."}
+# - On success, return {"ok":true}
+#
+# Stdout contract: print exactly one JSON object and nothing else.
+
+import json
+import re
+import secrets
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run(cmd, *, cwd=None, stdout_path=None, stderr_path=None):
+    if stdout_path and stderr_path and stdout_path == stderr_path:
+        with open(stdout_path, "wb") as f:
+            p = subprocess.run(cmd, cwd=cwd, stdout=f, stderr=f)
+            return p.returncode
+
+    if stdout_path and stderr_path:
+        with open(stdout_path, "wb") as stdout_f, open(stderr_path, "wb") as stderr_f:
+            p = subprocess.run(cmd, cwd=cwd, stdout=stdout_f, stderr=stderr_f)
+            return p.returncode
+    elif stdout_path:
+        with open(stdout_path, "wb") as stdout_f:
+            p = subprocess.run(cmd, cwd=cwd, stdout=stdout_f, stderr=subprocess.DEVNULL)
+            return p.returncode
+    elif stderr_path:
+        with open(stderr_path, "wb") as stderr_f:
+            p = subprocess.run(cmd, cwd=cwd, stdout=subprocess.DEVNULL, stderr=stderr_f)
+            return p.returncode
+    else:
+        p = subprocess.run(cmd, cwd=cwd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return p.returncode
+
+
+def run_capture(cmd, *, cwd=None):
+    p = subprocess.run(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    return p.returncode, p.stdout, p.stderr
+
+
+def tail_text(path, max_lines=200, max_chars=12000):
+    try:
+        data = Path(path).read_text(errors="replace")
+    except Exception:
+        return "(failed to read log)"
+    lines = data.splitlines()
+    tail = "\n".join(lines[-max_lines:])
+    if len(tail) > max_chars:
+        tail = tail[-max_chars:]
+    return tail
+
+
+def first_file_line(text):
+    for m in re.finditer(r"^([^\s:]+\.[a-zA-Z0-9]+):(\d+)(?::(\d+))?\b", text, flags=re.M):
+        file = m.group(1)
+        line = int(m.group(2))
+        return file, line
+    return None, None
+
+
+def write_fixfile(path, issues):
+    p = Path(path)
+    out = ["## IssuesToFix", ""]
+    for it in issues:
+        out.append(f"- id: {it['id']}")
+        out.append(f"  priority: {it['priority']}")
+        out.append(f"  category: {it['category']}")
+        out.append(f"  file: {it['file']}")
+        out.append(f"  line: {it['line'] if it['line'] is not None else 'null'}")
+        out.append(f"  title: {it['title']}")
+        desc = it["description"].replace("\n", "\\n")
+        sugg = it["suggestion"].replace("\n", "\\n")
+        out.append(f"  description: {desc}")
+        out.append(f"  suggestion: {sugg}")
+    p.write_text("\n".join(out) + "\n")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "PR_NUMBER_NOT_PROVIDED"}))
+        return 1
+
+    pr = sys.argv[1].strip()
+    if not pr.isdigit():
+        print(json.dumps({"error": "PR_NUMBER_NOT_PROVIDED"}))
+        return 1
+
+    rc, out, _ = run_capture(["git", "rev-parse", "--is-inside-work-tree"])
+    if rc != 0 or out.strip() != "true":
+        print(json.dumps({"error": "NOT_A_GIT_REPO"}))
+        return 1
+
+    rc = run(["gh", "auth", "status"])
+    if rc != 0:
+        print(json.dumps({"error": "GH_NOT_AUTHENTICATED"}))
+        return 1
+
+    rc, pr_json, _ = run_capture(["gh", "pr", "view", pr, "--json", "headRefName,baseRefName,mergeable"])
+    if rc != 0:
+        print(json.dumps({"error": "PR_NOT_FOUND_OR_NO_ACCESS"}))
+        return 1
+    try:
+        pr_info = json.loads(pr_json)
+    except Exception:
+        print(json.dumps({"error": "PR_NOT_FOUND_OR_NO_ACCESS"}))
+        return 1
+
+    head = (pr_info.get("headRefName") or "").strip()
+    base = (pr_info.get("baseRefName") or "").strip()
+    mergeable = (pr_info.get("mergeable") or "").strip()
+
+    rc, cur_branch, _ = run_capture(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+    if rc != 0:
+        print(json.dumps({"error": "PR_CHECKOUT_FAILED"}))
+        return 1
+    if head and cur_branch.strip() != head:
+        if run(["gh", "pr", "checkout", pr]) != 0:
+            print(json.dumps({"error": "PR_CHECKOUT_FAILED"}))
+            return 1
+
+    if not base:
+        rc, out, _ = run_capture(["gh", "repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"])
+        if rc == 0:
+            base = out.strip()
+    if not base:
+        print(json.dumps({"error": "PR_BASE_REF_NOT_FOUND"}))
+        return 1
+
+    if run(["git", "fetch", "origin", base]) != 0:
+        ok = False
+        for fallback in ("main", "master"):
+            if fallback == base:
+                continue
+            if run(["git", "fetch", "origin", fallback]) == 0:
+                base = fallback
+                ok = True
+                break
+        if not ok:
+            print(json.dumps({"error": "PR_BASE_REF_FETCH_FAILED"}))
+            return 1
+
+    if mergeable == "CONFLICTING":
+        print(json.dumps({"error": "PR_MERGE_CONFLICTS_UNRESOLVED"}))
+        return 1
+
+    run_id = secrets.token_hex(4)
+    cache = Path.home() / ".opencode" / "cache"
+    cache.mkdir(parents=True, exist_ok=True)
+    
+    cache_clear_log = cache / f"precheck-pr{pr}-{run_id}-cache-clear.log"
+    lint_log = cache / f"precheck-pr{pr}-{run_id}-lint.log"
+    build_log = cache / f"precheck-pr{pr}-{run_id}-build.log"
+    meta_log = cache / f"precheck-pr{pr}-{run_id}-meta.json"
+
+    meta_log.write_text(json.dumps({
+        "pr": int(pr),
+        "headRefName": head,
+        "baseRefName": base,
+        "mergeable": mergeable,
+        "cacheClearLog": str(cache_clear_log),
+        "lintLog": str(lint_log),
+        "buildLog": str(build_log),
+    }, indent=2) + "\n")
+
+    cache_rc = run(["dx", "cache", "clear"], stdout_path=str(cache_clear_log), stderr_path=str(cache_clear_log))
+    if cache_rc != 0:
+        fix_file = f"precheck-fix-pr{pr}-{run_id}.md"
+        fix_path = cache / fix_file
+        log_tail = tail_text(cache_clear_log)
+        issues = [{
+            "id": "PRE-001",
+            "priority": "P1",
+            "category": "quality",
+            "file": "<unknown>",
+            "line": None,
+            "title": "dx cache clear failed",
+            "description": log_tail,
+            "suggestion": f"Open log: {cache_clear_log}",
+        }]
+        write_fixfile(str(fix_path), issues)
+        print(json.dumps({"ok": False, "fixFile": fix_file}))
+        return 1
+
+    import threading
+
+    results = {}
+
+    def worker(name, cmd, log_path):
+        results[name] = run(cmd, stdout_path=str(log_path), stderr_path=str(log_path))
+
+    t1 = threading.Thread(target=worker, args=("lint", ["dx", "lint"], lint_log))
+    t2 = threading.Thread(target=worker, args=("build", ["dx", "build", "all"], build_log))
+    t1.start()
+    t2.start()
+    t1.join()
+    t2.join()
+
+    if results.get("lint", 1) == 0 and results.get("build", 1) == 0:
+        print(json.dumps({"ok": True}))
+        return 0
+
+    fix_file = f"precheck-fix-pr{pr}-{run_id}.md"
+    fix_path = cache / fix_file
+
+    issues = []
+    i = 1
+    if results.get("lint", 1) != 0:
+        log_tail = tail_text(lint_log)
+        file, line = first_file_line(log_tail)
+        issues.append({
+            "id": f"PRE-{i:03d}",
+            "priority": "P1",
+            "category": "lint",
+            "file": file or "<unknown>",
+            "line": line,
+            "title": "dx lint failed",
+            "description": log_tail,
+            "suggestion": f"Open log: {lint_log}",
+        })
+        i += 1
+    if results.get("build", 1) != 0:
+        log_tail = tail_text(build_log)
+        file, line = first_file_line(log_tail)
+        issues.append({
+            "id": f"PRE-{i:03d}",
+            "priority": "P0",
+            "category": "build",
+            "file": file or "<unknown>",
+            "line": line,
+            "title": "dx build all failed",
+            "description": log_tail,
+            "suggestion": f"Open log: {build_log}",
+        })
+
+    write_fixfile(str(fix_path), issues)
+    print(json.dumps({"ok": False, "fixFile": fix_file}))
+    return 1
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:
+        print(json.dumps({"error": "PRECHECK_SCRIPT_FAILED"}))
+        sys.exit(1)