jar_genesis/workflow/

merge.rs

use std::path::Path;

use crate::cache;
use crate::git;
use crate::github;
use crate::lean;
use crate::replay;
use crate::review;
use crate::snapshot;
use crate::types::{MergeReadiness, SelectTargetsOutput};

/// Run the merge workflow for a PR.
pub fn run(pr: u64, founder_override: bool) -> Result<(), Box<dyn std::error::Error>> {
    // --- Step 0: Guard against non-open PRs ---
    let state_json = github::pr_view(pr, "state")?;
    let state = state_json["state"].as_str().unwrap_or("");
    if state != "OPEN" {
        return Err(format!("PR #{pr} is not open (state: {state})").into());
    }

    let repo_root = git::repo_root()?;
    let spec_dir = Path::new(&repo_root).join("spec");

    // --- Step 1: Read and verify cache ---
    git::fetch("origin", "genesis-state")?;
    let cache_json = git::show_file("origin/genesis-state:genesis.json")?;
    let cache_indices: Vec<serde_json::Value> = serde_json::from_str(&cache_json)?;

    if let Err(e) = cache::check_staleness(&cache_indices, &spec_dir) {
        github::pr_comment(
            pr,
            &format!("**JAR Bot:** Genesis cache is stale — cannot merge. {e}"),
        )?;
        return Err(e.into());
    }

    // --- Step 2: Get PR details ---
    let pr_json = github::pr_view(pr, "headRefOid,author,createdAt,body")?;
    let head_sha = pr_json["headRefOid"].as_str().unwrap_or("").to_string();
    let mut author = pr_json["author"]["login"]
        .as_str()
        .unwrap_or("")
        .to_string();
    let pr_created_at = pr_json["createdAt"].as_str().unwrap_or("");
    let pr_body = pr_json["body"].as_str().unwrap_or("");

    let pr_created_epoch = parse_epoch(pr_created_at)?;

    // Parse PR body flags
    if let Some(genesis_author) = parse_flag(pr_body, "Set-Genesis-Author") {
        author = genesis_author;
    }

    // --- Step 3: Compute comparison targets ---
    let ranking_json =
        git::show_file("origin/genesis-state:ranking.json").unwrap_or_else(|_| "{}".to_string());
    let ranking_map: serde_json::Value = serde_json::from_str(&ranking_json)?;
    let scores_json =
        git::show_file("origin/genesis-state:scores.json").unwrap_or_else(|_| "{}".to_string());
    let scores_map: serde_json::Value = serde_json::from_str(&scores_json)?;

    let snap = snapshot::find(&cache_indices, &ranking_map, &scores_map, pr_created_epoch)?;

    let mut targets_input = serde_json::json!({
        "prId": pr,
        "prCreatedAt": pr_created_epoch,
        "indices": cache_indices,
    });
    if let Some(s) = &snap {
        targets_input["ranking"] = s.ranking.clone();
        if let Some(v) = &s.variances {
            targets_input["variances"] = v.clone();
        }
    }

    let targets_output: SelectTargetsOutput =
        lean::invoke("genesis_select_targets", &targets_input, &spec_dir)?;
    let targets = targets_output.targets;

    // --- Step 4: Check no commits after last review ---
    check_no_new_commits(pr)?;

    // --- Step 5: Collect reviews ---
    let collected = review::collect(pr, &head_sha, &targets)?;

    // --- Step 6: Re-check quorum (defense-in-depth) ---
    let check_input = serde_json::json!({
        "reviews": collected.reviews,
        "metaReviews": collected.meta_reviews,
        "indices": cache_indices,
    });
    let readiness: MergeReadiness = lean::invoke("genesis_check_merge", &check_input, &spec_dir)?;

    if !readiness.ready && !founder_override {
        github::pr_comment(
            pr,
            &format!(
                "**JAR Bot:** Quorum not reached — cannot merge.\n\
                 Merge weight: {}/{} (need >50%).",
                readiness.merge_weight, readiness.total_weight
            ),
        )?;
        return Err("quorum not reached".into());
    }

    let merge_type = if founder_override {
        "founder override"
    } else {
        "quorum reached"
    };

    // --- Step 7: Build SignedCommit and evaluate ---
    let epoch = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)?
        .as_secs();

    let commit_json = serde_json::json!({
        "id": head_sha,
        "prId": pr,
        "author": author,
        "mergeEpoch": epoch,
        "prCreatedAt": pr_created_epoch,
        "comparisonTargets": targets,
        "reviews": collected.reviews,
        "metaReviews": collected.meta_reviews,
        "founderOverride": founder_override,
    });

    let mut eval_input = serde_json::json!({
        "commit": commit_json,
        "pastIndices": cache_indices,
    });
    if let Some(s) = &snap {
        eval_input["ranking"] = s.ranking.clone();
        if let Some(v) = &s.variances {
            eval_input["variances"] = v.clone();
        }
    }

    let index: serde_json::Value = lean::invoke("genesis_evaluate", &eval_input, &spec_dir)?;

    let score = &index["score"];
    let weight_delta = index["weightDelta"].as_u64().unwrap_or(0);

    // Post warnings
    let mut all_warnings: Vec<String> = collected.warnings.clone();
    if let Some(eval_warnings) = index["warnings"].as_array() {
        for w in eval_warnings {
            if let Some(s) = w.as_str() {
                all_warnings.push(s.to_string());
            }
        }
    }

    if !all_warnings.is_empty() {
        let warning_lines: String = all_warnings.iter().map(|w| format!("- {w}\n")).collect();
        github::pr_comment(
            pr,
            &format!("**JAR Bot:** Evaluation warnings:\n{warning_lines}"),
        )?;
    }

    // Strip warnings from index for trailer
    let mut index_for_trailer = index.clone();
    if let Some(obj) = index_for_trailer.as_object_mut() {
        obj.remove("warnings");
    }

    // --- Step 8: Wait for CI ---
    if github::pr_checks_watch(pr).is_err() {
        github::pr_comment(
            pr,
            &format!("**JAR Bot:** Checks failed — cannot merge ({merge_type})."),
        )?;
        return Err("checks failed".into());
    }

    // --- Step 9: Merge with trailers ---
    let commit_compact = serde_json::to_string(&commit_json)?;
    let index_compact = serde_json::to_string(&index_for_trailer)?;
    let subject = format!(
        "Merge PR #{pr}\n\n\
         Genesis-Commit: {commit_compact}\n\
         Genesis-Index: {index_compact}\n\
         Genesis-PR: #{pr}\n\
         Genesis-Author: {author}"
    );

    github::pr_merge(pr, &head_sha, &subject)?;

    // Confirm merge
    for attempt in 1..=5 {
        let state_json = github::pr_view(pr, "state")?;
        let state = state_json["state"].as_str().unwrap_or("");
        if state == "MERGED" {
            break;
        }
        if attempt == 5 {
            github::pr_comment(
                pr,
                &format!("**JAR Bot:** Merge failed unexpectedly (state: {state})."),
            )?;
            return Err(format!("PR #{pr} not merged (state: {state})").into());
        }
        eprintln!("Waiting for merge state propagation (attempt {attempt}, state: {state})...");
        std::thread::sleep(std::time::Duration::from_secs(2));
    }

    github::pr_comment(
        pr,
        &format!(
            "**JAR Bot:** Merged ({merge_type}).\nScore: {}\nWeight delta: {weight_delta}",
            serde_json::to_string(score)?
        ),
    )?;

    // --- Step 10: Update genesis-state cache ---
    update_cache(
        pr,
        &spec_dir,
        &cache_indices,
        &index_for_trailer,
        &commit_json,
    )?;

    // --- Step 11: Verify cache integrity ---
    // Fetch latest master (includes our merge) without touching the working tree.
    git::git_cmd(&["fetch", "origin", "master"])?;
    replay::verify_cache()?;

    Ok(())
}

