#!/usr/bin/env python3

"""Generate the curated conflict branch-pair corpus (bench-conflict-corpus-v1).

For each conflict kind a small git repository is created at <out>/<kind>/ with

branch `ours` (checked out) and branch `theirs` diverging from `main`, built so

that `git merge theirs` produces exactly the intended outcome: a conflict for

every kind except adjacent-lines, which merges CLEAN but breaks an in-repo

invariant (the "clean merge, broken build" case — check.py is committed on

main and exits 1 against the merged tree).

The resolution oracle is kept OUT of the repository content: it is written as

a sidecar file <out>/<kind>.RESOLUTION.json (schema_version 1) recording the

expected conflict outcome, the unmerged paths, the sha256 of the correct

merged content for the primary conflicted path (plus the content itself, so

oracles are self-contained), and — for adjacent-lines — the post-merge check

command and its expected non-zero return code.

Kinds: text-overlap-{small,medium,large}, adjacent-lines, rename-rename,

rename-edit, delete-edit, binary-binary, lockfile (package-lock.json-style,

the most common real agent conflict). Mined-real pairs arrive later through

the GitGoodBench pipeline and are out of scope here.

Determinism follows make_monorepo_fixture.py conventions: fixed identity,

timestamps stepping from a fixed epoch via GIT_AUTHOR_DATE/GIT_COMMITTER_DATE,

all content derived from the seed through hashed sub-RNGs, and git config

isolated from the host. The same seed yields byte-identical repos and oracles.

Every kind is self-tested after generation ("the pipe is an instrument"): the

merge is run in a scratch clone and the conflict/clean outcome, unmerged path

set, resolution sha, and (for adjacent-lines) the broken-build check are all

asserted against the oracle; any mismatch exits 1.

Exit codes: 0 ok, 1 usage/generation/self-test error, 3 git unavailable

(skip-row honesty: the caller can record a skip instead of a bogus result).

Usage:

  python3 scripts/make_conflict_corpus.py --out /tmp/conflicts \\

      --seed oakbench-conflicts-v1 [--kinds text-overlap-small,lockfile] [--quick]

"""

from __future__ import annotations

import argparse

import base64

import hashlib

import json

import os

import random

import shutil

import subprocess

import sys

import tempfile

from pathlib import Path

GENERATOR_VERSION = "conflict-corpus-v1"

SCHEMA_VERSION = 1

IDENTITY_NAME = "Oak Bench"

IDENTITY_EMAIL = "[email protected]"

EPOCH = 1_700_000_000  # first commit timestamp; +60s per commit

ORACLE_SUFFIX = ".RESOLUTION.json"

KINDS = (

    "text-overlap-small",

    "text-overlap-medium",

    "text-overlap-large",

    "adjacent-lines",

    "rename-rename",

    "rename-edit",

    "delete-edit",

    "binary-binary",

    "lockfile",

)

# (full_lines, quick_lines, conflict_regions) per text-overlap size.

TEXT_OVERLAP_SHAPES = {

    "text-overlap-small": (40, 12, 1),

    "text-overlap-medium": (400, 30, 3),

    "text-overlap-large": (4000, 80, 6),

}

WORDS = (

    "handler request response buffer stream parse encode decode commit tree "

    "branch merge index cache token batch worker queue retry timeout config "

    "schema field record column filter reduce visit walk node edge graph "

    "mount hydrate snapshot manifest oracle subject lane scenario operation"

).split()

CHECK_PY = '''#!/usr/bin/env python3

"""Build invariant: len(ITEMS) must equal EXPECTED_COUNT in data.py."""

import os

import sys

here = os.path.dirname(os.path.abspath(__file__))

namespace = {}

with open(os.path.join(here, "data.py")) as fh:

    exec(compile(fh.read(), "data.py", "exec"), namespace)

items = namespace["ITEMS"]

expected = namespace["EXPECTED_COUNT"]

if len(items) != expected:

    print(f"BROKEN: len(ITEMS)={len(items)} != EXPECTED_COUNT={expected}")

    sys.exit(1)

print("ok")

'''

