marver 0.0.29

//! Getting a task's work off this machine.
//!
//! A task used to end at a local commit, which is a real answer — the work is
//! safe on a branch — but not one anybody else can see. `P` sends the branches
//! to `origin` and `O` opens a pull request for each, both from the task list,
//! because that is where a finished task sits doing nothing.
//!
//! **A task spans repos, so both are plural.** One branch name across N repos
//! means N pushes and N pull requests, each against the base *that repo's*
//! worktree was cut from. There is no combining them: git has no cross-repo
//! push, and a forge has no cross-repo pull request. Every repo is reported on
//! its own line and one failing does not stop the rest — unlike committing,
//! which is all-or-nothing because half a commit has no name. Half a push is
//! just a push, and the other half can be pressed again.
//!
//! **Nothing here is forced and nothing is destructive.** A push that is
//! rejected is reported; a pull request that already exists is found and its
//! URL given back rather than a second one being opened.
//!
//! The description is not invented. A pull request's title is the task's title
//! and its body is the prompt the agent was given, which is the most accurate
//! statement of intent that exists — nothing here asks a model to write prose
//! about a diff it would have to guess at.

use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::mpsc::{Receiver, Sender, channel};
use std::thread;

use crate::domain::Task;
use crate::git;
use crate::store::Store;

/// The program that opens pull requests.
pub const FORGE: &str = "gh";

/// One repo's worktree, and where its branch is going.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Target {
    pub repo: String,
    pub worktree: PathBuf,
    pub branch: String,
    /// What the branch was cut from, recorded when the worktree was made. The
    /// pull request goes back to the same place.
    pub base: String,
}

/// Every provisioned repo of a task, in the order they were selected.
pub fn targets(store: &Store, task: &Task) -> crate::store::Result<Vec<Target>> {
    let mut out = Vec::new();
    for link in store.list_task_repos(task.id)? {
        let (Some(worktree), Some(branch)) = (link.worktree_path, link.branch) else {
            continue;
        };
        let repo = match store.get_repo(link.repo_id) {
            Ok(repo) => repo.name,
            Err(_) => continue,
        };
        out.push(Target {
            repo,
            worktree,
            branch,
            base: link.base_ref.unwrap_or_default(),
        });
    }
    Ok(out)
}

/// What the task list asked for.
#[derive(Debug, Clone)]
pub enum Job {
    Push(Vec<Target>),
    Open {
        targets: Vec<Target>,
        title: String,
        body: String,
    },
}

impl Job {
    /// What to say while it runs.
    pub fn doing(&self) -> String {
        let repos = match self {
            Job::Push(targets) => targets.len(),
            Job::Open { targets, .. } => targets.len(),
        };
        match self {
            Job::Push(_) => format!("pushing {}", crate::tui::plural(repos, "branch")),
            Job::Open { .. } => format!("opening {}", crate::tui::plural(repos, "pull request")),
        }
    }
}

/// What a running job reports, in the order it happens.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Update {
    /// Something for the status line.
    Says(String),
    /// A pull request now exists — whether this run opened it or found it.
    Opened { repo: String, url: String },
    /// Nothing further is coming.
    Done,
}

/// Run a job on its own thread, reporting back down the returned channel.
///
/// Off the interface's thread for the same reason fetching is: this reaches a
/// network, and a screen that stops redrawing until it answers is a screen that
/// looks like it has crashed.
pub fn spawn(job: Job) -> Receiver<Update> {
    let (tx, rx) = channel();
    thread::spawn(move || run(job, &tx));
    rx
}