/// Update the genesis-state branch with the new index and ranking.
fn update_cache(
    pr: u64,
    spec_dir: &Path,
    cache_indices: &[serde_json::Value],
    new_index: &serde_json::Value,
    _new_commit: &serde_json::Value,
) -> Result<(), Box<dyn std::error::Error>> {
    // Update genesis.json
    let mut updated_indices = cache_indices.to_vec();
    updated_indices.push(new_index.clone());

    // Compute updated ranking from all SignedCommits in git history.
    // Use `git fetch` + `origin/master` ref instead of `git pull` to avoid
    // working tree conflicts (cargo build dirties Cargo.lock).
    let genesis_commit = git::read_genesis_commit_hash(spec_dir)?;
    git::git_cmd(&["fetch", "origin", "master"])?;

    let merge_commits = git::log_merge_commits_ref(&genesis_commit, "origin/master")?;
    let mut signed_commits = Vec::new();
    for (_, message) in &merge_commits {
        if let Some(commit_line) = git::parse_trailer(message, "Genesis-Commit")
            && let Ok(mut commit) = serde_json::from_str::<serde_json::Value>(&commit_line)
        {
            crate::replay::expand_review_hashes_public(&mut commit);
            signed_commits.push(commit);
        }
    }

    let ranking_input = serde_json::json!({
        "signedCommits": signed_commits,
        "indices": updated_indices,
    });
    let ranking_output: serde_json::Value =
        lean::invoke("genesis_ranking", &ranking_input, spec_dir)?;
    let new_ranking = &ranking_output["ranking"];

    let new_commit_hash = new_index["commitHash"].as_str().unwrap_or("");

    // Update ranking.json
    let existing_ranking_json =
        git::show_file("origin/genesis-state:ranking.json").unwrap_or_else(|_| "{}".to_string());
    let mut existing_ranking: serde_json::Map<String, serde_json::Value> =
        serde_json::from_str(&existing_ranking_json)?;
    existing_ranking.insert(new_commit_hash.to_string(), new_ranking.clone());

    // Update scores.json (v3 BT output, if present)
    let existing_scores_json =
        git::show_file("origin/genesis-state:scores.json").unwrap_or_else(|_| "{}".to_string());
    let mut existing_scores: serde_json::Map<String, serde_json::Value> =
        serde_json::from_str(&existing_scores_json)?;
    if let Some(scores) = ranking_output.get("scores") {
        existing_scores.insert(new_commit_hash.to_string(), scores.clone());
    }

    // Write to genesis-state branch via worktree
    git::fetch("origin", "genesis-state")?;
    git::git_cmd(&[
        "worktree",
        "add",
        "/tmp/genesis-state",
        "origin/genesis-state",
    ])?;
    git::git_cmd_in(
        "/tmp/genesis-state",
        &["checkout", "-B", "genesis-state", "origin/genesis-state"],
    )?;

    std::fs::write(
        "/tmp/genesis-state/genesis.json",
        serde_json::to_string_pretty(&updated_indices)?,
    )?;
    std::fs::write(
        "/tmp/genesis-state/ranking.json",
        serde_json::to_string_pretty(&serde_json::Value::Object(existing_ranking))?,
    )?;
    std::fs::write(
        "/tmp/genesis-state/scores.json",
        serde_json::to_string_pretty(&serde_json::Value::Object(existing_scores))?,
    )?;

    git::git_cmd_in("/tmp/genesis-state", &["config", "user.name", "JAR Bot"])?;
    git::git_cmd_in(
        "/tmp/genesis-state",
        &["config", "user.email", "legal@bitarray.dev"],
    )?;
    git::git_cmd_in(
        "/tmp/genesis-state",
        &["add", "genesis.json", "ranking.json", "scores.json"],
    )?;
    git::git_cmd_in(
        "/tmp/genesis-state",
        &[
            "commit",
            "-m",
            &format!("genesis: update state for PR #{pr}"),
        ],
    )?;
    git::git_cmd_in("/tmp/genesis-state", &["push", "origin", "genesis-state"])?;
    git::git_cmd(&["worktree", "remove", "/tmp/genesis-state"])?;

    Ok(())
}

