#!/usr/bin/env python3

"""Import GitGoodBench dataset exports (CSV or JSONL) into Oak benchmark scenarios.

Dataset: GitGoodBench -- Tobias Lindenbauer, Egor Bogomolov, and Yaroslav

Zharov, "GitGoodBench: A Novel Benchmark For Evaluating Agentic Performance

On Git" (REALM 2025, doi:10.18653/v1/2025.realm-1.19). Apache-2.0 licensed,

distributed as HuggingFace datasets (JetBrains/git_good_bench,

JetBrains/git_good_bench-lite, JetBrains/git_good_bench-train). The authors'

released harness is NOT runnable (proprietary code was removed before

publication), so imported scenarios execute in OUR agent lane instead.

Clean-room rule: no prompts or tool code are copied from the upstream

repository; only published dataset rows are consumed.

Export locally with the HuggingFace `datasets` package (docstring guidance

only -- this importer is stdlib-only, never touches the network, and consumes

LOCAL files exclusively):

    datasets.load_dataset("JetBrains/git_good_bench-lite")["train"].to_csv("lite.csv")

``--csv`` accepts the resulting ``.csv`` or a ``.jsonl`` export (sniffed by

file extension).

Real schema columns: id, name (owner/repository), default_branch, license,

stargazers, created_at, topics (semicolon-delimited), programming_language,

scenario (embedded structured per-scenario data), sample_type, project_size,

difficulty. Raw HuggingFace CSV rows currently encode ``scenario`` as a

Python-literal dict string; JSONL exports may carry JSON strings or already

structured values. ``sample_type`` takes exactly two values:

    merge              a historical merge with one or more conflicts

    file_commit_chain  two commits bounding a chain where one file changed in

                       every intermediate commit

Canonical mapping (used whenever a row carries ``sample_type``):

    sample_type "merge"             -> scenario_type "merge_conflict_resolution"

    sample_type "file_commit_chain" -> EXPANDED into TWO emitted scenarios:

        <id>--rebase   scenario_type "interactive_rebase"

        <id>--commits  scenario_type "iterative_commit"

Repo comes from "name", scenario id from "id" (row index fallback);

difficulty / programming_language / default_branch are carried through onto

every emitted scenario under "metadata". The "scenario" column is parsed as

JSON first, then as a Python literal for the raw HuggingFace CSV export, and

embedded verbatim as "source_scenario"; its exact inner keys are not pinned

publicly, so the merge commit is extracted liberally (keys containing

"merge_commit", then "hash", then "sha"). Unparseable scenario data turns

that sample into a skip entry with reason ``scenario_json_unparseable``.

Legacy fallback (rows WITHOUT a sample_type column -- old synthetic fixtures

and unknown exports; the canonical path takes precedence):

    repo           <- repo | repository | repo_name

    scenario_type  <- scenario_type | type | task_type

    commit         <- commit | sha | merge_commit_sha

    scenario_id    <- id | scenario_id

Mirrors are expected under ``--mirror-root`` as ``<owner>__<repo>/`` (bare or

worktree clones; a ``<owner>__<repo>.git/`` bare directory is also accepted).

A missing mirror skips that scenario with reason ``mirror_missing:<owner>/<repo>``

(pointer datasets rot; skip-row honesty over hard errors, mirroring

``scripts/mount_probe.py`` and ``scripts/oakbench/rows.py``).

Oracle modes are RECORDED here, not evaluated: ``strict-em`` / ``normalized``

apply to merge_conflict_resolution scenarios. interactive_rebase and

iterative_commit scenarios record oracle null with note

``oracle_defined_at_runtime:tree_equivalence`` -- their oracles are

tree/history equivalence checks performed by the agent lane later.

Exit codes: 0 if any scenario is ready; 3 if the dataset file is missing

(skip JSON ``{"status": "skipped", "reason": "dataset_missing:<path>"}`` on

stdout) or present but nothing is materializable; 2 on usage errors.

"""

from __future__ import annotations

import argparse

import ast

import csv

import json

import sys

from pathlib import Path

from typing import Any, Iterator, Optional

SCHEMA_VERSION = 2

SOURCE = "gitgoodbench"

LICENSE = "Apache-2.0"