/// The body of [`spawn`], without the thread.
pub fn run(job: Job, tx: &Sender<Update>) {
    match job {
        Job::Push(targets) => {
            for target in &targets {
                let _ = tx.send(match push(target) {
                    Ok(Pushed::Sent) => Update::Says(format!("pushed {}", target.repo)),
                    Ok(Pushed::NoRemote) => {
                        Update::Says(format!("{}: no remote to push to", target.repo))
                    }
                    Err(why) => Update::Says(format!("{}: {why}", target.repo)),
                });
            }
        }
        Job::Open {
            targets,
            title,
            body,
        } => {
            if !available() {
                let _ = tx.send(Update::Says(format!(
                    "{FORGE} is not installed, so there is nothing to open a pull request with"
                )));
                let _ = tx.send(Update::Done);
                return;
            }
            for target in &targets {
                // A pull request cannot describe commits the remote does not
                // have, so this is not an optional first step.
                match push(target) {
                    Ok(Pushed::Sent) => {}
                    Ok(Pushed::NoRemote) => {
                        let _ = tx.send(Update::Says(format!(
                            "{}: no remote, so no pull request",
                            target.repo
                        )));
                        continue;
                    }
                    Err(why) => {
                        let _ = tx.send(Update::Says(format!("{}: {why}", target.repo)));
                        continue;
                    }
                }
                let _ = tx.send(match open(target, &title, &body) {
                    Ok(Opened::Created(url)) => Update::Opened {
                        repo: target.repo.clone(),
                        url,
                    },
                    // Not an error, and not a second pull request: pressing the
                    // key twice is how anyone would ask "did that work?".
                    Ok(Opened::Already(url)) => Update::Opened {
                        repo: target.repo.clone(),
                        url,
                    },
                    Err(why) => Update::Says(format!("{}: {why}", target.repo)),
                });
            }
        }
    }
    let _ = tx.send(Update::Done);
}

enum Pushed {
    Sent,
    /// Nothing to push to. Ordinary for a repo that was never given a remote.
    NoRemote,
}

fn push(target: &Target) -> std::result::Result<Pushed, String> {
    match git::has_remote(&target.worktree) {
        Ok(true) => {}
        Ok(false) => return Ok(Pushed::NoRemote),
        Err(err) => return Err(err.to_string()),
    }
    git::push(&target.worktree, &target.branch)
        .map(|()| Pushed::Sent)
        .map_err(|err| trim(&err.to_string()))
}

enum Opened {
    Created(String),
    Already(String),
}

/// Whether the forge CLI is on the path.
pub fn available() -> bool {
    Command::new(FORGE)
        .arg("--version")
        .stdout(std::process::Stdio::null())
        .stderr(std::process::Stdio::null())
        .status()
        .is_ok_and(|status| status.success())
}

fn open(target: &Target, title: &str, body: &str) -> std::result::Result<Opened, String> {
    if let Some(url) = existing(target) {
        return Ok(Opened::Already(url));
    }
    let mut command = Command::new(FORGE);
    command
        .current_dir(&target.worktree)
        .args(["pr", "create"])
        .args(["--head", &target.branch])
        .args(["--title", title])
        .args(["--body", body]);
    // A base recorded as empty means the worktree predates it being written
    // down; the forge's own default is a better guess than a wrong branch.
    if !target.base.is_empty() {
        command.args(["--base", &target.base]);
    }

    let output = command.output().map_err(|err| err.to_string())?;
    if !output.status.success() {
        return Err(trim(&String::from_utf8_lossy(&output.stderr)));
    }
    // `gh` prints the URL of what it made, and nothing else worth keeping.
    let url = String::from_utf8_lossy(&output.stdout)
        .lines()
        .rev()
        .find(|line| line.starts_with("http"))
        .unwrap_or_default()
        .to_string();
    Ok(Opened::Created(url))
}

/// The pull request already open for this branch, if there is one.
fn existing(target: &Target) -> Option<String> {
    let output = Command::new(FORGE)
        .current_dir(&target.worktree)
        .args([
            "pr",
            "view",
            &target.branch,
            "--json",
            "url",
            "--jq",
            ".url",
        ])
        .output()
        .ok()?;
    if !output.status.success() {
        return None;
    }
    let url = String::from_utf8_lossy(&output.stdout).trim().to_string();
    url.starts_with("http").then_some(url)
}