fn check_no_new_commits(pr: u64) -> Result<(), Box<dyn std::error::Error>> {
    let repo = std::env::var("GITHUB_REPOSITORY").unwrap_or_else(|_| {
        github::gh(&[
            "repo",
            "view",
            "--json",
            "nameWithOwner",
            "--jq",
            ".nameWithOwner",
        ])
        .unwrap_or_default()
        .trim()
        .to_string()
    });

    let comments_json = github::pr_view(pr, "comments")?;
    let last_review_at = comments_json["comments"].as_array().and_then(|comments| {
        comments
            .iter()
            .rfind(|c| {
                c["body"]
                    .as_str()
                    .map(|b| b.starts_with("/review"))
                    .unwrap_or(false)
            })
            .and_then(|c| c["createdAt"].as_str().map(|s| s.to_string()))
    });

    if let Some(last_review) = last_review_at {
        let commits_output = github::gh(&[
            "api",
            &format!("repos/{repo}/pulls/{pr}/commits"),
            "--jq",
            "last | .commit.committer.date",
        ])?;
        let last_commit_at = commits_output.trim();

        if !last_commit_at.is_empty() && last_commit_at > &last_review {
            github::pr_comment(
                pr,
                &format!(
                    "**JAR Bot:** New commits pushed after the last review (commit: {last_commit_at}, review: {last_review}). Aborting merge — please re-review."
                ),
            )?;
            return Err("commits pushed after last review".into());
        }
    }

    Ok(())
}

