File size: 4,227 Bytes
e1f5446 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | """commit_runtime with the frozen local adapter installed.
Three hooks, all infrastructure, none touching pipeline logic:
1. `_start_validation_sandbox` returns a LocalSandbox over the repository's
prepared checkout (commit_runtime.py line 518 is the only construction site).
2. The commit walk's clone is redirected from the GitHub URL to the pinned
local mirror (`_shallow_clone_at_ref` at commit_runtime.py line 284). The
task keeps `repo = owner/name` and real commit references.
3. Issue enrichment is disabled: `capabilities_for` returns no ISSUES
capability, so the pipeline uses the commit message (its documented
fallback for sources without an issue API). There is no network.
"""
from __future__ import annotations
import json
import shutil
import subprocess
from dataclasses import fields
from pathlib import Path
from repo2rlenv.bootstrap.spec import BootstrapResult, LanguageHint
from repo2rlenv.pipelines import commit_runtime as _cr
from repo2rlenv.pipelines.commit_runtime import CommitRuntimePipeline
from .sandbox import LocalSandbox
def load_bootstrap(path: Path) -> BootstrapResult:
"""Load a prebaked bootstrap.json exactly as bootstrap/cache.py line 117 does."""
data = json.loads(Path(path).read_text())
if isinstance(data.get("language"), str):
try:
data["language"] = LanguageHint(data["language"])
except ValueError:
data["language"] = LanguageHint.UNKNOWN
if isinstance(data.get("transcript_path"), str):
data["transcript_path"] = Path(data["transcript_path"])
known = {f.name for f in fields(BootstrapResult)}
return BootstrapResult(**{k: v for k, v in data.items() if k in known})
def _mirror_for(repo_url: str, mirrors: dict[str, Path]) -> Path:
key = repo_url.rstrip("/").removesuffix(".git").lower()
if key not in mirrors:
raise RuntimeError(f"no local mirror registered for {repo_url}")
return mirrors[key]
def install_hooks(mirrors: dict[str, Path]) -> None:
"""Redirect clones to local mirrors and disable issue lookups. Idempotent."""
normalized = {k.rstrip("/").removesuffix(".git").lower(): Path(v) for k, v in mirrors.items()}
def _local_clone(repo_url, ref, token, dest, *, depth=1, on_progress=None):
del token, on_progress
mirror = _mirror_for(repo_url, normalized)
dest = Path(dest)
if dest.exists():
shutil.rmtree(dest, ignore_errors=True)
# --shared: no object copy; the mirror outlives every temp clone.
subprocess.run(
["git", "clone", "-q", "--shared", "--no-checkout", f"file://{mirror}", str(dest)],
check=True,
capture_output=True,
text=True,
timeout=300,
)
subprocess.run(
["git", "-C", str(dest), "checkout", "-q", "--detach", ref],
check=True,
capture_output=True,
text=True,
timeout=120,
)
_ = depth # history is complete; the depth limit is honored by list_commits' -n
_cr._shallow_clone_at_ref = _local_clone
_cr.capabilities_for = lambda kind: frozenset()
# git_local.show_diff decodes `git show` strictly as UTF-8 and a single
# commit carrying latin-1 bytes aborts the whole repository walk. Surface
# it as the GitError the run loop already handles (diff_fetch_failed skip).
_orig_show_diff = _cr.show_diff
def _show_diff(clone_dir, commit_sha):
try:
return _orig_show_diff(clone_dir, commit_sha)
except UnicodeDecodeError as exc:
raise _cr.GitError(f"non-UTF-8 diff for {commit_sha[:12]}: {exc}") from exc
_cr.show_diff = _show_diff
class LocalCommitRuntimePipeline(CommitRuntimePipeline):
"""CommitRuntimePipeline whose validation sandbox is a LocalSandbox."""
def __init__(self, input, options, bootstrap=None, *, sandbox_dir: Path):
super().__init__(input, options, bootstrap)
self.sandbox_dir = Path(sandbox_dir)
def _start_validation_sandbox(self):
return LocalSandbox.start(
sandbox_dir=self.sandbox_dir,
post_clean_cmds=list(self.bootstrap.rebuild_cmds or []),
)
|