/// The last line of a program's complaint, which is the part that says what
/// went wrong. `git push` and `gh` both print several, and the status line has
/// room for one.
fn trim(stderr: &str) -> String {
    stderr
        .lines()
        .map(str::trim)
        .rfind(|line| !line.is_empty())
        .unwrap_or("failed")
        .to_string()
}

/// The event recording that a pull request exists, so the URL outlives the
/// status line that announced it. Read back by [`crate::brief`].
pub const OPENED_EVENT: &str = "pr.opened";

/// Write down that a pull request exists.
pub fn record(store: &Store, task_id: i64, repo: &str, url: &str) {
    let _ = store.append_event(
        Some(task_id),
        OPENED_EVENT,
        &serde_json::json!({ "repo": repo, "url": url }),
        chrono::Utc::now(),
    );
}

/// A pull request's title and body, from what the task was asked to do.
pub fn description(task: &Task) -> (String, String) {
    let title = task.title.trim();
    let title = if title.is_empty() {
        format!("marver task {}", task.id)
    } else {
        title.to_string()
    };
    let mut body = task.prompt.trim().to_string();
    if body.is_empty() {
        body.push_str("_No prompt was recorded._");
    }
    body.push_str(&format!("\n\n---\nmarver task {}\n", task.id));
    (title, body)
}