fn parse_flag(body: &str, flag: &str) -> Option<String> {
    let prefix = format!("{flag}:");
    for line in body.lines() {
        if line.is_empty() {
            break; // Only check leading lines before first blank line
        }
        if let Some(rest) = line.strip_prefix(&prefix) {
            let value = rest.trim().trim_start_matches('@');
            if !value.is_empty() {
                return Some(value.to_string());
            }
        }
    }
    None
}

fn parse_epoch(iso: &str) -> Result<u64, Box<dyn std::error::Error>> {
    let output = std::process::Command::new("date")
        .args(["-d", iso, "+%s"])
        .output()?;
    if !output.status.success() {
        return Err(format!("failed to parse date '{iso}'").into());
    }
    Ok(String::from_utf8_lossy(&output.stdout).trim().parse()?)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_flag_basic() {
        let body = "Set-Genesis-Author: @alice\n\nThis PR does something.";
        assert_eq!(
            parse_flag(body, "Set-Genesis-Author"),
            Some("alice".to_string())
        );
    }

    #[test]
    fn test_parse_flag_no_at() {
        let body = "Set-Genesis-Author: alice\n\nBody text.";
        assert_eq!(
            parse_flag(body, "Set-Genesis-Author"),
            Some("alice".to_string())
        );
    }

    #[test]
    fn test_parse_flag_missing() {
        let body = "Some other text\n\nBody.";
        assert_eq!(parse_flag(body, "Set-Genesis-Author"), None);
    }

    #[test]
    fn test_parse_flag_after_blank_line_ignored() {
        let body = "\nSet-Genesis-Author: @alice";
        assert_eq!(parse_flag(body, "Set-Genesis-Author"), None);
    }

    #[test]
    fn test_parse_flag_multiple_flags() {
        let body = "Set-Genesis-Author: @alice\nSome-Other-Flag: value\n\nBody text.";
        assert_eq!(
            parse_flag(body, "Set-Genesis-Author"),
            Some("alice".to_string())
        );
        assert_eq!(
            parse_flag(body, "Some-Other-Flag"),
            Some("value".to_string())
        );
    }
}