The operation log says what each operation did; op restore, op revert and --at-op; commands say where they left you (closes #51, closes #52, closes #53) 98a1620a3840

//! Working with the operation log (spec §12.1): naming an operation,

//! reading the repository as it was after one (`--at-op`), going back to

//! one (`op restore`), undoing one alone (`op revert`), and saying what an

//! operation changed (`op log`).

use super::*;

/// One reference change between two views.

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum ViewChange {

    BookmarkCreated {

        name: String,

        heads: usize,

    },

    BookmarkDeleted {

        name: String,

    },

    BookmarkMoved {

        name: String,

        from: usize,

        to: usize,

    },

    RemoteMoved {

        remote: String,

        name: String,

    },

    TagCreated {

        name: String,

    },

    TagDeleted {

        name: String,

    },

    Policy,

    /// This workspace's working copy is now `change`.

    WorkingCopy {

        change: ChangeHash,

    },

}

/// What `op restore` did.

#[derive(Debug)]

pub struct RestoreReport {

    /// The operation restored to.

    pub op: ObjectRef,

    pub command: String,

    pub checkout: CheckoutReport,

}

/// What `op revert` did.

#[derive(Debug)]

pub struct RevertReport {

    pub op: ObjectRef,

    pub command: String,

    /// Bookmarks put back as they were before the operation.

    pub reverted: Vec<String>,

    /// Bookmarks the operation moved that have moved again since: left as

    /// they are.

    pub kept: Vec<String>,

    /// Whether the working copy followed the current bookmark.

    pub checked_out: bool,

}

impl Repo {

    /// This repository read as it was after operation `spec` (`--at-op`).

    /// Commands that would record an operation are refused.

    pub fn at_op(mut self, spec: &str) -> Result<Repo> {

        let (r, _) = self.resolve_op(spec)?;

        self.at_op = Some(r);

        Ok(self)

    }

    /// Whether this repository is read at an earlier operation (`--at-op`).

    pub fn is_at_op(&self) -> bool {

        self.at_op.is_some()

    }

    /// The operation `spec` names: `@` for the current one, `@-` for the

    /// one before it, or a prefix of an operation ID from `oxy op log`.

    pub fn resolve_op(&self, spec: &str) -> Result<(ObjectRef, Op)> {

        let spec = spec.trim();

        let log = self.op_log()?;

        if let Some(rest) = spec.strip_prefix('@') {

            if rest.chars().all(|c| c == '-') {

                return log

                    .into_iter()

                    .nth(rest.len())

                    .ok_or_else(|| RepoError::Msg(format!("the operation log has no {spec}")));

            }

        }

        if spec.is_empty() || !spec.chars().all(|c| c.is_ascii_hexdigit()) {

            return fail(format!(

                "{spec:?} is not an operation: give an ID from oxy op log, @ or @-"

            ));

        }

        let spec = spec.to_ascii_lowercase();

        let mut found = log

            .into_iter()

            .filter(|(r, _)| r.to_hex().starts_with(&spec));

        match (found.next(), found.next()) {

            (Some(one), None) => Ok(one),

            (None, _) => fail(format!("no operation {spec} in oxy op log")),

            (Some(_), Some(_)) => fail(format!(

                "operation {spec} is ambiguous: give more of its ID"

            )),

        }

    }

    /// What changed from `before` to `after`, for this workspace's working

    /// copy and every reference.

    pub fn view_changes(&self, before: &View, after: &View) -> Result<Vec<ViewChange>> {

        let mut out = Vec::new();

        let heads = |st: &ObjectRef| -> Result<usize> { Ok(self.store.get_state(st)?.heads.len()) };

        let names: BTreeSet<&String> = before

            .bookmarks

            .keys()

            .chain(after.bookmarks.keys())

            .collect();

        for name in names {

            match (before.bookmarks.get(name), after.bookmarks.get(name)) {

                (None, Some(a)) => out.push(ViewChange::BookmarkCreated {

                    name: name.clone(),

                    heads: heads(a)?,

                }),

                (Some(_), None) => out.push(ViewChange::BookmarkDeleted { name: name.clone() }),

                (Some(b), Some(a)) if a != b => out.push(ViewChange::BookmarkMoved {

                    name: name.clone(),

                    from: heads(b)?,

                    to: heads(a)?,

                }),

                _ => {}

            }

        }

        for (remote, bookmarks) in &after.remotes {

            for (name, st) in bookmarks {

                if before.remotes.get(remote).and_then(|b| b.get(name)) != Some(st) {

                    out.push(ViewChange::RemoteMoved {

                        remote: remote.clone(),

                        name: name.clone(),

                    });

                }

            }

        }

        for name in after.tags.keys().filter(|t| !before.tags.contains_key(*t)) {

            out.push(ViewChange::TagCreated { name: name.clone() });

        }

        for name in before.tags.keys().filter(|t| !after.tags.contains_key(*t)) {

            out.push(ViewChange::TagDeleted { name: name.clone() });

        }

        if before.policy != after.policy {

            out.push(ViewChange::Policy);

        }

        if let Some(w) = after.workspaces.get(&self.workspace) {

            if before.workspaces.get(&self.workspace) != Some(w) {

                out.push(ViewChange::WorkingCopy { change: *w });

            }

        }

        Ok(out)

    }

    /// Go back to how the bookmarks and this working copy were after

    /// operation `spec`, recorded as a new operation, so it can be undone

    /// in turn. The working copy is checked out at the base it had then;

    /// uncommitted work stops it unless `discard`. Tags and the trust

    /// policy are left as they are: neither goes backwards.

    pub fn op_restore(&self, spec: &str, discard: bool) -> Result<RestoreReport> {

        let _wc = self.lock_working_copy()?;

        let (target_ref, target) = self.resolve_op(spec)?;

        let command = format!("oxy op restore {}", target_ref.short(12));

        // Refuse before anything moves, as the checkout below would.

        if !discard && !self.clean_by_manifest()? {

            let snap = self.snapshot_status(&command)?;

            if !snap.statuses.is_empty() {

                return fail(format!(

                    "the working copy has uncommitted changes ({}): commit them, or drop them with --discard",

                    plural_paths(snap.statuses.len())

                ));

            }

        }

        let (head_ref, head) = self.head_op()?;

        let mut view = head.view.clone();

        view.bookmarks = target.view.bookmarks.clone();

        self.record_op(&[head_ref], &command, view)?;

        let base = match target.view.workspaces.get(&self.workspace) {

            Some(w) => {

                let wc = self.store.get_change(w)?;

                self.load_state_history(&wc.deps)?.maximal(&wc.deps)

            }

            None => self.bookmark_heads()?,

        };

        let checkout = self.checkout(&base, discard, &format!("{command} (checkout)"))?;

        Ok(RestoreReport {

            op: target_ref,

            command: target.command,

            checkout,

        })

    }

    /// Undo operation `spec` alone, keeping everything after it: each

    /// bookmark it moved goes back to where it was before, unless it has

    /// moved again since. The working copy follows the current bookmark

    /// when it was clean and on its heads, as after a pull.

    pub fn op_revert(&self, spec: &str) -> Result<RevertReport> {

        let _wc = self.lock_working_copy()?;

        let (target_ref, target) = self.resolve_op(spec)?;

        if target.is_snapshot() {

            return fail(

                "that operation only recorded the working copy: it moved no bookmark to revert",

            );

        }

        let Some(parent) = target.parents.first() else {

            return fail("that is the first operation: there is nothing before it");

        };

        let before = Op::decode(&self.store.get_typed(parent, ObjectType::Op)?)?.view;

        let (head_ref, head) = self.head_op()?;

        let mut view = head.view.clone();

        let (mut reverted, mut kept) = (Vec::new(), Vec::new());

        let names: BTreeSet<&String> = before

            .bookmarks

            .keys()

            .chain(target.view.bookmarks.keys())

            .collect();

        for name in names {

            let (was, became) = (before.bookmarks.get(name), target.view.bookmarks.get(name));

            if was == became {

                continue;

            }

            if head.view.bookmarks.get(name) != became {

                kept.push(name.clone());

                continue;

            }

            match was {

                Some(st) => view.bookmarks.insert(name.clone(), *st),

                None => view.bookmarks.remove(name),

            };

            reverted.push(name.clone());

        }

        if reverted.is_empty() {

            return fail(if kept.is_empty() {

                "that operation moved no bookmark: nothing to revert".to_string()

            } else {

                format!(

                    "every bookmark that operation moved has moved again since ({}); oxy op restore goes back to an operation instead",

                    kept.join(", ")

                )

            });

        }

        let command = format!("oxy op revert {}", target_ref.short(12));

        let current = self.config.bookmark.clone();

        let mut old = self.heads_of(&head.view, &current)?;

        old.sort();

        self.record_op(&[head_ref], &command, view.clone())?;

        let mut checked_out = false;

        if reverted.contains(&current) {

            let snap = self.snapshot(&command)?;

            let clean = snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty();

            let mut base = snap.base.maximal(&snap.wc.deps);

            base.sort();

            if clean && base == old {

                let new = self.heads_of(&view, &current)?;

                self.checkout(&new, false, &format!("{command} (checkout)"))?;

                checked_out = true;

            }

        }

        Ok(RevertReport {

            op: target_ref,

            command: target.command,

            reverted,

            kept,

            checked_out,

        })

    }

}

fn plural_paths(n: usize) -> String {

    format!("{n} path{}", if n == 1 { "" } else { "s" })

}

- **The operation log says what each operation did (#51).** `oxy op log` gives each operation a summary, such as "main: 1 → 2 heads; working copy now 91ab4d50", with its command dimmed beneath. Runs of working-copy snapshots fold into one row, and `-n` limits the listing. `--json` adds each operation's changes.

- **`oxy op restore`, `oxy op revert` and `--at-op` (#52).** `op restore OP` brings back the bookmarks and working copy as they were after OP. `op revert OP` undoes OP alone and keeps everything after it. `--at-op OP` runs any read-only command on the repository as it was then. Restore and revert are operations too, so `oxy undo` takes them back. `undo` now takes back a command's own checkout with it (pull and restore record one), and brings the files back when nothing uncommitted would be lost.

- **Commands say where they left you (#53).** Commit, checkout, switch, rebase, merge, amend, abandon, pull, undo, restore and revert end with the working copy and the bookmark's heads, newest first, as jj does.

    pub(crate) fn refuse_dirty(&self, snap: &SnapshotResult, discard: bool) -> Result<()> {

mod ops;

pub use ops::{RestoreReport, RevertReport, ViewChange};

    /// `--at-op`: read the repository as it was after this operation;

    /// recording an operation is refused.

    at_op: Option<ObjectRef>,

            at_op: None,

            at_op: None,

                    at_op: None,

                    at_op: None,

        if let Some(r) = self.at_op {

            return Ok((r, Op::decode(&self.store.get_typed(&r, ObjectType::Op)?)?));

        }

        if self.at_op.is_some() {

            return fail(

                "--at-op shows the repository as it was; this command would change it (run it without --at-op)",

            );

        }

    /// and the next snapshot recreates them, and a command's own checkout

    /// (`… (checkout)`) goes with the command. When the working copy is

    /// clean and was clean after the operation undone to, its files follow

    /// too, since nothing on disk can be lost; otherwise they stay as they

    /// are (an undone commit's edits come back as uncommitted work).

        let clean_now =

            self.clean_by_manifest()? || self.snapshot_status("oxy undo")?.statuses.is_empty();

        let wc_now = op.view.workspaces.get(&self.workspace).copied();

        let up = |op: Op| -> Result<Option<Op>> {

            match op.parents.first() {

                Some(p) => Ok(Some(Op::decode(&self.store.get_typed(p, ObjectType::Op)?)?)),

                None => Ok(None),

            }

        };

        loop {

            while op.is_snapshot() {

                match up(op.clone())? {

                    Some(p) => op = p,

                    None => break,

                }

            }

            if !op.command.ends_with(" (checkout)") {

            }

            match up(op.clone())? {

                Some(p) => op = p,

                None => break,

            }

        {

            let _lock = self.lock_ops()?;

            if self.head_ref()? != read_head {

                return fail("another oxy command ran while undoing; run undo again");

            }

            write_atomic(

                &self.oxy.join("ops").join("head"),

                parent.to_hex().as_bytes(),

            )?;

        if let Some(then) = parent_op.view.workspaces.get(&self.workspace) {

            if clean_now && Some(*then) != wc_now {

                let wc = self.store.get_change(then)?;

                if wc.edits.is_empty() && wc.tree_ops.is_empty() {

                    let base = self.load_state_history(&wc.deps)?.maximal(&wc.deps);

                    // The files differ from the restored working copy by

                    // exactly what the undone command did: nothing else is

                    // on disk, as the working copy was clean.

                    self.checkout(&base, true, "oxy undo (checkout)")?;

                }

            }

        }

/// oxygen#51, #52: --at-op reads an earlier view and refuses changes;

/// op restore goes back to an operation, files included, and undo takes

/// the restore back whole; op revert undoes one operation alone; each

/// operation's changes are described from the views.

#[test]

fn operations_can_be_read_restored_and_reverted() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    write(root, "a.txt", b"a\n");

    let first = repo.commit("first", &[]).unwrap();

    write(root, "a.txt", b"a\nb\n");

    let second = repo.commit("second", &[]).unwrap();

    let at_second = repo.head_op().unwrap().0.to_hex();

    repo.bookmark_create("keep", None).unwrap();

    let created = repo.head_op().unwrap().0.to_hex();

    write(root, "n.txt", b"n\n");

    let third = repo.commit("third", &[]).unwrap();

    // What each operation changed.

    let ops = repo.op_log().unwrap();

    let changes = repo.view_changes(&ops[1].1.view, &ops[0].1.view).unwrap();

    assert!(

        changes

            .iter()

            .any(|c| matches!(c, ViewChange::BookmarkMoved { name, .. } if name == "main")),

        "{changes:?}"

    );

    assert!(changes

        .iter()

        .any(|c| matches!(c, ViewChange::WorkingCopy { .. })));

    // Reading at an earlier operation.

    let old = Repo::open(root).unwrap().at_op(&at_second[..10]).unwrap();

    assert_eq!(old.bookmark_heads().unwrap(), vec![second]);

    assert!(!old.view().unwrap().bookmarks.contains_key("keep"));

    write(root, "z.txt", b"z\n");

    assert!(old.commit("refused", &[]).is_err(), "--at-op is read-only");

    fs::remove_file(root.join("z.txt")).unwrap();

    assert!(repo.resolve_op("zz").is_err());

    assert_eq!(repo.resolve_op("@").unwrap().0, repo.head_op().unwrap().0);

    // Restore goes back, files and all; undo takes it back whole.

    repo.op_restore(&at_second, false).unwrap();

    assert_eq!(repo.bookmark_heads().unwrap(), vec![second]);

    assert!(!root.join("n.txt").exists());

    repo.undo().unwrap();

    let mut heads = repo.bookmark_heads().unwrap();

    heads.sort();

    let mut want = vec![second, third];

    want.sort();

    assert_eq!(heads, want);

    assert!(

        root.join("n.txt").exists(),

        "the files came back with the undo"

    );

    // Revert the bookmark's creation alone: the commit after it stays.

    let r = repo.op_revert(&created).unwrap();

    assert_eq!(r.reverted, vec!["keep".to_string()]);

    assert!(!repo.view().unwrap().bookmarks.contains_key("keep"));

    assert!(repo

        .load_state(&repo.bookmark_heads().unwrap())

        .unwrap()

        .contains(&third));

    assert!(repo.op_revert(&created).is_err(), "nothing left to revert");

    let _ = first;

}

oxy op log                              # every operation, what it changed, and its command

### The operation log

Every command that changes the repository records an operation: the

bookmarks, tags and working copy as they were after it. `oxy op log` lists

them newest first, each with what it changed and the command that did it;

working-copy snapshots fold into one row.

```

@  13adb0d0b8bf just now

│  main: 1 → 2 heads; working copy now 91ab4d50

│  oxy commit -m "Third"

○  fa21727d70da just now

│  created bookmark test (1 head)

│  oxy bookmark create test

○  2d15930afdef … 830168a3ddcd just now

│  2 working-copy snapshots

```

Any operation can be looked at, gone back to, or undone alone:

```

oxy --at-op fa21727d log                # the log as it was after that operation; any read-only command works

oxy op restore fa21727d                 # bookmarks and working copy as they were then

oxy op revert fa21727d                  # undo just that operation, keeping everything after it

oxy undo                                # takes back the last command, a restore included

```

`op restore` and `op revert` are operations themselves, so `oxy undo` takes

them back. `op revert` puts back each bookmark the operation moved, unless

it has moved again since. Tags and the trust policy never go backwards.

`undo` brings the files back as well when nothing uncommitted would be

lost; an undone commit's edits stay on disk as uncommitted work.

Commands that move the working copy end by saying where it is:

```

* Committed 95245a21 #35bbf5097e0c  Third

  Working copy  91ab4d50

  Bookmark      main: 2 heads, newest 95245a21 Third

```

    /// Read the repository as it was after operation OP (an ID from oxy op log, @ or @-); commands that would change it are refused

    #[arg(long, global = true, value_name = "OP")]

    at_op: Option<String>,

/// `--at-op`, for `open` to apply.

static AT_OP: std::sync::OnceLock<Option<String>> = std::sync::OnceLock::new();

    /// List operations, newest first, with what each changed

        /// Show only the latest N (snapshots folded together count as one)

        #[arg(short = 'n', long)]

        limit: Option<usize>,

    },

    /// Go back to the bookmarks and working copy as they were after OP (recorded as a new operation, so it can be undone)

    Restore {

        /// The operation: an ID prefix from oxy op log, @ or @-

        op: String,

        /// Throw away uncommitted working-copy changes

        #[arg(long)]

        discard: bool,

    },

    /// Undo OP alone, keeping every operation after it: the bookmarks it moved go back

    Revert {

        /// The operation: an ID prefix from oxy op log

        op: String,

    let repo = Repo::open(&std::env::current_dir()?).context("opening repository")?;

    match AT_OP.get().and_then(|o| o.as_deref()) {

        Some(op) => Ok(repo.at_op(op)?),

        None => Ok(repo),

    }

    AT_OP.set(cli.at_op.clone()).ok();

        Cmd::Op { cmd } => match cmd {

            OpCmd::Log { limit, json } => workspace::op_log(limit, json),

            OpCmd::Restore { op, discard } => workspace::op_restore(&op, discard),

            OpCmd::Revert { op } => workspace::op_revert(&op),

        },

    super::workspace::where_now(&repo);

    where_now(&repo);

    let (conflicted, clean) = if repo.is_at_op() || repo.clean_by_manifest()? {

    where_now(&repo);

    where_now(&repo);

pub fn op_log(limit: Option<usize>, as_json: bool) -> Result<i32> {

    let ops = repo.op_log()?;

    // What each operation changed, against the one before it.

    let changes_of = |i: usize| -> Result<Vec<oxy_core::repo::ViewChange>> {

        match ops.get(i + 1) {

            Some((_, before)) => Ok(repo.view_changes(&before.view, &ops[i].1.view)?),

            None => Ok(vec![]),

        }

    };

        let mut items = Vec::new();

        for (i, (r, op)) in ops.iter().enumerate().take(limit.unwrap_or(usize::MAX)) {

            let summary: Vec<String> = changes_of(i)?

                .iter()

                .map(|c| change_words(&repo, c))

                .collect();

            items.push(json::obj([

                ("id", json::s(&r.to_hex())),

                ("when_ms", json::n(op.hlc.wall_ms)),

                ("command", json::s(&op.command)),

                ("snapshot", json::b(op.is_snapshot())),

                ("current", json::b(i == 0)),

                ("changes", json::arr(summary.iter().map(|x| json::s(x)))),

            ]));

        }

        println!("{}", json::arr(items));

    let id_prefix = unique_prefixes(ops.iter().map(|(r, _)| r.to_hex()));

    let id = |r: &oxy_core::hash::ObjectRef| {

        let hex = r.to_hex();

        let n = id_prefix.get(&hex).copied().unwrap_or(12).min(12);

        format!("{}{}", ui::id(&hex[..n]), ui::dim(&hex[n..12]))

    };

    let rail = ui::dim(ui::glyph("│", "|"));

    let (mut i, mut shown) = (0, 0);

    while i < ops.len() && shown < limit.unwrap_or(usize::MAX) {

        let (r, op) = &ops[i];

            ui::ok(ui::glyph("@", "@"))

        // A run of snapshots folds into one entry.

        let mut run = 1;

        while op.is_snapshot() && i + run < ops.len() && ops[i + run].1.is_snapshot() {

            run += 1;

        }

        let when = ui::dim(ui::ago(op.hlc.wall_ms));

        if op.is_snapshot() {

            let span = if run > 1 {

                format!("{} {}", ui::dim("…"), id(&ops[i + run - 1].0))

            } else {

                String::new()

            };

            println!(

                "{bullet}  {}{} {when}",

                id(r),

                if span.is_empty() {

                    String::new()

                } else {

                    format!(" {span}")

                }

            );

            println!(

                "{rail}  {}",

                ui::dim(if run == 1 {

                    "working-copy snapshot".to_string()

                } else {

                    format!("{run} working-copy snapshots")

                })

            );

        } else {

            println!("{bullet}  {} {when}", id(r));

            let words: Vec<String> = changes_of(i)?

                .iter()

                .map(|c| change_words(&repo, c))

                .collect();

            let summary = if words.is_empty() {

                if i + 1 == ops.len() {

                    "created the repository".to_string()

                } else {

                    "no bookmark or working-copy change".to_string()

                }

            } else {

                words.join("; ")

            };

            println!(

                "{rail}  {}",

                if i == 0 {

                    ui::subject(&summary)

                } else {

                    summary

                }

            );

            let cmd = op.command.lines().next().unwrap_or("");

            let cmd: String = cmd.chars().take(100).collect();

            println!("{rail}  {}", ui::dim(cmd));

        }

        i += run;

        shown += 1;

    }

    if i < ops.len() {

            "{}",

            ui::dim(format!(

                "{} {} older; pass -n to see more",

                ui::glyph("…", "..."),

                plural(ops.len() - i, "operation")

            ))

        );

    }

    Ok(0)

}

/// One change an operation made, in words.

fn change_words(repo: &Repo, c: &oxy_core::repo::ViewChange) -> String {

    use oxy_core::repo::ViewChange::*;

    match c {

        BookmarkCreated { name, heads } => {

            format!("created bookmark {name} ({})", plural(*heads, "head"))

        }

        BookmarkDeleted { name } => format!("deleted bookmark {name}"),

        BookmarkMoved { name, from, to } if from == to => format!("moved {name}"),

        BookmarkMoved { name, from, to } => format!(

            "{name}: {from} {} {}",

            ui::glyph("→", "->"),

            plural(*to, "head")

        ),

        RemoteMoved { remote, name } => format!("{remote}/{name} updated"),

        TagCreated { name } => format!("tagged {name}"),

        TagDeleted { name } => format!("removed tag {name}"),

        Policy => "trust policy changed".to_string(),

        WorkingCopy { change } => match repo.store().get_change_meta(change) {

            Ok(m) => format!("working copy now {}", m.change_id.short(8)),

            Err(_) => "working copy moved".to_string(),

        },

    }

}

pub fn op_restore(op: &str, discard: bool) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner(&format!("Restoring to operation {op}…"));

    let r = repo.op_restore(op, discard)?;

    sp.done(&format!(

        "{} to operation {} {}",

        ui::done("Restored"),

        ui::hash(r.op.short(12)),

        ui::dim(r.command.lines().next().unwrap_or(""))

    ));

    println!(

        "  {} {}",

        ui::note(),

        ui::dim(format!(

            "{} written, {} removed; oxy undo goes back again",

            plural(r.checkout.written, "file"),

            r.checkout.removed

        ))

    );

    where_now(&repo);

    Ok(0)

}

pub fn op_revert(op: &str) -> Result<i32> {

    let repo = open()?;

    let r = repo.op_revert(op)?;

    let view = repo.view()?;

    let names: Vec<String> = r

        .reverted

        .iter()

        .map(|n| {

            if view.bookmarks.contains_key(n) {

                ui::bookmark(n)

                format!("{} (removed)", ui::bookmark(n))

        })

        .collect();

    println!(

        "{} operation {} {}",

        ui::done("Reverted"),

        ui::hash(r.op.short(12)),

        ui::dim(r.command.lines().next().unwrap_or(""))

    );

    println!(

        "  {} {}",

        ui::note(),

        ui::dim(format!("as before it: {}", names.join(", ")))

    );

    if !r.kept.is_empty() {

        println!(

            "  {} {}",

            ui::caution(),

            ui::warn(format!(

                "left as they are, having moved again since: {}",

                r.kept.join(", ")

            ))

    if !r.checked_out && r.reverted.contains(&repo.config.bookmark) {

        println!(

            "  {} {}",

            ui::note(),

            ui::dim("the working copy has work of its own: oxy checkout to move it")

        );

    }

    where_now(&repo);

}

/// Where the working copy and bookmark are now, after a command moved

/// them (as jj says "Working copy now at").

pub fn where_now(repo: &Repo) {

    let Ok((_, wc)) = repo.working_copy() else {

        return;

    };

    let heads = repo.bookmark_heads().unwrap_or_default();

    let newest = heads

        .iter()

        .filter_map(|h| repo.store().get_change_meta(h).ok().map(|m| (m, *h)))

        .max_by_key(|(m, _)| m.hlc);

    println!(

        "  {} {}",

        ui::dim(format!("{:<13}", "Working copy")),

        ui::id(wc.change_id.short(8))

    );

    let tail = match newest {

        Some((m, _)) => format!(

            ", newest {} {}",

            ui::id(m.change_id.short(8)),

            subject_of(&m.message)

        ),

        None => String::new(),

    };

    println!(

        "  {} {}: {}{tail}",

        ui::dim(format!("{:<13}", "Bookmark")),

        ui::bookmark(&repo.config.bookmark),

        plural(heads.len(), "head")

    );

    where_now(&repo);

    where_now(&repo);

    where_now(&repo);

    where_now(&repo);

            where_now(&repo);

    where_now(&repo);