def make_rng(seed: str, *scope: object) -> random.Random:

    digest = hashlib.sha256(":".join([seed, *map(str, scope)]).encode()).digest()

    return random.Random(int.from_bytes(digest[:8], "big"))

def sha256_hex(data: bytes) -> str:

    return hashlib.sha256(data).hexdigest()

def git_env(tick: int = 0) -> dict[str, str]:

    """Isolated, identity-fixed git environment with deterministic timestamps."""

    stamp = f"{EPOCH + 60 * tick} +0000"

    env = dict(os.environ)

    env.update(

        GIT_CONFIG_GLOBAL=os.devnull,

        GIT_CONFIG_NOSYSTEM="1",

        GIT_AUTHOR_NAME=IDENTITY_NAME,

        GIT_AUTHOR_EMAIL=IDENTITY_EMAIL,

        GIT_COMMITTER_NAME=IDENTITY_NAME,

        GIT_COMMITTER_EMAIL=IDENTITY_EMAIL,

        GIT_AUTHOR_DATE=stamp,

        GIT_COMMITTER_DATE=stamp,

    )

    return env

def run_git(args: list[str], cwd: Path, tick: int = 0,

            check: bool = True) -> subprocess.CompletedProcess:

    return subprocess.run(["git", *args], cwd=cwd, env=git_env(tick),

                          check=check, capture_output=True, text=True)

class Repo:

    """A scratch-built fixture repo with deterministic commits."""

    def __init__(self, path: Path):

        self.path = path

        self.tick = 0

        path.mkdir(parents=True, exist_ok=True)

        run_git(["init", "-q"], path)

        run_git(["symbolic-ref", "HEAD", "refs/heads/main"], path)

    def write(self, rel: str, data: bytes) -> None:

        target = self.path / rel

        target.parent.mkdir(parents=True, exist_ok=True)

        target.write_bytes(data)

    def commit(self, message: str) -> None:

        run_git(["add", "-A"], self.path, self.tick)

        run_git(["commit", "-q", "-m", message], self.path, self.tick)

        self.tick += 1

    def checkout(self, branch: str, create: bool = False) -> None:

        args = ["checkout", "-q"] + (["-b"] if create else []) + [branch]

        run_git(args, self.path, self.tick)

    def mv(self, src: str, dst: str) -> None:

        run_git(["mv", src, dst], self.path, self.tick)

    def rm(self, rel: str) -> None:

        run_git(["rm", "-q", rel], self.path, self.tick)

def text_resolution(path: str, content: str) -> dict[str, object]:

    data = content.encode()

    return {"path": path, "content_sha256": sha256_hex(data), "content": content}

def binary_resolution(path: str, data: bytes) -> dict[str, object]:

    return {"path": path, "content_sha256": sha256_hex(data),

            "content_b64": base64.b64encode(data).decode()}

def source_lines(seed: str, kind: str, count: int) -> list[str]:

    rng = make_rng(seed, kind, "base")

    lines = [f"# {GENERATOR_VERSION} {kind}"]

    for i in range(count - 1):

        w = [rng.choice(WORDS) for _ in range(4)]

        lines.append(f"{w[0]}_{i} = {w[1]}({w[2]}, {w[3]})  # line {i}")

    return lines

def variant_line(seed: str, kind: str, side: str, region: int) -> str:

    rng = make_rng(seed, kind, side, region)

    w = [rng.choice(WORDS) for _ in range(3)]

    return f"{side}_{region} = {w[0]}({w[1]}, {w[2]})  # {side} rewrite r{region}"