/// Whether a path is inside a worktree that still exists. A task whose
/// directory has been reclaimed has nothing left to push.
pub fn is_live(target: &Target) -> bool {
    Path::new(&target.worktree).exists()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::domain::TaskState;
    use crate::git::testing::init_repo;
    use crate::store::Store;
    use chrono::{DateTime, Utc};
    use std::sync::mpsc::channel;
    use tempfile::TempDir;

    fn at(secs: i64) -> DateTime<Utc> {
        DateTime::from_timestamp(secs, 0).expect("valid timestamp")
    }

    fn task_with(title: &str, prompt: &str) -> Task {
        let mut store = Store::open_in_memory().unwrap();
        store
            .create_task(title, prompt, Path::new("/tmp/tasks"), &[], at(0))
            .unwrap()
    }

    /// A repo with a bare `origin` beside it, so a push has somewhere to go.
    fn repo_with_origin(root: &Path, name: &str) -> (PathBuf, PathBuf) {
        let repo = root.join(name);
        init_repo(&repo, "main");
        let origin = root.join(format!("{name}.git"));
        std::process::Command::new("git")
            .args(["init", "--bare", "--initial-branch=main"])
            .arg(&origin)
            .output()
            .expect("git init --bare");
        git::run(
            &repo,
            &["remote", "add", "origin", origin.to_str().unwrap()],
        )
        .unwrap();
        (repo, origin)
    }

    #[test]
    fn a_description_comes_from_what_the_task_was_asked_to_do() {
        // Not from a model asked to write prose about a diff it would have to
        // guess at. The prompt is the most accurate statement of intent there
        // is.
        let task = task_with(
            "Fix the auth flow",
            "Sessions drop after an hour.\nFind out why.",
        );
        let (title, body) = description(&task);

        assert_eq!(title, "Fix the auth flow");
        assert!(body.starts_with("Sessions drop after an hour."), "{body}");
        assert!(body.contains("Find out why."), "every line of it: {body}");
        assert!(body.contains(&format!("marver task {}", task.id)), "{body}");
    }

    #[test]
    fn a_task_with_no_title_still_gets_one() {
        let task = task_with("", "do the thing");
        let (title, _) = description(&task);
        assert_eq!(title, format!("marver task {}", task.id));
    }

    #[test]
    fn a_task_with_no_prompt_still_gets_a_body() {
        // An empty body is refused by every forge there is.
        let task = task_with("Something", "");
        let (_, body) = description(&task);
        assert!(!body.trim().is_empty());
        assert!(body.contains("No prompt"), "{body}");
    }

    #[test]
    fn a_branch_reaches_the_remote() {
        let tmp = TempDir::new().unwrap();
        let (repo, origin) = repo_with_origin(tmp.path(), "api");
        git::run(&repo, &["checkout", "-q", "-b", "marver/1-thing"]).unwrap();
        std::fs::write(repo.join("new.rs"), "fn f() {}\n").unwrap();
        git::stage_all(&repo).unwrap();
        git::commit(&repo, "agent work").unwrap();

        let target = Target {
            repo: "api".to_string(),
            worktree: repo.clone(),
            branch: "marver/1-thing".to_string(),
            base: "main".to_string(),
        };
        let (tx, rx) = channel();
        run(Job::Push(vec![target]), &tx);

        // Dropped first: `rx.iter()` runs until the channel disconnects, and
        // this is the last sender.
        drop(tx);
        let said: Vec<Update> = rx.iter().collect();
        assert_eq!(
            said,
            vec![Update::Says("pushed api".to_string()), Update::Done],
            "{said:?}"
        );
        assert!(
            git::ref_exists(&origin, "refs/heads/marver/1-thing").unwrap(),
            "the branch must be on the remote"
        );
    }

    #[test]
    fn a_repo_with_no_remote_is_said_rather_than_failed() {
        // Ordinary: a repo nobody ever gave a remote to.
        let tmp = TempDir::new().unwrap();
        let repo = tmp.path().join("local");
        init_repo(&repo, "main");

        let (tx, rx) = channel();
        run(
            Job::Push(vec![Target {
                repo: "local".to_string(),
                worktree: repo,
                branch: "main".to_string(),
                base: "main".to_string(),
            }]),
            &tx,
        );

        // Dropped first: `rx.iter()` runs until the channel disconnects, and
        // this is the last sender.
        drop(tx);
        let said: Vec<Update> = rx.iter().collect();
        assert_eq!(
            said[0],
            Update::Says("local: no remote to push to".to_string())
        );
    }

    #[test]
    fn one_repo_failing_does_not_stop_the_others() {
        // Unlike committing, which is all or nothing. Half a push is just a
        // push, and the other half can be pressed again.
        let tmp = TempDir::new().unwrap();
        let (good, _) = repo_with_origin(tmp.path(), "api");
        git::run(&good, &["checkout", "-q", "-b", "marver/1-x"]).unwrap();
        let broken = tmp.path().join("broken");
        std::fs::create_dir_all(&broken).unwrap();

        let (tx, rx) = channel();
        run(
            Job::Push(vec![
                Target {
                    repo: "broken".to_string(),
                    worktree: broken,
                    branch: "marver/1-x".to_string(),
                    base: "main".to_string(),
                },
                Target {
                    repo: "api".to_string(),
                    worktree: good,
                    branch: "marver/1-x".to_string(),
                    base: "main".to_string(),
                },
            ]),
            &tx,
        );

        // Dropped first: `rx.iter()` runs until the channel disconnects, and
        // this is the last sender.
        drop(tx);
        let said: Vec<Update> = rx.iter().collect();
        assert_eq!(said.len(), 3, "one line each, then Done: {said:?}");
        assert_eq!(said[2], Update::Done);
        assert!(
            matches!(&said[1], Update::Says(line) if line == "pushed api"),
            "the second repo still went: {said:?}"
        );
    }

    #[test]
    fn a_push_that_is_rejected_says_what_the_remote_said() {
        let tmp = TempDir::new().unwrap();
        let (repo, origin) = repo_with_origin(tmp.path(), "api");
        // The remote moves ahead of us, so a plain push cannot fast-forward.
        git::push(&repo, "main").unwrap();
        let other = tmp.path().join("other");
        std::process::Command::new("git")
            .args(["clone", "-q", origin.to_str().unwrap()])
            .arg(&other)
            .output()
            .unwrap();
        git::run(&other, &["config", "user.email", "t@m"]).unwrap();
        git::run(&other, &["config", "user.name", "t"]).unwrap();
        std::fs::write(other.join("theirs.rs"), "fn g() {}\n").unwrap();
        git::stage_all(&other).unwrap();
        git::commit(&other, "someone else").unwrap();
        git::push(&other, "main").unwrap();

        std::fs::write(repo.join("ours.rs"), "fn f() {}\n").unwrap();
        git::stage_all(&repo).unwrap();
        git::commit(&repo, "ours").unwrap();

        let (tx, rx) = channel();
        run(
            Job::Push(vec![Target {
                repo: "api".to_string(),
                worktree: repo,
                branch: "main".to_string(),
                base: "main".to_string(),
            }]),
            &tx,
        );

        // Dropped first: `rx.iter()` runs until the channel disconnects, and
        // this is the last sender.
        drop(tx);
        let said: Vec<Update> = rx.iter().collect();
        let Update::Says(line) = &said[0] else {
            panic!("expected a complaint: {said:?}");
        };
        assert!(line.starts_with("api: "), "named: {line}");
        assert!(
            !git::ref_exists(
                std::path::Path::new(&origin),
                "refs/heads/definitely-not-there"
            )
            .unwrap()
        );
    }

    #[test]
    fn opening_without_the_forge_installed_says_so_once() {
        // Rather than once per repo, which for a five-repo task is five copies
        // of the same sentence in a status line that shows one.
        if available() {
            return; // gh is here, so there is nothing to simulate
        }
        let (tx, rx) = channel();
        run(
            Job::Open {
                targets: vec![
                    Target {
                        repo: "a".into(),
                        worktree: PathBuf::from("/tmp"),
                        branch: "b".into(),
                        base: "main".into(),
                    },
                    Target {
                        repo: "b".into(),
                        worktree: PathBuf::from("/tmp"),
                        branch: "b".into(),
                        base: "main".into(),
                    },
                ],
                title: "t".into(),
                body: "b".into(),
            },
            &tx,
        );
        // Dropped first: `rx.iter()` runs until the channel disconnects, and
        // this is the last sender.
        drop(tx);
        let said: Vec<Update> = rx.iter().collect();
        assert_eq!(said.len(), 2, "one complaint and Done: {said:?}");
        let Update::Says(line) = &said[0] else {
            panic!("{said:?}")
        };
        assert!(line.contains(FORGE), "{line}");
    }

    #[test]
    fn targets_skip_a_repo_that_was_never_provisioned() {
        let tmp = TempDir::new().unwrap();
        let mut store = Store::open_in_memory().unwrap();
        let path = tmp.path().join("api");
        init_repo(&path, "main");
        let repo = store.upsert_repo(&path, "api", at(0)).unwrap();
        let task = store
            .create_task("t", "p", tmp.path(), &[repo.id], at(0))
            .unwrap();

        assert!(
            targets(&store, &task).unwrap().is_empty(),
            "selected is not provisioned"
        );

        store
            .record_worktree(task.id, repo.id, &path, "marver/1-t", "main")
            .unwrap();
        let found = targets(&store, &task).unwrap();
        assert_eq!(found.len(), 1);
        assert_eq!(found[0].repo, "api");
        assert_eq!(found[0].branch, "marver/1-t");
        assert_eq!(found[0].base, "main");
    }

    #[test]
    fn a_pull_request_url_outlives_the_line_that_announced_it() {
        // The status line lasts 500ms and a URL is the whole point.
        let tmp = TempDir::new().unwrap();
        let mut store = Store::open_in_memory().unwrap();
        let task = store.create_task("t", "p", tmp.path(), &[], at(0)).unwrap();

        record(&store, task.id, "api", "https://example.test/pr/1");

        let events = store.list_events(task.id).unwrap();
        let found = events
            .iter()
            .find(|e| e.kind == OPENED_EVENT)
            .expect("recorded");
        assert_eq!(found.payload["repo"], "api");
        assert_eq!(found.payload["url"], "https://example.test/pr/1");
        assert_eq!(TaskState::Queued, store.get_task(task.id).unwrap().state);
    }
}