CITATION = "lindenbauer-etal-2025-gitgoodbench (REALM 2025, doi:10.18653/v1/2025.realm-1.19)"

SOURCE_DATASETS = [

    "JetBrains/git_good_bench",

    "JetBrains/git_good_bench-lite",

    "JetBrains/git_good_bench-train",

]

EXIT_OK = 0

EXIT_USAGE = 2

EXIT_SKIP = 3

ORACLE_STRICT_EM = "strict-em"

ORACLE_NORMALIZED = "normalized"

NORMALIZATION_NORMALIZED = "whitespace_and_blank_lines"

ORACLE_NOTE_RUNTIME = "oracle_defined_at_runtime:tree_equivalence"

# Canonical (real published schema) columns.

SAMPLE_TYPE_COLUMNS = ("sample_type",)

NAME_COLUMNS = ("name",)

CANONICAL_ID_COLUMNS = ("id",)

SAMPLE_TYPE_MERGE = "merge"

SAMPLE_TYPE_CHAIN = "file_commit_chain"

# Legacy liberal fallback columns (old synthetic fixtures, unknown exports).

REPO_COLUMNS = ("repo", "repository", "repo_name")

TYPE_COLUMNS = ("scenario_type", "type", "task_type")

COMMIT_COLUMNS = ("commit", "sha", "merge_commit_sha")

ID_COLUMNS = ("id", "scenario_id")

TYPE_MERGE = "merge_conflict_resolution"

TYPE_REBASE = "interactive_rebase"

TYPE_ITERATIVE_COMMIT = "iterative_commit"

ROW_ERROR_KEY = "__row_error__"

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

    parser = argparse.ArgumentParser(

        description="Import a GitGoodBench export (CSV or JSONL) into scenarios JSON."

    )

    parser.add_argument(

        "--csv",

        type=Path,

        required=True,

        help="Local path to a dataset export: .csv or .jsonl (sniffed by extension)",

    )

    parser.add_argument(

        "--mirror-root",

        type=Path,

        required=True,

        help="Directory containing mirrored repos as <owner>__<repo>/ (bare or worktree clones)",

    )

    parser.add_argument("--out", type=Path, required=True, help="Path to write the scenarios JSON")

    parser.add_argument(

        "--oracle",

        choices=[ORACLE_STRICT_EM, ORACLE_NORMALIZED],

        default=ORACLE_STRICT_EM,

        help="Oracle mode recorded per merge scenario (recorded only; evaluation lives in the agent lane)",

    )

    return parser.parse_args(argv)

def pick_column(row: dict[str, Any], names: tuple[str, ...]) -> Optional[str]:

    lowered = {str(key).strip().lower(): value for key, value in row.items() if key is not None}

    for name in names:

        value = lowered.get(name)

        if value is not None and str(value).strip():

            return str(value).strip()

    return None

def raw_field(row: dict[str, Any], name: str) -> Any:

    """Case-insensitive raw lookup (JSONL rows may carry non-string values)."""

    for key, value in row.items():

        if key is not None and str(key).strip().lower() == name:

            return value

    return None

def normalize_scenario_type(raw: Optional[str]) -> Optional[str]:

    if not raw:

        return None

    text = raw.strip().lower()

    if "merge" in text:

        return TYPE_MERGE

    if "rebase" in text:

        return TYPE_REBASE

    if "commit" in text or "iterative" in text:

        return TYPE_ITERATIVE_COMMIT

    return None

def mirror_path_for(mirror_root: Path, repo: str) -> Optional[Path]:

    """Return the existing mirror directory for owner/repo, or None."""

    slug = repo.strip().strip("/").replace("/", "__")

    for candidate in (mirror_root / slug, mirror_root / f"{slug}.git"):

        if candidate.is_dir():

            return candidate

    return None

def oracle_record(mode: str) -> dict[str, Any]:

    return {

        "mode": mode,

        "normalization": NORMALIZATION_NORMALIZED if mode == ORACLE_NORMALIZED else None,

    }

def _walk_scalar_items(obj: Any) -> Iterator[tuple[str, Any]]:

    """Depth-first (key, scalar value) pairs from nested dicts/lists."""

    if isinstance(obj, dict):

        for key, value in obj.items():

            if isinstance(value, (dict, list)):

                yield from _walk_scalar_items(value)

            else:

                yield str(key).strip().lower(), value

    elif isinstance(obj, list):

        for item in obj:

            yield from _walk_scalar_items(item)

