| |
| """Run CodeQL on the pinned public cohort and compare method-level alerts. |
| |
| The caller supplies the downloaded public benchmark.jsonl files. GitHub's |
| CodeQL CLI and query packs are installed separately; this script does not |
| download or redistribute them. |
| """ |
|
|
| import argparse |
| import concurrent.futures |
| import json |
| import re |
| import shutil |
| import subprocess |
| import time |
| from collections import defaultdict |
| from functools import lru_cache |
| from pathlib import Path |
| from zipfile import ZipFile |
|
|
|
|
| LANGUAGES = {"python": "python", "javascript": "javascript", "typescript": "javascript", |
| "c": "cpp", "c++": "cpp", "cpp": "cpp"} |
| PACKS = {"python": "1.8.11", "javascript": "2.4.6", "cpp": "1.9.0"} |
|
|
|
|
| def rows(path): |
| with open(path, encoding="utf-8") as stream: |
| for line in stream: |
| if line.strip(): |
| yield json.loads(line) |
|
|
|
|
| def selected_pairs(args): |
| cohort = None if args.all_supported else json.loads(Path(args.cohort).read_text()) |
| selected = {} |
| for domain in ("bug", "security"): |
| repos = set(cohort[domain]) if cohort else None |
| selected[domain] = [ |
| pair for pair in rows(Path(args.data) / domain / "benchmark.jsonl") |
| if (repos is None or pair["repository"] in repos) |
| and pair["language"].lower() in LANGUAGES |
| and all(isinstance(pair[role].get("revision"), str) |
| and re.fullmatch(r"[0-9a-f]{40}", pair[role]["revision"]) |
| for role in ("before", "after")) |
| ] |
| return selected |
|
|
|
|
| def run(command, log_path, timeout=None, container_name=None): |
| log_path.parent.mkdir(parents=True, exist_ok=True) |
| start = time.monotonic() |
| with log_path.open("w", encoding="utf-8") as log: |
| try: |
| result = subprocess.run(command, stdout=log, stderr=subprocess.STDOUT, |
| timeout=timeout) |
| code = result.returncode |
| except subprocess.TimeoutExpired: |
| if container_name: |
| subprocess.run(["docker", "stop", "--time", "2", container_name], |
| stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) |
| log.write(f"CodeQL stage exceeded {timeout} seconds.\n") |
| code = 124 |
| return code, round(time.monotonic() - start, 2) |
|
|
|
|
| def prepare_rebench_patches(pairs, root, source_parquet): |
| """Recreate SWE-rebench repaired snapshots from its published gold patches.""" |
| if not source_parquet: |
| return |
| instances = {} |
| for pair in pairs["bug"]: |
| if not pair["pair_id"].startswith("swe-rebench:"): |
| continue |
| if "+" in pair["after"]["revision"]: |
| continue |
| instance = pair["pair_id"].split(":", 2)[1] |
| if not re.fullmatch(r"[A-Za-z0-9_.-]+", instance): |
| raise ValueError(f"Invalid instance ID: {instance}") |
| instances[instance] = pair |
| if not instances: |
| return |
| quoted = ",".join("'" + instance + "'" for instance in sorted(instances)) |
| parquet = Path(source_parquet).resolve().as_posix().replace("'", "''") |
| query = ("SELECT instance_id,base_commit,patch FROM read_parquet('" |
| + parquet + "') WHERE instance_id IN (" + quoted + ")") |
| response = subprocess.run(["duckdb", "-json", "-c", query], check=True, |
| capture_output=True, text=True) |
| source_rows = {row["instance_id"]: row for row in json.loads(response.stdout)} |
| errors = [] |
| for instance, pair in instances.items(): |
| source = source_rows.get(instance) |
| if not source: |
| errors.append({"instance_id": instance, "reason": "missing source patch"}) |
| continue |
| if pair["before"]["revision"] != source["base_commit"]: |
| errors.append({"instance_id": instance, "reason": "base commit mismatch"}) |
| continue |
| repo = pair["repository"] |
| slug = repo.replace("/", "__") |
| git_dir = root / "git" / slug |
| checkout = root / "checkouts" / slug / pair["after"]["revision"] |
| patch_file = root / "patches" / f"{instance}.patch" |
| patch_file.parent.mkdir(parents=True, exist_ok=True) |
| patch_file.write_text(source["patch"], encoding="utf-8") |
| try: |
| if not git_dir.exists(): |
| git_dir.parent.mkdir(parents=True, exist_ok=True) |
| subprocess.run(["git", "clone", "--filter=blob:none", "--no-checkout", |
| f"https://github.com/{repo}.git", str(git_dir)], check=True, |
| stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) |
| have = subprocess.run( |
| ["git", "-C", str(git_dir), "cat-file", "-e", |
| f"{source['base_commit']}^{{commit}}"], |
| stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, |
| ).returncode == 0 |
| if not have: |
| subprocess.run(["git", "-C", str(git_dir), "fetch", "origin", |
| source["base_commit"]], check=True, |
| stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) |
| if not checkout.exists(): |
| checkout.parent.mkdir(parents=True, exist_ok=True) |
| subprocess.run(["git", "-C", str(git_dir), "worktree", "add", "--detach", |
| str(checkout), source["base_commit"]], check=True, |
| stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) |
| subprocess.run(["git", "-C", str(checkout), "apply", "--whitespace=nowarn", |
| str(patch_file)], check=True, |
| stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) |
| except subprocess.CalledProcessError as error: |
| errors.append({"instance_id": instance, |
| "reason": f"{error.cmd[0]} exited {error.returncode}"}) |
| (root / "patch-errors.json").write_text(json.dumps(errors, indent=2) + "\n") |
|
|
|
|
| def prepare_sources(pairs, root): |
| tasks = defaultdict(set) |
| for domain, group in pairs.items(): |
| for pair in group: |
| repo = pair["repository"] |
| language = LANGUAGES[pair["language"].lower()] |
| for role in ("before", "after"): |
| tasks[(repo, pair[role]["revision"], language)].add(domain) |
|
|
| sources = {} |
| errors = [] |
| for repo, revision, language in sorted(tasks): |
| if not re.fullmatch(r"[0-9a-f]{40}", revision): |
| errors.append({"repository": repo, "revision": revision, |
| "reason": "not a Git commit"}) |
| continue |
| slug = repo.replace("/", "__") |
| git_dir = root / "git" / slug |
| checkout = root / "checkouts" / slug / revision |
| try: |
| if not git_dir.exists(): |
| git_dir.parent.mkdir(parents=True, exist_ok=True) |
| subprocess.run( |
| ["git", "clone", "--filter=blob:none", "--no-checkout", |
| f"https://github.com/{repo}.git", str(git_dir)], |
| check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, |
| ) |
| if not checkout.exists(): |
| checkout.parent.mkdir(parents=True, exist_ok=True) |
| have = subprocess.run( |
| ["git", "-C", str(git_dir), "cat-file", "-e", f"{revision}^{{commit}}"], |
| stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, |
| ).returncode == 0 |
| if not have: |
| subprocess.run(["git", "-C", str(git_dir), "fetch", "origin", revision], |
| check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) |
| subprocess.run(["git", "-C", str(git_dir), "worktree", "add", "--detach", |
| str(checkout), revision], check=True, |
| stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) |
| sources[(repo, revision, language)] = (checkout, tasks[(repo, revision, language)]) |
| except subprocess.CalledProcessError as error: |
| errors.append({"repository": repo, "revision": revision, |
| "reason": f"{error.cmd[0]} exited {error.returncode}"}) |
| (root / "source-errors.json").write_text(json.dumps(errors, indent=2) + "\n") |
| return sources |
|
|
|
|
| def docker(args, name, *command): |
| return ["docker", "run", "--rm", "--name", name, |
| "-v", f"{Path(args.codeql).resolve()}:/opt/codeql:ro", |
| "-v", f"{Path(args.root).resolve()}:/work", args.image, |
| "/opt/codeql/codeql", *command] |
|
|
|
|
| def scan_one(args, task): |
| (repo, revision, language), (checkout, domains) = task |
| root = Path(args.root).resolve() |
| slug = repo.replace("/", "__") |
| stem = f"{slug}-{revision[:12]}-{language}" |
| db = root / "dbs" / stem |
| log_dir = root / "logs" |
| result = {"repository": repo, "revision": revision, "language": language, |
| "domains": sorted(domains)} |
| if not (db / f"db-{language}").exists(): |
| if db.exists(): |
| shutil.rmtree(db) |
| container = f"codeql-create-{stem}".lower() |
| code, seconds = run(docker(args, container, "database", "create", f"/work/dbs/{stem}", |
| f"--language={language}", "--build-mode=none", |
| f"--source-root=/work/checkouts/{slug}/{revision}", |
| "--threads=4", "--ram=4096"), |
| log_dir / f"{stem}-create.log", args.scan_timeout, container) |
| result["create_seconds"] = seconds |
| if code: |
| result["error"] = f"database create exit {code}" |
| return result |
| for domain in sorted(domains): |
| sarif = root / "sarif" / domain / f"{stem}.sarif" |
| if sarif.exists(): |
| continue |
| sarif.parent.mkdir(parents=True, exist_ok=True) |
| suite = "security-extended" if domain == "security" else "security-and-quality" |
| query = (f"/work/packs/codeql/{language}-queries/{PACKS[language]}/" |
| f"codeql-suites/{language}-{suite}.qls") |
| container = f"codeql-{domain}-{stem}".lower() |
| code, seconds = run(docker(args, container, "database", "analyze", f"/work/dbs/{stem}", |
| query, "--format=sarif-latest", |
| f"--output=/work/sarif/{domain}/{stem}.sarif", |
| "--threads=4", "--ram=4096"), |
| log_dir / f"{stem}-{domain}-analyze.log", args.scan_timeout, |
| container) |
| result[f"{domain}_analyze_seconds"] = seconds |
| if code: |
| result["error"] = f"{domain} analyze exit {code}" |
| return result |
| result["ok"] = True |
| return result |
|
|
|
|
| def scan(args): |
| root = Path(args.root).resolve() |
| (root / "dbs").mkdir(parents=True, exist_ok=True) |
| pairs = selected_pairs(args) |
| prepare_rebench_patches(pairs, root, args.rebench_parquet) |
| sources = prepare_sources(pairs, root) |
| print(f"Fixed cohort: {len(pairs['bug'])} bug pairs, " |
| f"{len(pairs['security'])} security pairs, {len(sources)} databases", flush=True) |
| manifest = {domain: [p["pair_id"] for p in group] for domain, group in pairs.items()} |
| (root / "cohort-pair-ids.json").write_text(json.dumps(manifest, indent=2) + "\n") |
| with concurrent.futures.ThreadPoolExecutor(max_workers=args.jobs) as executor: |
| for result in concurrent.futures.as_completed( |
| [executor.submit(scan_one, args, task) for task in sources.items()] |
| ): |
| item = result.result() |
| with (root / "scan-status.jsonl").open("a", encoding="utf-8") as stream: |
| stream.write(json.dumps(item, sort_keys=True) + "\n") |
| print(f"{'OK' if item.get('ok') else 'FAILED'} " |
| f"{item['repository']} {item['revision'][:12]} " |
| f"{','.join(item['domains'])}", flush=True) |
|
|
|
|
| def method_span(side): |
| lines = [int(match) for match in re.findall(r"(?m)^L(\d+)\|", |
| side["state"]["method"]["source"])] |
| return (min(lines), max(lines)) if lines else None |
|
|
|
|
| def source_matches(side, source_path): |
| content = source_path.read_text(errors="replace").replace("\r\n", "\n") |
| needle = side["source"].replace("\r\n", "\n").strip() |
| start = content.find(needle) |
| return start >= 0 and content.count("\n", 0, start) + 1 == method_span(side)[0] |
|
|
|
|
| @lru_cache(maxsize=128) |
| def archived_sources(archive): |
| with ZipFile(archive) as zipped: |
| return set(zipped.namelist()) |
|
|
|
|
| def codeql_alert(sarif, side, domain): |
| path = side["path"].lstrip("/") |
| span = method_span(side) |
| if not span: |
| raise ValueError(f"Missing line-numbered method: {path}") |
| data = json.loads(sarif.read_text()) |
| alerts = [] |
| for run_data in data["runs"]: |
| rule_tags = { |
| rule["id"]: set(rule.get("properties", {}).get("tags", [])) |
| for rule in run_data["tool"]["driver"].get("rules", []) |
| } |
| for finding in run_data.get("results", []): |
| tags = rule_tags.get(finding["ruleId"], set()) |
| if domain == "security" and "security" not in tags: |
| continue |
| if domain == "bug" and not tags.intersection( |
| ("correctness", "reliability", "security") |
| ): |
| continue |
| for location in finding.get("locations", [])[:1]: |
| physical = location.get("physicalLocation", {}) |
| uri = physical.get("artifactLocation", {}).get("uri", "") |
| region = physical.get("region", {}) |
| if uri.lstrip("/") != path or "startLine" not in region: |
| continue |
| start = region["startLine"] |
| end = region.get("endLine", start) |
| if start <= span[1] and end >= span[0]: |
| alerts.append(finding["ruleId"]) |
| return sorted(set(alerts)) |
|
|
|
|
| def metrics(items): |
| items = list(items) |
| tp = sum(label and alert for label, alert in items) |
| fp = sum(not label and alert for label, alert in items) |
| fn = sum(label and not alert for label, alert in items) |
| tn = sum(not label and not alert for label, alert in items) |
| precision = tp / (tp + fp) if tp + fp else None |
| recall = tp / (tp + fn) if tp + fn else 0.0 |
| fpr = fp / (fp + tn) if fp + tn else 0.0 |
| f1 = (2 * precision * recall / (precision + recall) |
| if precision is not None and precision + recall else 0.0) |
| return {"tp": tp, "fp": fp, "fn": fn, "tn": tn, "precision": precision, |
| "recall": recall, "fpr": fpr, "f1": f1, "recall_minus_fpr": recall - fpr} |
|
|
|
|
| def score(args): |
| root = Path(args.root).resolve() |
| selected = selected_pairs(args) |
| all_results = {} |
| for domain, group in selected.items(): |
| jev = {(r["pair_id"], r["role"]): r for r in |
| rows(Path(args.predictions) / domain / "jev.jsonl")} |
| output = [] |
| unavailable = [] |
| for pair in group: |
| decisions = [] |
| for role in ("before", "after"): |
| side = pair[role] |
| lang = LANGUAGES[pair["language"].lower()] |
| stem = f"{pair['repository'].replace('/', '__')}-{side['revision'][:12]}-{lang}" |
| sarif = root / "sarif" / domain / f"{stem}.sarif" |
| source_path = (root / "checkouts" / pair["repository"].replace("/", "__") |
| / side["revision"] / side["path"]) |
| if not sarif.exists() or (pair["pair_id"], role) not in jev: |
| reason = ("source snapshot unavailable" if not source_path.exists() |
| else "CodeQL analysis unavailable" if not sarif.exists() |
| else "Jev prediction unavailable") |
| unavailable.append({"pair_id": pair["pair_id"], "role": role, |
| "reason": reason}) |
| decisions = [] |
| break |
| archive = root / "dbs" / stem / "src.zip" |
| archived_name = (f"work/checkouts/{pair['repository'].replace('/', '__')}/" |
| f"{side['revision']}/{side['path']}") |
| if not source_path.exists(): |
| unavailable.append({"pair_id": pair["pair_id"], "role": role, |
| "reason": "source snapshot unavailable"}) |
| decisions = [] |
| break |
| if (not archive.exists() |
| or archived_name not in archived_sources(archive) |
| or not source_matches(side, source_path)): |
| unavailable.append({"pair_id": pair["pair_id"], "role": role, |
| "reason": "target source not verified in CodeQL database"}) |
| decisions = [] |
| break |
| rules = codeql_alert(sarif, side, domain) |
| label = int(side["labels"][domain]) |
| decisions.append({"role": role, "label": label, "codeql_alert": bool(rules), |
| "codeql_rules": rules, |
| "jev_alert": bool(jev[(pair["pair_id"], role)]["alert"]), |
| "jev_score": jev[(pair["pair_id"], role)]["score"]}) |
| if decisions: |
| output.append({"pair_id": pair["pair_id"], "repository": pair["repository"], |
| "language": pair["language"], "decisions": decisions}) |
| model_scores = {} |
| for model in ("codeql", "jev"): |
| model_scores[model] = metrics( |
| (d["label"], d[f"{model}_alert"]) for row in output for d in row["decisions"] |
| ) |
| all_results[domain] = {"pairs": len(output), "requested_pairs": len(group), |
| "missing_sides": unavailable, "models": model_scores} |
| out = root / f"{domain}-codeql-comparison.jsonl" |
| out.write_text("".join(json.dumps(r, sort_keys=True) + "\n" for r in output)) |
| (root / "codeql-comparison-results.json").write_text( |
| json.dumps(all_results, indent=2, sort_keys=True) + "\n" |
| ) |
| print(json.dumps(all_results, indent=2)) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("operation", choices=("scan", "score")) |
| parser.add_argument("--root", required=True) |
| parser.add_argument("--data", required=True, help="directory with bug/security/benchmark.jsonl") |
| parser.add_argument("--predictions", required=True, help="directory with bug/security/jev.jsonl") |
| parser.add_argument("--cohort", default=str(Path(__file__).with_name("codeql-cohort.json"))) |
| parser.add_argument("--all-supported", action="store_true", |
| help="scan every pair in supported languages with two Git revisions") |
| parser.add_argument("--codeql", help="unpacked CodeQL CLI directory") |
| parser.add_argument("--rebench-parquet", help="SWE-rebench-V2 source Parquet with gold patches") |
| parser.add_argument("--image", default="node:22-bookworm") |
| parser.add_argument("--jobs", type=int, default=4) |
| parser.add_argument("--scan-timeout", type=int, default=600, |
| help="seconds allowed per CodeQL database or analysis stage") |
| args = parser.parse_args() |
| if args.operation == "scan": |
| if not args.codeql: |
| parser.error("--codeql is required for scanning") |
| scan(args) |
| else: |
| score(args) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