def region_positions(seed: str, kind: str, count: int, regions: int) -> list[int]:

    segment = max(1, (count - 4) // regions)

    rng = make_rng(seed, kind, "regions")

    return [min(count - 2, 2 + i * segment + rng.randrange(max(1, segment - 2)))

            for i in range(regions)]

# --- kind builders ----------------------------------------------------------

# Each builder populates an initialized Repo (leaving HEAD on `ours` with a

# clean tree) and returns the oracle body for the sidecar.

def build_text_overlap(kind: str, repo: Repo, seed: str, quick: bool) -> dict[str, object]:

    full, quick_lines, regions = TEXT_OVERLAP_SHAPES[kind]

    count = quick_lines if quick else full

    path = "src/module.py"

    base = source_lines(seed, kind, count)

    positions = region_positions(seed, kind, count, regions)

    repo.write(path, ("\n".join(base) + "\n").encode())

    repo.commit(f"base: {kind} ({count} lines, {regions} regions)")

    ours = list(base)

    theirs = list(base)

    resolved = list(base)

    for ridx, pos in enumerate(positions):

        ours[pos] = variant_line(seed, kind, "ours", ridx)

        theirs[pos] = variant_line(seed, kind, "theirs", ridx)

        # Each earlier region inserted one extra line into `resolved`.

        resolved[pos + ridx:pos + ridx + 1] = [ours[pos], theirs[pos]]

    repo.checkout("ours", create=True)

    repo.write(path, ("\n".join(ours) + "\n").encode())

    repo.commit("ours: rewrite conflict regions")

    repo.checkout("main")

    repo.checkout("theirs", create=True)

    repo.write(path, ("\n".join(theirs) + "\n").encode())

    repo.commit("theirs: rewrite conflict regions")

    repo.checkout("ours")

    return {

        "expected_conflict": True,

        "conflicted_paths": [path],

        "resolution": text_resolution(path, "\n".join(resolved) + "\n"),

        "post_merge_check": None,

    }

def build_adjacent_lines(kind: str, repo: Repo, seed: str, quick: bool) -> dict[str, object]:

    rng = make_rng(seed, kind, "items")

    n = 8

    items = [f"{rng.choice(WORDS)}-{rng.randrange(1000)}" for _ in range(n)]

    ours_item = f"ours-{make_rng(seed, kind, 'ours').choice(WORDS)}"

    theirs_item = f"theirs-{make_rng(seed, kind, 'theirs').choice(WORDS)}"

    def data_py(entries: list[str], expected: int) -> str:

        body = "\n".join(f'    "{e}",' for e in entries)

        return f"ITEMS = [\n{body}\n]\nEXPECTED_COUNT = {expected}\n"

    repo.write("data.py", data_py(items, n).encode())

    repo.write("check.py", CHECK_PY.encode())

    repo.commit("base: data.py invariant guarded by check.py")

    # ours prepends + bumps the count; theirs appends + bumps the count.

    # The count bumps are identical, the list edits do not overlap, so the

    # merge is CLEAN — but the merged list has n+2 items vs EXPECTED_COUNT n+1.

    repo.checkout("ours", create=True)

    repo.write("data.py", data_py([ours_item] + items, n + 1).encode())

    repo.commit("ours: prepend item, bump count")

    repo.checkout("main")

    repo.checkout("theirs", create=True)

    repo.write("data.py", data_py(items + [theirs_item], n + 1).encode())

    repo.commit("theirs: append item, bump count")

    repo.checkout("ours")

    resolved = data_py([ours_item] + items + [theirs_item], n + 2)

    return {

        "expected_conflict": False,

        "conflicted_paths": [],

        "resolution": text_resolution("data.py", resolved),

        "post_merge_check": {

            "command": ["python3", "check.py"],

            "expected_returncode_clean_merge": 1,

        },

    }

def build_rename_rename(kind: str, repo: Repo, seed: str, quick: bool) -> dict[str, object]:

    content = "\n".join(source_lines(seed, kind, 16)) + "\n"

    repo.write("src/util.py", content.encode())

    repo.commit("base: src/util.py")

    repo.checkout("ours", create=True)

    repo.mv("src/util.py", "src/helpers.py")

    repo.commit("ours: rename util.py -> helpers.py")

    repo.checkout("main")

    repo.checkout("theirs", create=True)

    repo.mv("src/util.py", "src/tools.py")

    repo.commit("theirs: rename util.py -> tools.py")

    repo.checkout("ours")

    return {

        "expected_conflict": True,

        "conflicted_paths": ["src/helpers.py", "src/tools.py", "src/util.py"],

        "resolution": text_resolution("src/helpers.py", content),

        "post_merge_check": None,

    }

def build_rename_edit(kind: str, repo: Repo, seed: str, quick: bool) -> dict[str, object]:

    count = 12 if quick else 24

    base = source_lines(seed, kind, count)

    pos = region_positions(seed, kind, count, 1)[0]

    repo.write("src/config.py", ("\n".join(base) + "\n").encode())

    repo.commit("base: src/config.py")

    ours = list(base)

    ours[pos] = variant_line(seed, kind, "ours", 0)

    theirs = list(base)

    theirs[pos] = variant_line(seed, kind, "theirs", 0)

    resolved = list(base)

    resolved[pos:pos + 1] = [ours[pos], theirs[pos]]

    repo.checkout("ours", create=True)

    repo.mv("src/config.py", "src/settings.py")

    repo.write("src/settings.py", ("\n".join(ours) + "\n").encode())

    repo.commit("ours: rename config.py -> settings.py and edit")

    repo.checkout("main")

    repo.checkout("theirs", create=True)

    repo.write("src/config.py", ("\n".join(theirs) + "\n").encode())

    repo.commit("theirs: edit config.py in place")

    repo.checkout("ours")

    return {

        "expected_conflict": True,

        "conflicted_paths": ["src/settings.py"],

        "resolution": text_resolution("src/settings.py", "\n".join(resolved) + "\n"),

        "post_merge_check": None,

    }

def build_delete_edit(kind: str, repo: Repo, seed: str, quick: bool) -> dict[str, object]:

    count = 12 if quick else 24

    base = source_lines(seed, kind, count)

    pos = region_positions(seed, kind, count, 1)[0]

    repo.write("src/legacy.py", ("\n".join(base) + "\n").encode())

    repo.commit("base: src/legacy.py")

    theirs = list(base)

    theirs[pos] = variant_line(seed, kind, "theirs", 0)

    repo.checkout("ours", create=True)

    repo.rm("src/legacy.py")

    repo.commit("ours: delete legacy.py")

    repo.checkout("main")

    repo.checkout("theirs", create=True)

    repo.write("src/legacy.py", ("\n".join(theirs) + "\n").encode())

    repo.commit("theirs: edit legacy.py")

    repo.checkout("ours")

    # Correct resolution: the edit proves the file is still live; keep theirs.

    return {

        "expected_conflict": True,

        "conflicted_paths": ["src/legacy.py"],

        "resolution": text_resolution("src/legacy.py", "\n".join(theirs) + "\n"),

        "post_merge_check": None,

    }

def build_binary_binary(kind: str, repo: Repo, seed: str, quick: bool) -> dict[str, object]:

    size = 64 if quick else 4096

    # Leading NUL guarantees git treats the blob as binary.

    blob = lambda side: b"\x00\xff" + make_rng(seed, kind, side).randbytes(size)  # noqa: E731

    repo.write("assets/logo.bin", blob("base"))

    repo.commit("base: assets/logo.bin")

    repo.checkout("ours", create=True)

    repo.write("assets/logo.bin", blob("ours"))

    repo.commit("ours: regenerate logo")

    repo.checkout("main")

    repo.checkout("theirs", create=True)

    theirs_bytes = blob("theirs")

    repo.write("assets/logo.bin", theirs_bytes)

    repo.commit("theirs: regenerate logo")

    repo.checkout("ours")

    # Binary has no textual merge; the canonical resolution takes theirs

    # (declared the newer asset export).

    return {

        "expected_conflict": True,

        "conflicted_paths": ["assets/logo.bin"],

        "resolution": binary_resolution("assets/logo.bin", theirs_bytes),

        "post_merge_check": None,

    }

def _integrity(seed: str, name: str, version: str) -> str:

    digest = hashlib.sha512(f"{seed}:{name}@{version}".encode()).digest()

    return "sha512-" + base64.b64encode(digest).decode()

def _lockfile_text(seed: str, pinned: dict[str, str], ranges: dict[str, str]) -> str:

    packages: dict[str, object] = {

        "": {"name": "fixture-app", "version": "1.0.0", "dependencies": ranges},

    }

    for name in sorted(pinned):

        version = pinned[name]

        packages[f"node_modules/{name}"] = {

            "version": version,

            "resolved": f"https://registry.example/{name}/-/{name}-{version}.tgz",

            "integrity": _integrity(seed, name, version),

        }

    doc = {

        "name": "fixture-app",

        "version": "1.0.0",

        "lockfileVersion": 3,

        "requires": True,

        "packages": packages,

    }

    return json.dumps(doc, indent=2) + "\n"

def build_lockfile(kind: str, repo: Repo, seed: str, quick: bool) -> dict[str, object]:

    ranges = {"alpha-core": "^1.4.0", "pad-utils": "^1.0.0", "zeta-utils": "^2.1.0"}

    base_pins = {"alpha-core": "1.4.2", "pad-utils": "1.1.0", "zeta-utils": "2.1.3"}

    package_json = json.dumps(

        {"name": "fixture-app", "version": "1.0.0", "dependencies": ranges},

        indent=2) + "\n"

    repo.write("package.json", package_json.encode())

    repo.write("package-lock.json", _lockfile_text(seed, base_pins, ranges).encode())

    repo.commit("base: package.json + package-lock.json")

    # Classic agent conflict: each side ran its own install and pinned a

    # different pad-utils version (version/resolved/integrity lines collide).

    repo.checkout("ours", create=True)

    repo.write("package-lock.json",

               _lockfile_text(seed, {**base_pins, "pad-utils": "1.2.0"}, ranges).encode())

    repo.commit("ours: lockfile pins pad-utils 1.2.0")

    repo.checkout("main")

    repo.checkout("theirs", create=True)

    repo.write("package-lock.json",

               _lockfile_text(seed, {**base_pins, "pad-utils": "1.3.0"}, ranges).encode())

    repo.commit("theirs: lockfile pins pad-utils 1.3.0")

    repo.checkout("ours")

    # Correct resolution: the highest compatible pin wins (theirs, 1.3.0).

    resolved = _lockfile_text(seed, {**base_pins, "pad-utils": "1.3.0"}, ranges)

    return {

        "expected_conflict": True,

        "conflicted_paths": ["package-lock.json"],

        "resolution": text_resolution("package-lock.json", resolved),

        "post_merge_check": None,

    }

BUILDERS = {

    "text-overlap-small": build_text_overlap,

    "text-overlap-medium": build_text_overlap,

    "text-overlap-large": build_text_overlap,

    "adjacent-lines": build_adjacent_lines,

    "rename-rename": build_rename_rename,

    "rename-edit": build_rename_edit,

    "delete-edit": build_delete_edit,

    "binary-binary": build_binary_binary,

    "lockfile": build_lockfile,

}

# --- self-test ---------------------------------------------------------------

def resolution_bytes(resolution: dict[str, object]) -> bytes:

    if "content" in resolution:

        return str(resolution["content"]).encode()

    return base64.b64decode(str(resolution["content_b64"]))

def verify_kind(repo_path: Path, oracle: dict[str, object]) -> list[str]:

    """Re-run the merge in a scratch clone and check it against the oracle."""

    problems: list[str] = []

    resolution = oracle["resolution"]

    if sha256_hex(resolution_bytes(resolution)) != resolution["content_sha256"]:

        problems.append("resolution content does not match its content_sha256")

    scratch_root = tempfile.mkdtemp(prefix="conflict-verify-")

    scratch = Path(scratch_root) / "clone"

    try:

        run_git(["clone", "--quiet", str(repo_path), str(scratch)], repo_path.parent)

        run_git(["branch", "theirs", "origin/theirs"], scratch)

        check = oracle["post_merge_check"]

        if check is not None:

            # Both sides must pass the check on their own branch first.

            for branch in ("theirs", "ours"):

                run_git(["checkout", "-q", branch], scratch)

                pre = subprocess.run(check["command"], cwd=scratch,

                                     capture_output=True, text=True)

                if pre.returncode != 0:

                    problems.append(f"pre-merge check failed on branch {branch}")

        merge = run_git(["merge", "--no-edit", "theirs"], scratch,

                        tick=1000, check=False)

        conflicted = merge.returncode != 0

        if conflicted != oracle["expected_conflict"]:

            problems.append(

                f"merge outcome mismatch: conflicted={conflicted}, "

                f"expected_conflict={oracle['expected_conflict']}")

        unmerged = run_git(["diff", "--name-only", "--diff-filter=U"], scratch)

        observed = sorted(p for p in unmerged.stdout.splitlines() if p)

        if observed != list(oracle["conflicted_paths"]):

            problems.append(

                f"conflicted paths mismatch: observed={observed}, "

                f"oracle={oracle['conflicted_paths']}")

        if check is not None and not conflicted:

            post = subprocess.run(check["command"], cwd=scratch,

                                  capture_output=True, text=True)

            if post.returncode != check["expected_returncode_clean_merge"]:

                problems.append(

                    f"post-merge check returned {post.returncode}, expected "

                    f"{check['expected_returncode_clean_merge']} (build should break)")

    finally:

        shutil.rmtree(scratch_root, ignore_errors=True)

    return problems

# --- entry point -------------------------------------------------------------

def generate_kind(out: Path, kind: str, seed: str, quick: bool) -> dict[str, object]:

    repo = Repo(out / kind)

    body = BUILDERS[kind](kind, repo, seed, quick)

    oracle = {

        "schema_version": SCHEMA_VERSION,

        "kind": kind,

        "seed": seed,

        "generator_version": GENERATOR_VERSION,

        "expected_conflict": body["expected_conflict"],

        "conflicted_paths": body["conflicted_paths"],

        "resolution": body["resolution"],

        "post_merge_check": body["post_merge_check"],

    }

    sidecar = out / f"{kind}{ORACLE_SUFFIX}"

    sidecar.write_text(json.dumps(oracle, indent=2) + "\n")

    return oracle

def parse_args(argv: list[str] | None = None) -> argparse.Namespace:

    ap = argparse.ArgumentParser(

        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)

    ap.add_argument("--out", type=Path, required=True,

                    help="corpus root; one repo per kind plus oracle sidecars")

    ap.add_argument("--seed", required=True)

    ap.add_argument("--kinds", default=",".join(KINDS),

                    help=f"comma-separated subset of: {', '.join(KINDS)}")

    ap.add_argument("--quick", action="store_true", help="tiny sizes for tests")

    return ap.parse_args(argv)

def main(argv: list[str] | None = None) -> int:

    args = parse_args(argv)

    if shutil.which("git") is None:

        print("make_conflict_corpus: git not found on PATH; cannot generate "

              "fixture — record this run as skipped, not failed", file=sys.stderr)

        return 3

    kinds = [k.strip() for k in args.kinds.split(",") if k.strip()]

    unknown = [k for k in kinds if k not in BUILDERS]

    if unknown or not kinds:

        print(f"unknown kinds: {', '.join(unknown) or '(none requested)'}; "

              f"valid: {', '.join(KINDS)}", file=sys.stderr)

        return 1

    out = args.out

    out.mkdir(parents=True, exist_ok=True)

    for kind in kinds:

        kind_dir = out / kind

        if kind_dir.exists() and any(kind_dir.iterdir()):

            print(f"refusing to write into non-empty {kind_dir}", file=sys.stderr)

            return 1

    failures = 0

    for kind in kinds:

        oracle = generate_kind(out, kind, args.seed, args.quick)

        problems = verify_kind(out / kind, oracle)

        if problems:

            failures += 1

            for problem in problems:

                print(f"{kind}: SELF-TEST FAILED: {problem}", file=sys.stderr)

        else:

            print(f"{kind}: expected_conflict={oracle['expected_conflict']} "

                  f"conflicted_paths={len(oracle['conflicted_paths'])} verified")

    if failures:

        print(f"{failures} kind(s) failed self-test", file=sys.stderr)

        return 1

    print(f"{GENERATOR_VERSION} seed={args.seed} kinds={len(kinds)} -> {out}")

    return 0

if __name__ == "__main__":

    raise SystemExit(main())