def extract_merge_commit(scenario_obj: Any) -> Optional[str]:

    """Liberal extraction: keys containing merge_commit, then hash, then sha."""

    items = list(_walk_scalar_items(scenario_obj))

    for needle in ("merge_commit", "hash", "sha"):

        for key, value in items:

            if needle in key and isinstance(value, str) and value.strip():

                return value.strip()

    return None

def parse_scenario_field(row: dict[str, Any]) -> tuple[Any, bool]:

    """Parse the 'scenario' column. Returns (parsed, ok)."""

    raw = raw_field(row, "scenario")

    if isinstance(raw, (dict, list)):

        return raw, True  # already structured (e.g. a generous JSONL export)

    if raw is None or not str(raw).strip():

        return None, False

    # Both parse paths accept only structured (dict/list) results: a scalar

    # scenario column carries no scenario data and must skip, not go ready.

    try:

        parsed = json.loads(str(raw))

    except (json.JSONDecodeError, ValueError):

        try:

            parsed = ast.literal_eval(str(raw))

        except (SyntaxError, ValueError):

            return None, False

    if isinstance(parsed, (dict, list)):

        return parsed, True

    return None, False

def base_entry(

    scenario_id: str,

    scenario_type: Optional[str],

    sample_type: Optional[str],

    repo: Optional[str],

    metadata: Optional[dict[str, Any]],

) -> dict[str, Any]:

    return {

        "scenario_id": scenario_id,

        "scenario_type": scenario_type,

        "sample_type": sample_type,

        "repo": repo,

        "mirror_path": None,

        "commit": None,

        "source_scenario": None,

        "metadata": metadata,

        "oracle": None,

        "oracle_note": None,

        "status": "skipped",

        "skip_reason": None,

    }

def build_canonical(

    row: dict[str, Any],

    index: int,

    mirror_root: Path,

    oracle_mode: str,

    sample_type: str,

) -> list[dict[str, Any]]:

    """Canonical path for rows carrying the real published schema."""

    base_id = pick_column(row, CANONICAL_ID_COLUMNS) or f"{SOURCE}-row-{index}"

    repo = pick_column(row, NAME_COLUMNS)

    metadata = {

        "difficulty": pick_column(row, ("difficulty",)),

        "programming_language": pick_column(row, ("programming_language",)),

        "default_branch": pick_column(row, ("default_branch",)),

    }

    normalized_sample_type = sample_type.strip().lower()

    if normalized_sample_type == SAMPLE_TYPE_MERGE:

        specs = [(base_id, TYPE_MERGE)]

    elif normalized_sample_type == SAMPLE_TYPE_CHAIN:

        specs = [

            (f"{base_id}--rebase", TYPE_REBASE),

            (f"{base_id}--commits", TYPE_ITERATIVE_COMMIT),

        ]

    else:

        entry = base_entry(base_id, None, sample_type, repo, metadata)

        entry["skip_reason"] = f"unrecognized_sample_type:{sample_type}"

        return [entry]

    source_scenario, parsed_ok = parse_scenario_field(row)

    if not parsed_ok:

        entry = base_entry(base_id, None, sample_type, repo, metadata)

        entry["skip_reason"] = "scenario_json_unparseable"

        return [entry]

    merge_commit = extract_merge_commit(source_scenario)

    entries: list[dict[str, Any]] = []

    for scenario_id, scenario_type in specs:

        entry = base_entry(scenario_id, scenario_type, sample_type, repo, metadata)

        entry["source_scenario"] = source_scenario

        if scenario_type == TYPE_MERGE:

            entry["commit"] = merge_commit

        if not repo:

            entry["skip_reason"] = "missing_repo"

            entries.append(entry)

            continue

        mirror = mirror_path_for(mirror_root, repo)

        if mirror is None:

            entry["skip_reason"] = f"mirror_missing:{repo}"

            entries.append(entry)

            continue

        entry["mirror_path"] = str(mirror)

        entry["status"] = "ready"

        if scenario_type == TYPE_MERGE:

            entry["oracle"] = oracle_record(oracle_mode)

        else:

            entry["oracle"] = None

            entry["oracle_note"] = ORACLE_NOTE_RUNTIME

        entries.append(entry)

    return entries

def build_legacy(

    row: dict[str, Any],

    index: int,

    mirror_root: Path,

    oracle_mode: str,

) -> dict[str, Any]:

    """Legacy liberal fallback for rows without a sample_type column."""

    repo = pick_column(row, REPO_COLUMNS)

    raw_type = pick_column(row, TYPE_COLUMNS)

    commit = pick_column(row, COMMIT_COLUMNS)

    scenario_id = pick_column(row, ID_COLUMNS) or f"{SOURCE}-row-{index}"

    scenario_type = normalize_scenario_type(raw_type)

    entry = base_entry(scenario_id, scenario_type, None, repo, None)

    entry["commit"] = commit

    if scenario_type is None:

        entry["skip_reason"] = f"unrecognized_scenario_type:{raw_type or ''}"

        return entry

    if not repo:

        entry["skip_reason"] = "missing_repo"

        return entry

    mirror = mirror_path_for(mirror_root, repo)

    if mirror is None:

        entry["skip_reason"] = f"mirror_missing:{repo}"

        return entry

    entry["mirror_path"] = str(mirror)

    entry["status"] = "ready"

    if scenario_type == TYPE_MERGE:

        entry["oracle"] = oracle_record(oracle_mode)

    else:

        entry["oracle"] = None

        entry["oracle_note"] = ORACLE_NOTE_RUNTIME

    return entry

def build_from_row(

    row: dict[str, Any],

    index: int,

    mirror_root: Path,

    oracle_mode: str,

) -> list[dict[str, Any]]:

    row_error = row.get(ROW_ERROR_KEY)

    if row_error:

        entry = base_entry(f"{SOURCE}-row-{index}", None, None, None, None)

        entry["skip_reason"] = str(row_error)

        return [entry]

    sample_type = pick_column(row, SAMPLE_TYPE_COLUMNS)

    if sample_type:

        return build_canonical(row, index, mirror_root, oracle_mode, sample_type)

    return [build_legacy(row, index, mirror_root, oracle_mode)]

def read_rows(path: Path) -> Iterator[dict[str, Any]]:

    """Yield row dicts from a .csv or .jsonl export (sniffed by extension)."""

    if path.suffix.lower() == ".jsonl":

        with path.open(encoding="utf-8") as fh:

            for line in fh:

                text = line.strip()

                if not text:

                    continue

                try:

                    obj = json.loads(text)

                except json.JSONDecodeError:

                    yield {ROW_ERROR_KEY: "row_json_unparseable"}

                    continue

                if isinstance(obj, dict):

                    yield obj

                else:

                    yield {ROW_ERROR_KEY: "row_not_an_object"}

    else:

        with path.open(newline="", encoding="utf-8") as fh:

            yield from csv.DictReader(fh)

def import_dataset(dataset_path: Path, mirror_root: Path, oracle_mode: str) -> dict[str, Any]:

    scenarios: list[dict[str, Any]] = []

    for index, row in enumerate(read_rows(dataset_path)):

        scenarios.extend(build_from_row(row, index, mirror_root, oracle_mode))

    ready = sum(1 for item in scenarios if item["status"] == "ready")

    skipped = sum(1 for item in scenarios if item["status"] == "skipped")

    return {

        "schema_version": SCHEMA_VERSION,

        "source": SOURCE,

        "license": LICENSE,

        "citation": CITATION,

        "source_datasets": SOURCE_DATASETS,

        "oracle_mode": oracle_mode,

        "scenarios": scenarios,

        "counts": {"ready": ready, "skipped": skipped},

    }

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

    args = parse_args(argv)

    if not args.csv.is_file():

        print(json.dumps({"status": "skipped", "reason": f"dataset_missing:{args.csv}"}))

        return EXIT_SKIP

    document = import_dataset(args.csv, args.mirror_root, args.oracle)

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

    args.out.write_text(json.dumps(document, indent=2, sort_keys=True) + "\n")

    print(f"[result] {args.out}", file=sys.stderr)

    if document["counts"]["ready"] > 0:

        return EXIT_OK

    return EXIT_SKIP

if __name__ == "__main__":

    raise SystemExit(main())