CLI: modern output across all commands: rail-and-bullet log with -n/-v, relative times, authors, signature marks; glyphs on UTF-8 terminals with ASCII fallback 94084087a876

--- README.md
-oxy log
+oxy log                                  # -n 10 for the latest ten, -v for full messages
+Output uses colour, glyphs, and relative times on a UTF-8 terminal, and
+falls back to plain ASCII when piped, with `--plain`, or with `NO_COLOR` set.
+
--- docs/plan.md
+- [x] User request (2026-09-27, mid-loop): make `oxy log` and all output look modern like `git log` with lines, spacing, and glyphs when the terminal supports them. (Done: rail-and-bullet log with `-n`/`-v`, relative times, authors, signature marks; status/show/op log/tags/workspaces/remotes/fetch/push/policy/identity restyled; ASCII fallback when piped or with `--plain`/`NO_COLOR`/non-UTF-8 locale.)
+- 2026-09-27 05:45 iteration 11: modern CLI output across all commands (user request). 105 tests.
--- src/cli/format.rs
+use super::ui;
+/// A compact, styled authentication marker for log lines.
+pub fn signature_mark(repo: &Repo, h: &ChangeHash) -> Result<String> {
+    Ok(match repo.authenticate_change(h)? {
+        SignatureStatus::Unsigned => ui::dim(format!("{} unsigned", ui::glyph("·", "-"))),
+        SignatureStatus::Valid { sealed, .. } => ui::ok(format!("{} {}", ui::glyph("✔", "v"), if sealed { "sealed" } else { "signed" })),
+        SignatureStatus::Invalid(why) => ui::err(format!("{} INVALID: {why}", ui::glyph("✖", "x"))),
+    })
+}
+
+/// The author's display name: the identity's name, or a Git-Author trailer
+/// for imported changes, or a shortened key.
+pub fn author_name(repo: &Repo, c: &ChangeMeta) -> String {
+    if !c.author.is_zero() {
+        if let Ok(id) = repo.identity(&c.author) {
+            return id.name;
+        }
+        return c.author.short(12);
+    }
+    c.message
+        .lines()
+        .rev()
+        .find_map(|l| l.strip_prefix("Git-Author: "))
+        .map(|a| a.split('<').next().unwrap_or(a).trim().to_string())
+        .unwrap_or_else(|| "unknown".into())
+}
+
+/// The first line of a message, or a placeholder.
+pub fn subject_of(message: &str) -> &str {
+    match message.lines().next() {
+        Some(l) if !l.trim().is_empty() => l,
+        _ => "(no description)",
+    }
+}
+
--- src/cli/identity.rs
-    println!("Created identity {name} <{email}>");
-    println!("KeyId: {key}");
-    println!("Secret key stored under {}", repo::default_keys_dir().display());
-        IdentityScope::User => println!("Recorded as your default author in {}", repo.user_config_path().display()),
-        IdentityScope::Repo => println!("Recorded in this repository's .oxy/config only"),
-        println!("Changes will carry this author; run `oxy config --user core.sign change` to sign each commit.");
-    println!("{} <{}>", id.name, id.email);
-    println!("KeyId:   {key}");
-    println!("Created: {}", when(id.created));
-    println!("Secret:  {}", if repo.secret_key()?.is_some() { "available" } else { "NOT FOUND in key directory" });
-    println!("Signing: {}", if repo.config.sign_changes { "every change (core.sign = change)" } else { "at push via seals (core.sign = seal)" });
-            ui::err(&line)
-            ui::dim(&line)
-            ui::ok(&line)
-        println!("{key} = {value} (in {})", path.display());
-        println!("{key} = {value} (in this repository)");
-    println!("Wrote identity {} <{}> ({}) to {}", id.name, id.email, key.short(12), path.display());
-    println!("Created policy serial {} with root key {}; push to publish it.", sp.policy.serial, sp.policy.roots[0].short(12));
-    println!("policy #{} serial {} expires {}{}", r.short(12), p.serial, when(p.expires), if p.is_expired(oxy_core::objects::Hlc::now().wall_ms) { "  EXPIRED" } else { "" });
-    println!("roots (threshold {}):", p.root_threshold);
-        println!("  {}  {}", k.short(12), name(k));
-    println!("rules:");
-        println!("  {:12} threshold {} require {} conflicts {}", rule.pattern, rule.threshold, rule.require.name(), if rule.allow_conflicts { "allowed" } else { "refused" });
-            println!("      {}  {}", k.short(12), name(k));
-        println!("revoked:");
-            println!("  {}  {}", k.short(12), name(k));
-    println!("Granted {} <{}> ({}) on {}; policy serial {}. Push to publish.", id.name, id.email, key.short(12), pattern.unwrap_or("*"), sp.policy.serial);
-    println!("Revoked {}; policy serial {}. Push to publish.", full.short(12), sp.policy.serial);
+    println!("{} identity {} <{email}>", ui::done("Created"), ui::author(&name));
+    println!("{}", ui::kv("key", key));
+    println!("{}", ui::kv("secret", ui::path(repo::default_keys_dir().display())));
+        IdentityScope::User => println!("{}", ui::kv("scope", format!("default author in {}", ui::path(repo.user_config_path().display())))),
+        IdentityScope::Repo => println!("{}", ui::kv("scope", "this repository's .oxy/config only")),
+        println!("  {} {}", ui::note(), ui::dim("changes will carry this author; run oxy config --user core.sign change to sign each commit"));
+    println!("{} {} <{}>", ui::section("identity"), ui::author(&id.name), id.email);
+    println!("{}", ui::kv("key", key));
+    println!("{}", ui::kv("created", format!("{} {}", when(id.created), ui::dim(format!("({})", ui::ago(id.created))))));
+    println!("{}", ui::kv("secret", if repo.secret_key()?.is_some() { ui::ok(format!("{} available", ui::glyph("✔", "*"))) } else { ui::err(format!("{} not found in the key directory", ui::glyph("✖", "x"))) }));
+    println!("{}", ui::kv("signing", if repo.config.sign_changes { "every change (core.sign = change)" } else { "at push via seals (core.sign = seal)" }));
+            ui::err(format!("{} {line}", ui::glyph("✖", "x")))
+            ui::dim(format!("{} {line}", ui::glyph("·", "-")))
+            ui::ok(format!("{} {line}", ui::glyph("✔", "v")))
+        println!("{} {key} = {value} {}", ui::done("Set"), ui::dim(format!("(in {})", path.display())));
+        println!("{} {key} = {value} {}", ui::done("Set"), ui::dim("(in this repository)"));
+    println!("{} identity {} <{}> ({}) to {}", ui::done("Wrote"), ui::author(&id.name), id.email, key.short(12), ui::path(path.display()));
+    println!("{} policy serial {} with root key {} {}", ui::done("Created"), sp.policy.serial, sp.policy.roots[0].short(12), ui::dim("(push to publish it)"));
+    let expired = p.is_expired(oxy_core::objects::Hlc::now().wall_ms);
+    println!("{} {}{}serial {}{}expires {}{}", ui::section("policy"), ui::hash(format!("#{}", r.short(12))), ui::sep(), p.serial, ui::sep(), when(p.expires), if expired { ui::err(format!("  {} EXPIRED", ui::glyph("✖", "x"))) } else { String::new() });
+    println!("{}", ui::section(format!("roots {}", ui::dim(format!("(threshold {})", p.root_threshold)))));
+        println!("  {} {}  {}", ui::ok(ui::glyph("🔑", "*")), ui::hash(k.short(12)), ui::author(name(k)));
+    println!("{}", ui::section("rules"));
+        println!("  {} {:12} {}", ui::ok(ui::glyph("▸", ">")), ui::bookmark(&rule.pattern), ui::dim(format!("threshold {}, require {}, conflicts {}", rule.threshold, rule.require.name(), if rule.allow_conflicts { "allowed" } else { "refused" })));
+            println!("      {}  {}", ui::hash(k.short(12)), ui::author(name(k)));
+        println!("{}", ui::section("revoked"));
+            println!("  {} {}  {}", ui::err(ui::glyph("✖", "x")), ui::hash(k.short(12)), ui::author(name(k)));
+    println!("{} {} <{}> ({}) on {} {}", ui::done("Granted"), ui::author(&id.name), id.email, key.short(12), ui::bookmark(pattern.unwrap_or("*")), ui::dim(format!("(policy serial {}; push to publish)", sp.policy.serial)));
+    println!("{} {} {}", ui::done("Revoked"), ui::hash(full.short(12)), ui::dim(format!("(policy serial {}; push to publish)", sp.policy.serial)));
--- src/cli/mod.rs
-    Log,
-        Cmd::Log => workspace::log(),
+    Log {
+        /// Show at most this many changes
+        #[arg(short = 'n', long)]
+        limit: Option<usize>,
+        /// Show full messages, dependencies, and signatures
+        #[arg(short, long)]
+        verbose: bool,
+    },
+        Cmd::Log { limit, verbose } => workspace::log(limit, verbose),
--- src/cli/sync.rs
-    sp.done(&format!("{} into {} ({} on {}: {})", ui::ok("Cloned"), ui::path(repo.root().display()), url, ui::id(&repo.config.bookmark), plural(heads.len(), "head")));
-    println!("Added remote {name} = {url}");
-    println!("Removed remote {name}");
-        println!("{name}\t{url}");
-                println!("    {bm}: {}", plural(heads, "head"));
-        println!("{} {}, {}", ui::id(format!("{remote}/{name}")), plural(heads.len(), "head"), plural(*n, "new change"));
-        println!("{}", ui::dim(format!("{} adopted", plural(report.new_tags, "tag"))));
-        eprintln!("{} {remote} has no trust policy; nothing fetched from it was verified", ui::warn("warning:"));
-        sp.done(&ui::dim("Already up to date."));
-        ui::ok("Pulled:"),
-        ui::id(&repo.config.bookmark),
-        if r.checked_out { "; working copy updated" } else { "; run `oxy checkout` to update the working copy" }
-        println!("  {}", ui::warn("the result has conflicts; see oxy status"));
-            println!("{} {}", ui::id(format!("{remote}/{}", r.name)), ui::ok(if r.reason.is_empty() { "updated" } else { r.reason.as_str() }));
-            println!("{} {} {}", ui::id(format!("{remote}/{}", r.name)), ui::err("rejected:"), r.reason);
-        "Exported {} to {} as branch {} (currently {}); {} already exported.",
-        git_dir.display(),
-        r.branch,
-        plural(r.heads, "head"),
-        r.skipped
-        "Imported {} ({} merges) from {} {branch} into {} in {:.1?}: {} now has {}.{}",
-        git_dir.display(),
-        repo.root().display(),
-        started.elapsed(),
-        repo.config.bookmark,
-        plural(r.heads, "head"),
-        if r.skipped_submodules > 0 { format!(" Skipped {} submodule entries.", r.skipped_submodules) } else { String::new() }
+    sp.done(&format!("{} into {} {}", ui::done("Cloned"), ui::path(repo.root().display()), ui::dim(format!("({url}, {} with {})", ui::bookmark(&repo.config.bookmark), plural(heads.len(), "head")))));
+    println!("{} remote {} {} {url}", ui::done("Added"), ui::bookmark(name), ui::dim(ui::glyph("→", "->")));
+    println!("{} remote {}", ui::done("Removed"), ui::bookmark(name));
+    if repo.config.remotes.is_empty() {
+        println!("{}", ui::dim("No remotes; add one with oxy remote add <name> <url>."));
+    }
+        println!("{} {}{}{}", ui::ok(ui::glyph("⇄", "<>")), ui::bookmark(name), ui::sep(), ui::dim(url));
+                println!("    {} {}{}{}", ui::dim(ui::glyph("↳", "->")), ui::id(format!("{name}/{bm}")), ui::sep(), ui::dim(plural(heads, "head")));
+    if report.refs.is_empty() {
+        println!("{} {}", ui::done("Fetched"), ui::dim(format!("nothing new from {remote}")));
+    }
+        let what = if *n == 0 { ui::dim("up to date") } else { ui::ok(plural(*n, "new change")) };
+        println!("{} {}{}{}{}{what}", ui::done("Fetched"), ui::id(format!("{remote}/{name}")), ui::sep(), ui::dim(plural(heads.len(), "head")), ui::sep());
+        println!("  {} {}", ui::note(), ui::dim(format!("{} adopted", plural(report.new_tags, "tag"))));
+        eprintln!("{} {remote} has no trust policy; nothing fetched from it was verified", ui::caution());
+        sp.done(&format!("{} {}", ui::ok(ui::glyph("✔", "*")), ui::dim("Already up to date.")));
+        ui::done("Pulled:"),
+        ui::bookmark(&repo.config.bookmark),
+        ui::dim(if r.checked_out { "; working copy updated" } else { "; run oxy checkout to update the working copy" })
+        println!("  {} {}", ui::caution(), ui::warn("the result has conflicts; see oxy status"));
+            println!("{} {}{}{}", ui::done("Pushed"), ui::id(format!("{remote}/{}", r.name)), ui::sep(), ui::dim(if r.reason.is_empty() { "updated" } else { r.reason.as_str() }));
+            println!("{} {} {}{}{}", ui::err(ui::glyph("✖", "x")), ui::err("Rejected"), ui::id(format!("{remote}/{}", r.name)), ui::sep(), r.reason);
+        "{} {} to {} as branch {} {}",
+        ui::done("Exported"),
+        ui::path(git_dir.display()),
+        ui::bookmark(&r.branch),
+        ui::dim(format!("(currently {}; {} already exported)", plural(r.heads, "head"), r.skipped))
+        "{} {} ({} merges) from {} {} into {} {}",
+        ui::done("Imported"),
+        ui::path(git_dir.display()),
+        ui::bookmark(branch),
+        ui::path(repo.root().display()),
+        ui::dim(format!("in {:.1?}; {} now has {}", started.elapsed(), repo.config.bookmark, plural(r.heads, "head")))
+    if r.skipped_submodules > 0 {
+        println!("  {} {}", ui::note(), ui::dim(format!("skipped {} submodule entries", r.skipped_submodules)));
+    }
--- src/cli/ui.rs
-/// Decide once whether to use colour and animation.
-}
-/// A status tag: green for additions, yellow for modifications, red for removals and conflicts.
-pub fn tag(t: &str) -> String {
-    match t {
-        "A" => s(t).green().bold().to_string(),
-        "M" | "X" => s(t).yellow().bold().to_string(),
-        "D" | "C!" => s(t).red().bold().to_string(),
-        "R" => s(t).cyan().bold().to_string(),
-        other => other.to_string(),
-    }
-
+static UNICODE: AtomicBool = AtomicBool::new(false);
+/// Decide once whether to use colour, glyphs, and animation.
+        let utf8 = ["LC_ALL", "LC_CTYPE", "LANG"]
+            .iter()
+            .filter_map(|k| std::env::var(k).ok())
+            .find(|v| !v.is_empty())
+            .map(|v| v.to_ascii_uppercase().contains("UTF-8") || v.to_ascii_uppercase().contains("UTF8"))
+            .unwrap_or(false);
+        UNICODE.store(!plain && utf8, Ordering::Relaxed);
+/// Whether the terminal takes Unicode glyphs (a UTF-8 locale, not `--plain`).
+pub fn unicode() -> bool {
+    UNICODE.load(Ordering::Relaxed)
+}
+
+/// A glyph with an ASCII fallback for plain output and non-UTF-8 locales.
+pub fn glyph<'a>(fancy: &'a str, ascii: &'a str) -> &'a str {
+    if unicode() { fancy } else { ascii }
+}
+
+/// A finished action: a tick and the verb in green.
+pub fn done<T: std::fmt::Display>(v: T) -> String {
+    format!("{} {}", ok(glyph("✔", "*")), ok(v))
+}
+
+/// A warning line prefix.
+pub fn caution() -> String {
+    warn(glyph("⚠", "!"))
+}
+
+/// An informational note prefix.
+pub fn note() -> String {
+    dim(glyph("ℹ", "i"))
+}
+
+/// A section title.
+pub fn section<T: std::fmt::Display>(v: T) -> String {
+    format!("{} {}", s(glyph("▍", "#")).cyan(), s(v).bold())
+}
+
+/// `  key   value`, with the key dimmed and padded.
+pub fn kv<T: std::fmt::Display>(key: &str, value: T) -> String {
+    format!("  {} {value}", dim(format!("{key:<8}")))
+}
+
+/// An author name.
+pub fn author<T: std::fmt::Display>(v: T) -> String {
+    s(v).magenta().to_string()
+}
+
+/// A bookmark or reference name.
+pub fn bookmark<T: std::fmt::Display>(v: T) -> String {
+    s(v).green().bold().to_string()
+}
+
+/// The subject line of a message.
+pub fn subject<T: std::fmt::Display>(v: T) -> String {
+    s(v).bold().to_string()
+}
+
+/// A dimmed separator between the parts of a metadata line.
+pub fn sep() -> String {
+    dim(format!(" {} ", glyph("·", "-")))
+}
+
+/// Milliseconds since the epoch as a relative time ("3 minutes ago"), or the
+/// date when older than a month.
+pub fn ago(ms: u64) -> String {
+    let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);
+    let secs = now.saturating_sub(ms) / 1000;
+    let unit = |n: u64, w: &str| format!("{n} {w}{} ago", if n == 1 { "" } else { "s" });
+    match secs {
+        0..=44 => "just now".into(),
+        45..=89 => "a minute ago".into(),
+        90..=2_699 => unit(secs.div_ceil(60), "minute"),
+        2_700..=5_399 => "an hour ago".into(),
+        5_400..=79_199 => unit(secs.div_ceil(3_600), "hour"),
+        79_200..=129_599 => "yesterday".into(),
+        129_600..=2_591_999 => unit(secs.div_ceil(86_400), "day"),
+        _ => super::format::when(ms).split(' ').next().unwrap_or("").to_string(),
+    }
+}
+
+/// The bullet for a log entry: the working copy, a head, or an ordinary change.
+pub fn log_bullet(working_copy: bool, head: bool, conflicted: bool) -> String {
+    if working_copy {
+        s(glyph("◉", "@")).cyan().bold().to_string()
+    } else if conflicted {
+        err(glyph("✱", "!"))
+    } else if head {
+        ok(glyph("●", "*"))
+    } else {
+        dim(glyph("○", "o"))
+    }
+}
+
+/// The vertical rail joining log entries.
+pub fn rail() -> String {
+    dim(glyph("│", "|"))
+}
+
+/// A status glyph and word for a working-copy change.
+pub fn status_mark(tag: &str) -> String {
+    let (g, a, word) = match tag {
+        "A" => ("✚", "+", "added"),
+        "M" => ("✎", "~", "modified"),
+        "D" => ("✖", "-", "removed"),
+        "X" => ("⚙", "x", "mode"),
+        "C!" => ("‼", "!", "markers"),
+        "R" => ("✔", "r", "resolved"),
+        _ => ("?", "?", "unknown"),
+    };
+    let text = format!("{} {word:<9}", glyph(g, a));
+    self::tag_style(tag, &text)
+}
+
+fn tag_style(t: &str, text: &str) -> String {
+    match t {
+        "A" | "R" => s(text).green().to_string(),
+        "M" | "X" => s(text).yellow().to_string(),
+        "D" | "C!" => s(text).red().to_string(),
+        _ => text.to_string(),
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn relative_times() {
+        let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_millis() as u64;
+        assert_eq!(ago(now), "just now");
+        assert_eq!(ago(now - 60_000), "a minute ago");
+        assert_eq!(ago(now - 5 * 60_000), "5 minutes ago");
+        assert_eq!(ago(now - 3 * 3_600_000), "3 hours ago");
+        assert_eq!(ago(now - 25 * 3_600_000), "yesterday");
+        assert_eq!(ago(now - 4 * 86_400_000), "4 days ago");
+        assert_eq!(ago(0), "1970-01-01");
+        assert_eq!(glyph("✔", "*"), if unicode() { "✔" } else { "*" });
+    }
+}
--- src/cli/workspace.rs
-use super::format::{deps_line, deps_of, plural, short_id, short_meta_id, signature_line, when};
-    println!("{} oxy repository in {}", ui::ok("Initialized"), ui::path(repo.root().display()));
-    println!("  bookmark {}   author {} <{}>", ui::id(&repo.config.bookmark), repo.config.author_name, repo.config.author_email);
-        "{} {} on {} {}",
-        ui::heading("Working copy"),
-        ui::id(&repo.config.bookmark),
-        ui::dim(format!("({})", plural(heads.len(), "head")))
-        println!("  {}", ui::dim("clean"));
-    }
-    for s in &snap.statuses {
-        println!("  {:2} {}", ui::tag(status_tag(s.status)), ui::path(&s.path));
-    println!("{} {}", ui::err("Conflicts"), ui::dim("edit the marked files, or the .oxy-conflict-N candidates, then commit"));
-        println!("  tree: {c:?}");
-                Some(ChangeStatus::Resolved) => ui::ok("resolved in working copy"),
-                Some(ChangeStatus::ConflictEdited) => ui::warn("markers remain"),
-                _ => ui::err("unresolved"),
-    sp.done(&format!("{} {} {} {}", ui::ok("Committed"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), message.lines().next().unwrap_or("")));
-pub fn log() -> Result<i32> {
-    repo.snapshot("oxy log")?;
-    for e in repo.log()? {
-        let mut flags = Vec::new();
-            flags.push("working copy");
-        if e.is_head {
-            flags.push("head");
-        let flags = if flags.is_empty() { String::new() } else { ui::warn(format!(" ({})", flags.join(", "))) };
-        println!("{} {}{}", ui::id(short_meta_id(c)), ui::hash(format!("#{}", e.hash.short(12))), flags);
-        println!("    {}", ui::dim(when(c.hlc.wall_ms)));
-        if !c.deps.is_empty() {
-            println!("    {}", ui::dim(format!("deps: {}", deps_of(&c.deps))));
-        let msg = if c.message.is_empty() { "(no description)" } else { &c.message };
-        for line in msg.lines() {
-            println!("    {line}");
-        println!();
-    println!("{} {} {}", ui::heading("change"), ui::id(short_id(&c)), ui::hash(format!("#{h}")));
-    println!("  kind  {:?}", c.kind);
-    println!("  date  {}", when(c.hlc.wall_ms));
-    println!("  deps  {}", ui::dim(deps_line(&c)));
-    println!("  sig   {}", signature_line(&repo, &h)?);
-    println!("\n{}\n", if c.message.is_empty() { "(no description)" } else { &c.message });
-    sp.done(&format!("{} on {}: {} written, {} removed", ui::ok("Working copy"), ui::id(&spec), plural(r.written, "file"), r.removed));
-        println!("  {}", ui::warn("this state has conflicts; see oxy status"));
-    println!("{} now at: {}", ui::ok("Undone;"), ui::dim(&op.command));
-        println!("{}{} {}  {}", if i == 0 { ui::ok("@ ") } else { "  ".into() }, ui::hash(r.short(12)), ui::dim(when(op.hlc.wall_ms)), op.command);
-    println!("{} {} {} {}", ui::ok("Described"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), message.lines().next().unwrap_or(""));
-    println!("{} {} {} {}", ui::ok("Amended"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), c.message.lines().next().unwrap_or(""));
-    println!("Abandoned {} #{}; its content remains on disk as uncommitted work if the working copy sat on it.", short_id(&c), h.short(12));
-        println!("  {} {n}", ui::warn("note:"));
-    sp.done(&format!("{} {} of {} ({} bytes) for {}", ui::ok("Checkpoint"), ui::hash(format!("#{}", r.short(12))), plural(changes, "change"), bytes, ui::id(&repo.config.bookmark)));
-        "{} {} -> {} ({}){}",
-        ui::ok("Tagged"),
-        ui::id(&t.name),
-            "{} {} {}{}{}",
-            ui::id(&t.name),
-            ui::dim(format!("({})", plural(t.heads.len(), "head"))),
-            if t.message.is_empty() { String::new() } else { format!("  {}", t.message.lines().next().unwrap_or("")) },
-            t.signer.map(|s| ui::dim(format!("  [{s}]"))).unwrap_or_default()
-    sp.done(&format!("{} {} (workspace {})", ui::ok("Workspace created at"), ui::path(ws.root().display()), ui::id(ws.workspace().short(8))));
-            if w.current { ui::ok("*") } else { " ".into() },
-            w.working_copy.map(|h| ui::dim(format!("  wc #{}", h.short(12)))).unwrap_or_else(|| ui::warn("  (not in view)"))
-    println!("{} workspace {} at {}; its files were left in place.", ui::ok("Forgot"), ui::id(w.id.short(8)), ui::path(w.path.display()));
-    println!("{} {} (advisory, local)", ui::ok("Locked"), ui::path(path));
-    println!("{} {}", ui::ok("Unlocked"), ui::path(path));
-    println!("{} into {} {} and {} {}", ui::ok("Split"), ui::id(short_id(&c1)), ui::hash(format!("#{}", h1.short(12))), ui::id(short_id(&c2)), ui::hash(format!("#{}", h2.short(12))));
+use super::format::{author_name, deps_line, deps_of, plural, short_id, short_meta_id, signature_line, signature_mark, subject_of, when};
+use oxy_core::objects::ChangeKind;
+    println!("{} oxy repository in {}", ui::done("Initialized"), ui::path(repo.root().display()));
+    println!("{}", ui::kv("bookmark", ui::bookmark(&repo.config.bookmark)));
+    println!("{}", ui::kv("author", format!("{} <{}>", ui::author(&repo.config.author_name), repo.config.author_email)));
+        "{} {}{}working copy {}{}{}",
+        ui::dim("On"),
+        ui::bookmark(&repo.config.bookmark),
+        ui::sep(),
+        ui::sep(),
+        ui::dim(plural(heads.len(), "head"))
+        println!("  {} {}", ui::ok(ui::glyph("✔", "*")), ui::dim("nothing to commit, working copy clean"));
+    } else {
+        println!();
+        for s in &snap.statuses {
+            println!("  {} {}", ui::status_mark(status_tag(s.status)), ui::path(&s.path));
+        }
+    println!("{} {}", ui::section(ui::err("Conflicts")), ui::dim("edit the marked files, or the .oxy-conflict-N candidates, then commit"));
+        println!("  {} tree: {c:?}", ui::err(ui::glyph("✱", "!")));
+                Some(ChangeStatus::Resolved) => ui::ok(format!("{} resolved in working copy", ui::glyph("✔", "*"))),
+                Some(ChangeStatus::ConflictEdited) => ui::warn(format!("{} markers remain", ui::glyph("‼", "!"))),
+                _ => ui::err(format!("{} unresolved", ui::glyph("✱", "!"))),
+    sp.done(&format!("{} {} {}  {}", ui::done("Committed"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), ui::subject(subject_of(message))));
+/// The log: one entry per change, newest first, joined by a rail. The
+/// default view is the subject and a metadata line; `verbose` adds the full
+/// message, dependencies, and the authenticating key.
+pub fn log(limit: Option<usize>, verbose: bool) -> Result<i32> {
+    let snap = repo.snapshot("oxy log")?;
+    let conflicted = snap.base_snapshot.is_conflicted();
+    let entries = repo.log()?;
+    let total = entries.len();
+    let shown = limit.unwrap_or(total).min(total);
+    let rail = ui::rail();
+    for (i, e) in entries.iter().take(shown).enumerate() {
+        let bullet = ui::log_bullet(e.is_working_copy, e.is_head, e.is_working_copy && conflicted);
+        let mut labels = Vec::new();
+            labels.push(ui::warn("working copy"));
+        if c.kind == ChangeKind::Resolution {
+            labels.push(ui::warn("resolution"));
+        let labels = if labels.is_empty() { String::new() } else { format!(" {}{}{}", ui::dim("("), labels.join(ui::dim(", ").as_str()), ui::dim(")")) };
+        let subject = if e.is_working_copy && c.message.is_empty() {
+            ui::dim(if snap.statuses.is_empty() { "(clean)" } else { "(uncommitted changes)" })
+        } else {
+            ui::subject(subject_of(&c.message))
+        };
+        println!("{bullet} {}{labels}  {subject}", ui::id(short_meta_id(c)));
+        let meta = format!(
+            "{}{}{}{}{}{}{}",
+            ui::hash(format!("#{}", e.hash.short(12))),
+            ui::sep(),
+            ui::author(author_name(&repo, c)),
+            ui::sep(),
+            ui::dim(ui::ago(c.hlc.wall_ms)),
+            ui::sep(),
+            if e.is_working_copy { ui::dim("not yet committed") } else { signature_mark(&repo, &e.hash)? }
+        );
+        println!("{rail} {meta}");
+        if verbose {
+            if !e.is_working_copy {
+                println!("{rail} {}", ui::dim(format!("{} {}", when(c.hlc.wall_ms), signature_line(&repo, &e.hash)?)));
+            }
+            if !c.deps.is_empty() {
+                println!("{rail} {} {}", ui::dim(ui::glyph("↳", "->")), ui::dim(deps_of(&c.deps)));
+            }
+            let body: Vec<&str> = c.message.lines().skip(1).skip_while(|l| l.trim().is_empty()).collect();
+            if !body.is_empty() {
+                println!("{rail}");
+                for line in body {
+                    println!("{rail}   {line}");
+                }
+            }
+        if i + 1 < shown {
+            println!("{rail}");
+    if shown < total {
+        println!("{}", ui::dim(format!("{} {} more; pass -n to see them", ui::glyph("…", "..."), total - shown)));
+    }
+    println!("{} {} {}", ui::section("change"), ui::id(short_id(&c)), ui::hash(format!("#{h}")));
+    println!("{}", ui::kv("kind", format!("{:?}", c.kind).to_lowercase()));
+    println!("{}", ui::kv("author", ui::author(author_name(&repo, &oxy_core::state::ChangeMeta::of(&c)))));
+    println!("{}", ui::kv("date", format!("{} {}", when(c.hlc.wall_ms), ui::dim(format!("({})", ui::ago(c.hlc.wall_ms))))));
+    println!("{}", ui::kv("deps", ui::dim(deps_line(&c))));
+    println!("{}", ui::kv("sig", signature_line(&repo, &h)?));
+    println!();
+    for line in (if c.message.is_empty() { "(no description)" } else { &c.message }).lines() {
+        println!("    {line}");
+    }
+    println!();
+    sp.done(&format!("{} on {}: {} written, {} removed", ui::done("Working copy"), ui::bookmark(&spec), plural(r.written, "file"), r.removed));
+        println!("  {} {}", ui::caution(), ui::warn("this state has conflicts; see oxy status"));
+    println!("{} now at: {}", ui::done("Undone;"), ui::dim(&op.command));
+        let bullet = if i == 0 { ui::ok(ui::glyph("●", "@")) } else { ui::dim(ui::glyph("○", "o")) };
+        let cmd = subject_of(&op.command).split("\\n").next().unwrap_or("");
+        println!("{bullet} {}{}{}  {}", ui::hash(r.short(12)), ui::sep(), ui::dim(format!("{:<16}", ui::ago(op.hlc.wall_ms))), if i == 0 { ui::subject(cmd) } else { cmd.to_string() });
+    println!("{} {} {}  {}", ui::done("Described"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), ui::subject(subject_of(message)));
+    println!("{} {} {}  {}", ui::done("Amended"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), ui::subject(subject_of(&c.message)));
+    println!("{} {} {}  {}", ui::done("Abandoned"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), ui::dim("its content remains on disk as uncommitted work if the working copy sat on it"));
+        println!("  {} {n}", ui::note());
+    sp.done(&format!("{} {} of {} ({} bytes) for {}", ui::done("Checkpoint"), ui::hash(format!("#{}", r.short(12))), plural(changes, "change"), bytes, ui::id(&repo.config.bookmark)));
+        "{} {} {} {} ({}){}",
+        ui::done("Tagged"),
+        ui::bookmark(&t.name),
+        ui::dim(ui::glyph("→", "->")),
+            "{} {} {}{}{}{}",
+            ui::ok(ui::glyph("⚑", "#")),
+            ui::bookmark(&t.name),
+            ui::sep() + &ui::dim(plural(t.heads.len(), "head")),
+            if t.message.is_empty() { String::new() } else { format!("  {}", ui::subject(subject_of(&t.message))) },
+            t.signer.map(|s| ui::sep() + &ui::ok(format!("{} {s}", ui::glyph("✔", "v")))).unwrap_or_default()
+    sp.done(&format!("{} {} (workspace {})", ui::done("Workspace created at"), ui::path(ws.root().display()), ui::id(ws.workspace().short(8))));
+            if w.current { ui::ok(ui::glyph("●", "*")) } else { ui::dim(ui::glyph("○", "o")) },
+            w.working_copy.map(|h| ui::sep() + &ui::dim(format!("working copy #{}", h.short(12)))).unwrap_or_else(|| ui::sep() + &ui::warn("not in view"))
+    println!("{} workspace {} at {}; its files were left in place.", ui::done("Forgot"), ui::id(w.id.short(8)), ui::path(w.path.display()));
+    println!("{} {} {}", ui::done("Locked"), ui::path(path), ui::dim("(advisory, local)"));
+    println!("{} {}", ui::done("Unlocked"), ui::path(path));
+    println!("{} into {} {} and {} {}", ui::done("Split"), ui::id(short_id(&c1)), ui::hash(format!("#{}", h1.short(12))), ui::id(short_id(&c2)), ui::hash(format!("#{}", h2.short(12))));

Author

Andy McCall @andymccall <[email protected]>

When

1 month ago · 2026-09-26 23:34 UTC

Signature

✔ signed by Andy McCall

Hash

94084087a8766e8cd30a51344f56f5429934de0cfa139739f3ecd41ff80056b1

Depends on

045469792ee1 132b884b9a8d 135212de5370 23b217d75848 252e8cb23fbc 2863456a0f6d 4e88e774777a 614541c3cebd 648724d8e0de 6706bdcfb63e 79ab8528ff62 7bc302317004 83e0677b07fe 96f7610fa666 c3069537d7c5 cdb5beba7f05 d02e545dc265 e8b4e156f2fa fce44ae9ad29

Depended on by

284fe47d98b9 0299076f09a2 530a0fc650a2 34fad4a92451 bf3a67819b59 5cde7882d767 2c9ddac3c387 47ce8b8e2d4b b35df36b7dc5 33472ccc08cc 3604179679eb c07406bcc237 98a1620a3840 2bf22305bc48 ff1f62fee654 4cce912a0953 69816d688300 83d61e803ccd 6a81dbab471d cc7a00565161 75167672ebcd e02bf0cd0533 c6aa5bd9d1c8 957fee30826e 4dee277c327a 6e723b81f5b9 28fc23d7706a

In bookmarks

agents-in-readme bare-hashes carried-not-removed carry-identical doctor-trust identical-sides keyless-tags main merge-remote-bookmark only-help-103 paths-for-resolutions-and-amend push-notes show-stat subrepo-pin-state switch-says

In tags

v0.1.0 v0.10.0 v0.11.0 v0.2.0 v0.3.0 v0.3.1 v0.4.0 v0.4.1 v0.4.2 v0.4.3 v0.4.4 v0.4.5 v0.4.6 v0.5.0 v0.5.1 v0.6.0 v0.7.0 v0.8.0 v0.9.0

Edits

98 atoms, 0 tree operations, 8 files

Browse the tree at this change

35 unchanged lines

oxy init                                 # in a project directory

oxy status

oxy commit -m "First change"

oxy log

oxy log                                  # -n 10 for the latest ten, -v for full messages

```

Output uses colour, glyphs, and relative times on a UTF-8 terminal, and

falls back to plain ASCII when piped, with `--plain`, or with `NO_COLOR` set.

Collaborating:

```

28 unchanged lines

25 unchanged lines

- [x] Hooks (spec §20) — done 2026-09-27 03:55: executables in `.oxy/hooks/<event>`, JSON on stdin, `pre-*` veto via exit status with stderr as the message, `semantic-deps` adds explicit deps when `hooks.semantic-deps = true`. `pre-commit`, `post-commit`, `pre-push`, `post-fetch`, `post-checkout`, and the `semantic-deps` hook with its JSON interface.

- [x] Amend on non-head changes; `oxy split` — done 2026-09-27 04:45: `oxy amend --into CHANGE` appends the working copy's edits to an older change when they reference only its closure (identity correspondence for dependents, refused otherwise with a clear message); `oxy split CHANGE PATH..` rebuilds a head as two changes. Found and fixed a graph bug: a delete/insert conflict now requires the deleter and inserter to commute (both directions).

- [x] Reify orphaned references on rewrite as conflicts instead of refusing (spec §8.4); define the conflict shape in the spec. (Done: re-anchoring to the nearest surviving line, else the chain's anchors, so order conflicts arise naturally; vanished nodes drop dependent edits; notes reported by `oxy abandon`.)

- [x] User request (2026-09-27, mid-loop): make `oxy log` and all output look modern like `git log` with lines, spacing, and glyphs when the terminal supports them. (Done: rail-and-bullet log with `-n`/`-v`, relative times, authors, signature marks; status/show/op log/tags/workspaces/remotes/fetch/push/policy/identity restyled; ASCII fallback when piped or with `--plain`/`NO_COLOR`/non-UTF-8 locale.)

- [ ] Identity lifecycle: `oxy identity rotate|revoke`, expiry, delegates (`oxy identity delegate add|remove`), multi-signer policy updates.

- [ ] Rename detection on Git import (similarity ≥ 50%); `oxy git fetch`/`push` against a Git remote via a mirror.

- [ ] Hardening: property tests for the CBOR decoder and pack reader against random and mutated inputs; a concurrent-push test against the server; a 1 GB single-file benchmark for chunking and blobs.

3 unchanged lines

## Log

- 2026-09-26 23:01 plan created.

- 2026-09-27 05:45 iteration 11: modern CLI output across all commands (user request). 105 tests.

- 2026-09-27 05:15 iteration 10: orphaned references reified on rewrite (spec 0.6m); gc fixed to tolerate old views whose working copies were pruned under a zero op-retention during development (this repo's oldest 20 operations). 104 tests.

- 2026-09-27 04:45 iteration 9: amend --into and split; graph delete/insert fix. 104 tests.

- 2026-09-27 03:55 iteration 8: hooks. 102 tests.

7 unchanged lines

//! Shared presentation helpers.

use super::ui;

use anyhow::Result;

use oxy_core::hash::ChangeHash;

use oxy_core::objects::Change;

43 unchanged lines

    })

}

/// A compact, styled authentication marker for log lines.

pub fn signature_mark(repo: &Repo, h: &ChangeHash) -> Result<String> {

    Ok(match repo.authenticate_change(h)? {

        SignatureStatus::Unsigned => ui::dim(format!("{} unsigned", ui::glyph("·", "-"))),

        SignatureStatus::Valid { sealed, .. } => ui::ok(format!("{} {}", ui::glyph("✔", "v"), if sealed { "sealed" } else { "signed" })),

        SignatureStatus::Invalid(why) => ui::err(format!("{} INVALID: {why}", ui::glyph("✖", "x"))),

    })

}

/// The author's display name: the identity's name, or a Git-Author trailer

/// for imported changes, or a shortened key.

pub fn author_name(repo: &Repo, c: &ChangeMeta) -> String {

    if !c.author.is_zero() {

        if let Ok(id) = repo.identity(&c.author) {

            return id.name;

        }

        return c.author.short(12);

    }

    c.message

        .lines()

        .rev()

        .find_map(|l| l.strip_prefix("Git-Author: "))

        .map(|a| a.split('<').next().unwrap_or(a).trim().to_string())

        .unwrap_or_else(|| "unknown".into())

}

/// The first line of a message, or a placeholder.

pub fn subject_of(message: &str) -> &str {

    match message.lines().next() {

        Some(l) if !l.trim().is_empty() => l,

        _ => "(no description)",

    }

}

pub fn deps_line(c: &Change) -> String {

    deps_of(&c.deps)

}

17 unchanged lines

14 unchanged lines

    let email = email.unwrap_or_else(|| repo.config.author_email.clone());

    let scope = if local { IdentityScope::Repo } else { IdentityScope::User };

    let (key, _) = repo.create_identity(&name, &email, scope)?;

    println!("Created identity {name} <{email}>");

    println!("KeyId: {key}");

    println!("Secret key stored under {}", repo::default_keys_dir().display());

    println!("{} identity {} <{email}>", ui::done("Created"), ui::author(&name));

    println!("{}", ui::kv("key", key));

    println!("{}", ui::kv("secret", ui::path(repo::default_keys_dir().display())));

    match scope {

        IdentityScope::User => println!("Recorded as your default author in {}", repo.user_config_path().display()),

        IdentityScope::Repo => println!("Recorded in this repository's .oxy/config only"),

        IdentityScope::User => println!("{}", ui::kv("scope", format!("default author in {}", ui::path(repo.user_config_path().display())))),

        IdentityScope::Repo => println!("{}", ui::kv("scope", "this repository's .oxy/config only")),

    }

    if !repo.config.sign_changes {

        println!("Changes will carry this author; run `oxy config --user core.sign change` to sign each commit.");

        println!("  {} {}", ui::note(), ui::dim("changes will carry this author; run oxy config --user core.sign change to sign each commit"));

    }

    Ok(0)

}

5 unchanged lines

        return Ok(0);

    };

    let id = repo.identity(&key)?;

    println!("{} <{}>", id.name, id.email);

    println!("KeyId:   {key}");

    println!("Created: {}", when(id.created));

    println!("Secret:  {}", if repo.secret_key()?.is_some() { "available" } else { "NOT FOUND in key directory" });

    println!("Signing: {}", if repo.config.sign_changes { "every change (core.sign = change)" } else { "at push via seals (core.sign = seal)" });

    println!("{} {} <{}>", ui::section("identity"), ui::author(&id.name), id.email);

    println!("{}", ui::kv("key", key));

    println!("{}", ui::kv("created", format!("{} {}", when(id.created), ui::dim(format!("({})", ui::ago(id.created))))));

    println!("{}", ui::kv("secret", if repo.secret_key()?.is_some() { ui::ok(format!("{} available", ui::glyph("✔", "*"))) } else { ui::err(format!("{} not found in the key directory", ui::glyph("✖", "x"))) }));

    println!("{}", ui::kv("signing", if repo.config.sign_changes { "every change (core.sign = change)" } else { "at push via seals (core.sign = seal)" }));

    Ok(0)

}

12 unchanged lines

        let line = signature_line(&repo, &h)?;

        let styled = if line.starts_with("INVALID") {

            bad += 1;

            ui::err(&line)

            ui::err(format!("{} {line}", ui::glyph("✖", "x")))

        } else if line == "unsigned" {

            ui::dim(&line)

            ui::dim(format!("{} {line}", ui::glyph("·", "-")))

        } else {

            ui::ok(&line)

            ui::ok(format!("{} {line}", ui::glyph("✔", "v")))

        };

        println!("{} {}  {styled}", ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))));

    }

4 unchanged lines

    if user {

        let path = repo::default_user_config();

        repo::Config::set_user(&path, key, value)?;

        println!("{key} = {value} (in {})", path.display());

        println!("{} {key} = {value} {}", ui::done("Set"), ui::dim(format!("(in {})", path.display())));

    } else {

        let mut repo = open()?;

        repo.config.set(key, value)?;

        repo.save_config()?;

        println!("{key} = {value} (in this repository)");

        println!("{} {key} = {value} {}", ui::done("Set"), ui::dim("(in this repository)"));

    }

    Ok(0)

}

6 unchanged lines

    let id = repo.identity(&key)?;

    let path = path.unwrap_or_else(|| PathBuf::from(format!("{}.identity", key.short(16))));

    std::fs::write(&path, id.encode())?;

    println!("Wrote identity {} <{}> ({}) to {}", id.name, id.email, key.short(12), path.display());

    println!("{} identity {} <{}> ({}) to {}", ui::done("Wrote"), ui::author(&id.name), id.email, key.short(12), ui::path(path.display()));

    Ok(0)

}

pub fn policy_init() -> Result<i32> {

    let repo = open()?;

    let sp = repo.policy_init()?;

    println!("Created policy serial {} with root key {}; push to publish it.", sp.policy.serial, sp.policy.roots[0].short(12));

    println!("{} policy serial {} with root key {} {}", ui::done("Created"), sp.policy.serial, sp.policy.roots[0].short(12), ui::dim("(push to publish it)"));

    Ok(0)

}

5 unchanged lines

    };

    let p = &sp.policy;

    let name = |k: &oxy_core::hash::KeyId| p.identity(k).map(|i| format!("{} <{}>", i.name, i.email)).unwrap_or_else(|| "(unknown identity)".into());

    println!("policy #{} serial {} expires {}{}", r.short(12), p.serial, when(p.expires), if p.is_expired(oxy_core::objects::Hlc::now().wall_ms) { "  EXPIRED" } else { "" });

    println!("roots (threshold {}):", p.root_threshold);

    let expired = p.is_expired(oxy_core::objects::Hlc::now().wall_ms);

    println!("{} {}{}serial {}{}expires {}{}", ui::section("policy"), ui::hash(format!("#{}", r.short(12))), ui::sep(), p.serial, ui::sep(), when(p.expires), if expired { ui::err(format!("  {} EXPIRED", ui::glyph("✖", "x"))) } else { String::new() });

    println!("{}", ui::section(format!("roots {}", ui::dim(format!("(threshold {})", p.root_threshold)))));

    for k in &p.roots {

        println!("  {}  {}", k.short(12), name(k));

        println!("  {} {}  {}", ui::ok(ui::glyph("🔑", "*")), ui::hash(k.short(12)), ui::author(name(k)));

    }

    println!("rules:");

    println!("{}", ui::section("rules"));

    for rule in &p.rules {

        println!("  {:12} threshold {} require {} conflicts {}", rule.pattern, rule.threshold, rule.require.name(), if rule.allow_conflicts { "allowed" } else { "refused" });

        println!("  {} {:12} {}", ui::ok(ui::glyph("▸", ">")), ui::bookmark(&rule.pattern), ui::dim(format!("threshold {}, require {}, conflicts {}", rule.threshold, rule.require.name(), if rule.allow_conflicts { "allowed" } else { "refused" })));

        for k in &rule.keys {

            println!("      {}  {}", k.short(12), name(k));

            println!("      {}  {}", ui::hash(k.short(12)), ui::author(name(k)));

        }

    }

    if !p.revoked.is_empty() {

        println!("revoked:");

        println!("{}", ui::section("revoked"));

        for k in &p.revoked {

            println!("  {}  {}", k.short(12), name(k));

            println!("  {} {}  {}", ui::err(ui::glyph("✖", "x")), ui::hash(k.short(12)), ui::author(name(k)));

        }

    }

    Ok(0)

4 unchanged lines

    let id = Identity::decode(&std::fs::read(identity_file)?)?;

    let key = id.hash();

    let sp = repo.policy_grant(id.clone(), pattern)?;

    println!("Granted {} <{}> ({}) on {}; policy serial {}. Push to publish.", id.name, id.email, key.short(12), pattern.unwrap_or("*"), sp.policy.serial);

    println!("{} {} <{}> ({}) on {} {}", ui::done("Granted"), ui::author(&id.name), id.email, key.short(12), ui::bookmark(pattern.unwrap_or("*")), ui::dim(format!("(policy serial {}; push to publish)", sp.policy.serial)));

    Ok(0)

}

9 unchanged lines

        _ => anyhow::bail!("{key:?} is ambiguous"),

    };

    let sp = repo.policy_revoke(&full)?;

    println!("Revoked {}; policy serial {}. Push to publish.", full.short(12), sp.policy.serial);

    println!("{} {} {}", ui::done("Revoked"), ui::hash(full.short(12)), ui::dim(format!("(policy serial {}; push to publish)", sp.policy.serial)));

    Ok(0)

}

64 unchanged lines

        depends_on: Vec<String>,

    },

    /// List changes reachable from the bookmark and the working copy

    Log,

    Log {

        /// Show at most this many changes

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

        limit: Option<usize>,

        /// Show full messages, dependencies, and signatures

        #[arg(short, long)]

        verbose: bool,

    },

    /// Show what the working copy changes against its base

    Diff,

    /// Change the message of a head (default: the head the working copy sits on)

213 unchanged lines

        Cmd::Status => workspace::status(),

        Cmd::Prompt { format } => workspace::prompt(&format),

        Cmd::Commit { message, depends_on } => workspace::commit(&message, &depends_on),

        Cmd::Log => workspace::log(),

        Cmd::Log { limit, verbose } => workspace::log(limit, verbose),

        Cmd::Diff => workspace::diff(),

        Cmd::Describe { message, change } => workspace::describe(&message, change.as_deref()),

        Cmd::Amend { message, into } => workspace::amend(message.as_deref(), into.as_deref()),

49 unchanged lines

18 unchanged lines

        None => Repo::clone_with(url, &dest, max_blob, sparse)?,

    };

    let heads = repo.bookmark_heads()?;

    sp.done(&format!("{} into {} ({} on {}: {})", ui::ok("Cloned"), ui::path(repo.root().display()), url, ui::id(&repo.config.bookmark), plural(heads.len(), "head")));

    sp.done(&format!("{} into {} {}", ui::done("Cloned"), ui::path(repo.root().display()), ui::dim(format!("({url}, {} with {})", ui::bookmark(&repo.config.bookmark), plural(heads.len(), "head")))));

    Ok(0)

}

1 unchanged lines

    let mut repo = open()?;

    repo.config.set(&format!("remote.{name}.url"), url)?;

    repo.save_config()?;

    println!("Added remote {name} = {url}");

    println!("{} remote {} {} {url}", ui::done("Added"), ui::bookmark(name), ui::dim(ui::glyph("→", "->")));

    Ok(0)

}

1 unchanged lines

    let mut repo = open()?;

    repo.config.set(&format!("remote.{name}.url"), "")?;

    repo.save_config()?;

    println!("Removed remote {name}");

    println!("{} remote {}", ui::done("Removed"), ui::bookmark(name));

    Ok(0)

}

pub fn remote_list() -> Result<i32> {

    let repo = open()?;

    let view = repo.view()?;

    if repo.config.remotes.is_empty() {

        println!("{}", ui::dim("No remotes; add one with oxy remote add <name> <url>."));

    }

    for (name, url) in &repo.config.remotes {

        println!("{name}\t{url}");

        println!("{} {}{}{}", ui::ok(ui::glyph("⇄", "<>")), ui::bookmark(name), ui::sep(), ui::dim(url));

        if let Some(bms) = view.remotes.get(name) {

            for (bm, st) in bms {

                let heads = repo.store().get_state(st).map(|s| s.heads.len()).unwrap_or(0);

                println!("    {bm}: {}", plural(heads, "head"));

                println!("    {} {}{}{}", ui::dim(ui::glyph("↳", "->")), ui::id(format!("{name}/{bm}")), ui::sep(), ui::dim(plural(heads, "head")));

            }

        }

    }

10 unchanged lines

    let sp = ui::spinner(&format!("Fetching from {remote}…"));

    let report = repo.fetch(&remote)?;

    sp.clear();

    if report.refs.is_empty() {

        println!("{} {}", ui::done("Fetched"), ui::dim(format!("nothing new from {remote}")));

    }

    for (name, heads, n) in &report.refs {

        println!("{} {}, {}", ui::id(format!("{remote}/{name}")), plural(heads.len(), "head"), plural(*n, "new change"));

        let what = if *n == 0 { ui::dim("up to date") } else { ui::ok(plural(*n, "new change")) };

        println!("{} {}{}{}{}{what}", ui::done("Fetched"), ui::id(format!("{remote}/{name}")), ui::sep(), ui::dim(plural(heads.len(), "head")), ui::sep());

    }

    if report.new_tags > 0 {

        println!("{}", ui::dim(format!("{} adopted", plural(report.new_tags, "tag"))));

        println!("  {} {}", ui::note(), ui::dim(format!("{} adopted", plural(report.new_tags, "tag"))));

    }

    if report.unverified {

        eprintln!("{} {remote} has no trust policy; nothing fetched from it was verified", ui::warn("warning:"));

        eprintln!("{} {remote} has no trust policy; nothing fetched from it was verified", ui::caution());

    }

    Ok(0)

}

4 unchanged lines

    let sp = ui::spinner(&format!("Pulling from {remote}…"));

    let r = repo.pull(&remote)?;

    if !r.changed {

        sp.done(&ui::dim("Already up to date."));

        sp.done(&format!("{} {}", ui::ok(ui::glyph("✔", "*")), ui::dim("Already up to date.")));

        return Ok(0);

    }

    sp.done(&format!(

        "{} {} now has {}{}",

        ui::ok("Pulled:"),

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

        ui::done("Pulled:"),

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

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

        if r.checked_out { "; working copy updated" } else { "; run `oxy checkout` to update the working copy" }

        ui::dim(if r.checked_out { "; working copy updated" } else { "; run oxy checkout to update the working copy" })

    ));

    let snap = repo.snapshot("oxy pull")?;

    if snap.base_snapshot.is_conflicted() {

        println!("  {}", ui::warn("the result has conflicts; see oxy status"));

        println!("  {} {}", ui::caution(), ui::warn("the result has conflicts; see oxy status"));

    }

    Ok(0)

}

7 unchanged lines

    let mut code = 0;

    for r in results {

        if r.ok {

            println!("{} {}", ui::id(format!("{remote}/{}", r.name)), ui::ok(if r.reason.is_empty() { "updated" } else { r.reason.as_str() }));

            println!("{} {}{}{}", ui::done("Pushed"), ui::id(format!("{remote}/{}", r.name)), ui::sep(), ui::dim(if r.reason.is_empty() { "updated" } else { r.reason.as_str() }));

        } else {

            println!("{} {} {}", ui::id(format!("{remote}/{}", r.name)), ui::err("rejected:"), r.reason);

            println!("{} {} {}{}{}", ui::err(ui::glyph("✖", "x")), ui::err("Rejected"), ui::id(format!("{remote}/{}", r.name)), ui::sep(), r.reason);

            code = 1;

        }

    }

23 unchanged lines

    let r = repo.git_export(git_dir)?;

    sp.clear();

    println!(

        "Exported {} to {} as branch {} (currently {}); {} already exported.",

        "{} {} to {} as branch {} {}",

        ui::done("Exported"),

        plural(r.exported, "new state"),

        git_dir.display(),

        r.branch,

        plural(r.heads, "head"),

        r.skipped

        ui::path(git_dir.display()),

        ui::bookmark(&r.branch),

        ui::dim(format!("(currently {}; {} already exported)", plural(r.heads, "head"), r.skipped))

    );

    Ok(0)

}

5 unchanged lines

    let r = repo.import_git(git_dir, branch)?;

    sp.clear();

    println!(

        "Imported {} ({} merges) from {} {branch} into {} in {:.1?}: {} now has {}.{}",

        "{} {} ({} merges) from {} {} into {} {}",

        ui::done("Imported"),

        plural(r.commits, "commit"),

        r.merges,

        git_dir.display(),

        repo.root().display(),

        started.elapsed(),

        repo.config.bookmark,

        plural(r.heads, "head"),

        if r.skipped_submodules > 0 { format!(" Skipped {} submodule entries.", r.skipped_submodules) } else { String::new() }

        ui::path(git_dir.display()),

        ui::bookmark(branch),

        ui::path(repo.root().display()),

        ui::dim(format!("in {:.1?}; {} now has {}", started.elapsed(), repo.config.bookmark, plural(r.heads, "head")))

    );

    if r.skipped_submodules > 0 {

        println!("  {} {}", ui::note(), ui::dim(format!("skipped {} submodule entries", r.skipped_submodules)));

    }

    Ok(0)

}

11 unchanged lines

7 unchanged lines

use std::time::Duration;

static PLAIN: AtomicBool = AtomicBool::new(false);

static UNICODE: AtomicBool = AtomicBool::new(false);

static INIT: std::sync::Once = std::sync::Once::new();

/// Decide once whether to use colour and animation.

/// Decide once whether to use colour, glyphs, and animation.

pub fn init(plain_flag: bool) {

    INIT.call_once(|| {

        let no_color = std::env::var_os("NO_COLOR").is_some();

1 unchanged lines

        let plain = plain_flag || no_color || !tty;

        PLAIN.store(plain, Ordering::Relaxed);

        console::set_colors_enabled(!plain);

        let utf8 = ["LC_ALL", "LC_CTYPE", "LANG"]

            .iter()

            .filter_map(|k| std::env::var(k).ok())

            .find(|v| !v.is_empty())

            .map(|v| v.to_ascii_uppercase().contains("UTF-8") || v.to_ascii_uppercase().contains("UTF8"))

            .unwrap_or(false);

        UNICODE.store(!plain && utf8, Ordering::Relaxed);

    });

}

1 unchanged lines

    PLAIN.load(Ordering::Relaxed)

}

/// Whether the terminal takes Unicode glyphs (a UTF-8 locale, not `--plain`).

pub fn unicode() -> bool {

    UNICODE.load(Ordering::Relaxed)

}

/// A glyph with an ASCII fallback for plain output and non-UTF-8 locales.

pub fn glyph<'a>(fancy: &'a str, ascii: &'a str) -> &'a str {

    if unicode() { fancy } else { ascii }

}

/// A finished action: a tick and the verb in green.

pub fn done<T: std::fmt::Display>(v: T) -> String {

    format!("{} {}", ok(glyph("✔", "*")), ok(v))

}

/// A warning line prefix.

pub fn caution() -> String {

    warn(glyph("⚠", "!"))

}

/// An informational note prefix.

pub fn note() -> String {

    dim(glyph("ℹ", "i"))

}

/// A section title.

pub fn section<T: std::fmt::Display>(v: T) -> String {

    format!("{} {}", s(glyph("▍", "#")).cyan(), s(v).bold())

}

/// `  key   value`, with the key dimmed and padded.

pub fn kv<T: std::fmt::Display>(key: &str, value: T) -> String {

    format!("  {} {value}", dim(format!("{key:<8}")))

}

/// An author name.

pub fn author<T: std::fmt::Display>(v: T) -> String {

    s(v).magenta().to_string()

}

/// A bookmark or reference name.

pub fn bookmark<T: std::fmt::Display>(v: T) -> String {

    s(v).green().bold().to_string()

}

/// The subject line of a message.

pub fn subject<T: std::fmt::Display>(v: T) -> String {

    s(v).bold().to_string()

}

/// A dimmed separator between the parts of a metadata line.

pub fn sep() -> String {

    dim(format!(" {} ", glyph("·", "-")))

}

/// Milliseconds since the epoch as a relative time ("3 minutes ago"), or the

/// date when older than a month.

pub fn ago(ms: u64) -> String {

    let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);

    let secs = now.saturating_sub(ms) / 1000;

    let unit = |n: u64, w: &str| format!("{n} {w}{} ago", if n == 1 { "" } else { "s" });

    match secs {

        0..=44 => "just now".into(),

        45..=89 => "a minute ago".into(),

        90..=2_699 => unit(secs.div_ceil(60), "minute"),

        2_700..=5_399 => "an hour ago".into(),

        5_400..=79_199 => unit(secs.div_ceil(3_600), "hour"),

        79_200..=129_599 => "yesterday".into(),

        129_600..=2_591_999 => unit(secs.div_ceil(86_400), "day"),

        _ => super::format::when(ms).split(' ').next().unwrap_or("").to_string(),

    }

}

/// The bullet for a log entry: the working copy, a head, or an ordinary change.

pub fn log_bullet(working_copy: bool, head: bool, conflicted: bool) -> String {

    if working_copy {

        s(glyph("◉", "@")).cyan().bold().to_string()

    } else if conflicted {

        err(glyph("✱", "!"))

    } else if head {

        ok(glyph("●", "*"))

    } else {

        dim(glyph("○", "o"))

    }

}

/// The vertical rail joining log entries.

pub fn rail() -> String {

    dim(glyph("│", "|"))

}

/// A status glyph and word for a working-copy change.

pub fn status_mark(tag: &str) -> String {

    let (g, a, word) = match tag {

        "A" => ("✚", "+", "added"),

        "M" => ("✎", "~", "modified"),

        "D" => ("✖", "-", "removed"),

        "X" => ("⚙", "x", "mode"),

        "C!" => ("‼", "!", "markers"),

        "R" => ("✔", "r", "resolved"),

        _ => ("?", "?", "unknown"),

    };

    let text = format!("{} {word:<9}", glyph(g, a));

    self::tag_style(tag, &text)

}

fn tag_style(t: &str, text: &str) -> String {

    match t {

        "A" | "R" => s(text).green().to_string(),

        "M" | "X" => s(text).yellow().to_string(),

        "D" | "C!" => s(text).red().to_string(),

        _ => text.to_string(),

    }

}

fn s<T: std::fmt::Display>(v: T) -> StyledObject<T> {

    style(v)

}

23 unchanged lines

}

pub fn heading<T: std::fmt::Display>(v: T) -> String {

    s(v).bold().underlined().to_string()

}

/// A status tag: green for additions, yellow for modifications, red for removals and conflicts.

pub fn tag(t: &str) -> String {

    match t {

        "A" => s(t).green().bold().to_string(),

        "M" | "X" => s(t).yellow().bold().to_string(),

        "D" | "C!" => s(t).red().bold().to_string(),

        "R" => s(t).cyan().bold().to_string(),

        other => other.to_string(),

    }

}

/// A live spinner with a message, shown only on a terminal. Drop or call

/// `done` to clear it; `done` prints the final line in its place.

pub struct Spinner {

26 unchanged lines

        }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn relative_times() {

        let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_millis() as u64;

        assert_eq!(ago(now), "just now");

        assert_eq!(ago(now - 60_000), "a minute ago");

        assert_eq!(ago(now - 5 * 60_000), "5 minutes ago");

        assert_eq!(ago(now - 3 * 3_600_000), "3 hours ago");

        assert_eq!(ago(now - 25 * 3_600_000), "yesterday");

        assert_eq!(ago(now - 4 * 86_400_000), "4 days ago");

        assert_eq!(ago(0), "1970-01-01");

        assert_eq!(glyph("✔", "*"), if unicode() { "✔" } else { "*" });

    }

}

//! Commands that act on the local repository and working copy.

use super::format::{deps_line, deps_of, plural, short_id, short_meta_id, signature_line, when};

use super::format::{author_name, deps_line, deps_of, plural, short_id, short_meta_id, signature_line, signature_mark, subject_of, when};

use super::open;

use super::ui;

use anyhow::Result;

use oxy_core::objects::ChangeKind;

use oxy_core::repo::{render_change, ChangeStatus, Repo};

use std::path::PathBuf;

pub fn init(path: Option<PathBuf>) -> Result<i32> {

    let path = path.unwrap_or(std::env::current_dir()?);

    let repo = Repo::init(&path)?;

    println!("{} oxy repository in {}", ui::ok("Initialized"), ui::path(repo.root().display()));

    println!("  bookmark {}   author {} <{}>", ui::id(&repo.config.bookmark), repo.config.author_name, repo.config.author_email);

    println!("{} oxy repository in {}", ui::done("Initialized"), ui::path(repo.root().display()));

    println!("{}", ui::kv("bookmark", ui::bookmark(&repo.config.bookmark)));

    println!("{}", ui::kv("author", format!("{} <{}>", ui::author(&repo.config.author_name), repo.config.author_email)));

    Ok(0)

}

15 unchanged lines

    let heads = repo.bookmark_heads()?;

    sp.clear();

    println!(

        "{} {} on {} {}",

        ui::heading("Working copy"),

        "{} {}{}working copy {}{}{}",

        ui::dim("On"),

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

        ui::sep(),

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

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

        ui::dim(format!("({})", plural(heads.len(), "head")))

        ui::sep(),

        ui::dim(plural(heads.len(), "head"))

    );

    if snap.statuses.is_empty() {

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

    }

    for s in &snap.statuses {

        println!("  {:2} {}", ui::tag(status_tag(s.status)), ui::path(&s.path));

        println!("  {} {}", ui::ok(ui::glyph("✔", "*")), ui::dim("nothing to commit, working copy clean"));

    } else {

        println!();

        for s in &snap.statuses {

            println!("  {} {}", ui::status_mark(status_tag(s.status)), ui::path(&s.path));

        }

    }

    if !snap.base_snapshot.is_conflicted() {

        return Ok(0);

    }

    println!();

    println!("{} {}", ui::err("Conflicts"), ui::dim("edit the marked files, or the .oxy-conflict-N candidates, then commit"));

    println!("{} {}", ui::section(ui::err("Conflicts")), ui::dim("edit the marked files, or the .oxy-conflict-N candidates, then commit"));

    for c in &snap.base_snapshot.tree.conflicts {

        println!("  tree: {c:?}");

        println!("  {} tree: {c:?}", ui::err(ui::glyph("✱", "!")));

    }

    for (p, f) in &snap.base_snapshot.files {

        if f.is_conflicted() {

            let state = match snap.statuses.iter().find(|s| s.path == *p).map(|s| s.status) {

                Some(ChangeStatus::Resolved) => ui::ok("resolved in working copy"),

                Some(ChangeStatus::ConflictEdited) => ui::warn("markers remain"),

                _ => ui::err("unresolved"),

                Some(ChangeStatus::Resolved) => ui::ok(format!("{} resolved in working copy", ui::glyph("✔", "*"))),

                Some(ChangeStatus::ConflictEdited) => ui::warn(format!("{} markers remain", ui::glyph("‼", "!"))),

                _ => ui::err(format!("{} unresolved", ui::glyph("✱", "!"))),

            };

            println!("  {}  {state}", ui::path(p));

        }

10 unchanged lines

    let sp = ui::spinner("Committing…");

    let h = repo.commit(message, &deps)?;

    let c = repo.store().get_change(&h)?;

    sp.done(&format!("{} {} {} {}", ui::ok("Committed"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), message.lines().next().unwrap_or("")));

    sp.done(&format!("{} {} {}  {}", ui::done("Committed"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), ui::subject(subject_of(message))));

    Ok(0)

}

pub fn log() -> Result<i32> {

/// The log: one entry per change, newest first, joined by a rail. The

/// default view is the subject and a metadata line; `verbose` adds the full

/// message, dependencies, and the authenticating key.

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

    let repo = open()?;

    repo.snapshot("oxy log")?;

    for e in repo.log()? {

    let snap = repo.snapshot("oxy log")?;

    let conflicted = snap.base_snapshot.is_conflicted();

    let entries = repo.log()?;

    let total = entries.len();

    let shown = limit.unwrap_or(total).min(total);

    let rail = ui::rail();

    for (i, e) in entries.iter().take(shown).enumerate() {

        let c = &e.change;

        let mut flags = Vec::new();

        let bullet = ui::log_bullet(e.is_working_copy, e.is_head, e.is_working_copy && conflicted);

        let mut labels = Vec::new();

        if e.is_working_copy {

            flags.push("working copy");

            labels.push(ui::warn("working copy"));

        }

        if e.is_head {

            flags.push("head");

        if c.kind == ChangeKind::Resolution {

            labels.push(ui::warn("resolution"));

        }

        let flags = if flags.is_empty() { String::new() } else { ui::warn(format!(" ({})", flags.join(", "))) };

        println!("{} {}{}", ui::id(short_meta_id(c)), ui::hash(format!("#{}", e.hash.short(12))), flags);

        println!("    {}", ui::dim(when(c.hlc.wall_ms)));

        if !c.deps.is_empty() {

            println!("    {}", ui::dim(format!("deps: {}", deps_of(&c.deps))));

        let labels = if labels.is_empty() { String::new() } else { format!(" {}{}{}", ui::dim("("), labels.join(ui::dim(", ").as_str()), ui::dim(")")) };

        let subject = if e.is_working_copy && c.message.is_empty() {

            ui::dim(if snap.statuses.is_empty() { "(clean)" } else { "(uncommitted changes)" })

        } else {

            ui::subject(subject_of(&c.message))

        };

        println!("{bullet} {}{labels}  {subject}", ui::id(short_meta_id(c)));

        let meta = format!(

            "{}{}{}{}{}{}{}",

            ui::hash(format!("#{}", e.hash.short(12))),

            ui::sep(),

            ui::author(author_name(&repo, c)),

            ui::sep(),

            ui::dim(ui::ago(c.hlc.wall_ms)),

            ui::sep(),

            if e.is_working_copy { ui::dim("not yet committed") } else { signature_mark(&repo, &e.hash)? }

        );

        println!("{rail} {meta}");

        if verbose {

            if !e.is_working_copy {

                println!("{rail} {}", ui::dim(format!("{} {}", when(c.hlc.wall_ms), signature_line(&repo, &e.hash)?)));

            }

            if !c.deps.is_empty() {

                println!("{rail} {} {}", ui::dim(ui::glyph("↳", "->")), ui::dim(deps_of(&c.deps)));

            }

            let body: Vec<&str> = c.message.lines().skip(1).skip_while(|l| l.trim().is_empty()).collect();

            if !body.is_empty() {

                println!("{rail}");

                for line in body {

                    println!("{rail}   {line}");

                }

            }

        }

        let msg = if c.message.is_empty() { "(no description)" } else { &c.message };

        for line in msg.lines() {

            println!("    {line}");

        if i + 1 < shown {

            println!("{rail}");

        }

        println!();

    }

    if shown < total {

        println!("{}", ui::dim(format!("{} {} more; pass -n to see them", ui::glyph("…", "..."), total - shown)));

    }

    Ok(0)

}

9 unchanged lines

    repo.snapshot("oxy show")?;

    let h = repo.resolve_change(change)?;

    let c = repo.store().get_change(&h)?;

    println!("{} {} {}", ui::heading("change"), ui::id(short_id(&c)), ui::hash(format!("#{h}")));

    println!("  kind  {:?}", c.kind);

    println!("  date  {}", when(c.hlc.wall_ms));

    println!("  deps  {}", ui::dim(deps_line(&c)));

    println!("  sig   {}", signature_line(&repo, &h)?);

    println!("\n{}\n", if c.message.is_empty() { "(no description)" } else { &c.message });

    println!("{} {} {}", ui::section("change"), ui::id(short_id(&c)), ui::hash(format!("#{h}")));

    println!("{}", ui::kv("kind", format!("{:?}", c.kind).to_lowercase()));

    println!("{}", ui::kv("author", ui::author(author_name(&repo, &oxy_core::state::ChangeMeta::of(&c)))));

    println!("{}", ui::kv("date", format!("{} {}", when(c.hlc.wall_ms), ui::dim(format!("({})", ui::ago(c.hlc.wall_ms))))));

    println!("{}", ui::kv("deps", ui::dim(deps_line(&c))));

    println!("{}", ui::kv("sig", signature_line(&repo, &h)?));

    println!();

    for line in (if c.message.is_empty() { "(no description)" } else { &c.message }).lines() {

        println!("    {line}");

    }

    println!();

    print!("{}", repo.describe_change(&h)?);

    Ok(0)

}

12 unchanged lines

    let spec = if changes.is_empty() { repo.config.bookmark.clone() } else { changes.join(" ") };

    let sp = ui::spinner(&format!("Checking out {spec}…"));

    let r = repo.checkout(&heads, discard, &format!("oxy checkout {spec}"))?;

    sp.done(&format!("{} on {}: {} written, {} removed", ui::ok("Working copy"), ui::id(&spec), plural(r.written, "file"), r.removed));

    sp.done(&format!("{} on {}: {} written, {} removed", ui::done("Working copy"), ui::bookmark(&spec), plural(r.written, "file"), r.removed));

    if r.conflicted {

        println!("  {}", ui::warn("this state has conflicts; see oxy status"));

        println!("  {} {}", ui::caution(), ui::warn("this state has conflicts; see oxy status"));

    }

    Ok(0)

}

37 unchanged lines

pub fn undo() -> Result<i32> {

    let repo = open()?;

    let op = repo.undo()?;

    println!("{} now at: {}", ui::ok("Undone;"), ui::dim(&op.command));

    println!("{} now at: {}", ui::done("Undone;"), ui::dim(&op.command));

    Ok(0)

}

pub fn op_log() -> Result<i32> {

    let repo = open()?;

    for (i, (r, op)) in repo.op_log()?.into_iter().enumerate() {

        println!("{}{} {}  {}", if i == 0 { ui::ok("@ ") } else { "  ".into() }, ui::hash(r.short(12)), ui::dim(when(op.hlc.wall_ms)), op.command);

        let bullet = if i == 0 { ui::ok(ui::glyph("●", "@")) } else { ui::dim(ui::glyph("○", "o")) };

        let cmd = subject_of(&op.command).split("\\n").next().unwrap_or("");

        println!("{bullet} {}{}{}  {}", ui::hash(r.short(12)), ui::sep(), ui::dim(format!("{:<16}", ui::ago(op.hlc.wall_ms))), if i == 0 { ui::subject(cmd) } else { cmd.to_string() });

    }

    Ok(0)

}

41 unchanged lines

    };

    let new = repo.describe(&h, message)?;

    let c = repo.store().get_change(&new)?;

    println!("{} {} {} {}", ui::ok("Described"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), message.lines().next().unwrap_or(""));

    println!("{} {} {}  {}", ui::done("Described"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), ui::subject(subject_of(message)));

    Ok(0)

}

7 unchanged lines

        None => repo.amend(message)?,

    };

    let c = repo.store().get_change(&new)?;

    println!("{} {} {} {}", ui::ok("Amended"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), c.message.lines().next().unwrap_or(""));

    println!("{} {} {}  {}", ui::done("Amended"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), ui::subject(subject_of(&c.message)));

    Ok(0)

}

2 unchanged lines

    let h = repo.resolve_change(change)?;

    let c = repo.store().get_change(&h)?;

    let notes = repo.abandon(&h)?;

    println!("Abandoned {} #{}; its content remains on disk as uncommitted work if the working copy sat on it.", short_id(&c), h.short(12));

    println!("{} {} {}  {}", ui::done("Abandoned"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), ui::dim("its content remains on disk as uncommitted work if the working copy sat on it"));

    for n in notes {

        println!("  {} {n}", ui::warn("note:"));

        println!("  {} {n}", ui::note());

    }

    Ok(0)

}

2 unchanged lines

    let repo = open()?;

    let sp = ui::spinner("Writing checkpoint…");

    let (r, changes, bytes) = repo.checkpoint()?;

    sp.done(&format!("{} {} of {} ({} bytes) for {}", ui::ok("Checkpoint"), ui::hash(format!("#{}", r.short(12))), plural(changes, "change"), bytes, ui::id(&repo.config.bookmark)));

    sp.done(&format!("{} {} of {} ({} bytes) for {}", ui::done("Checkpoint"), ui::hash(format!("#{}", r.short(12))), plural(changes, "change"), bytes, ui::id(&repo.config.bookmark)));

    Ok(0)

}

45 unchanged lines

    };

    let t = repo.tag_create(name, &heads, message)?;

    println!(

        "{} {} -> {} ({}){}",

        ui::ok("Tagged"),

        ui::id(&t.name),

        "{} {} {} {} ({}){}",

        ui::done("Tagged"),

        ui::bookmark(&t.name),

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

        ui::hash(format!("#{}", t.state.short(12))),

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

        t.signer.map(|s| format!(", signed by {s}")).unwrap_or_else(|| ui::dim(", unsigned"))

9 unchanged lines

    }

    for t in tags {

        println!(

            "{} {} {}{}{}",

            ui::id(&t.name),

            "{} {} {}{}{}{}",

            ui::ok(ui::glyph("⚑", "#")),

            ui::bookmark(&t.name),

            ui::hash(format!("#{}", t.state.short(12))),

            ui::dim(format!("({})", plural(t.heads.len(), "head"))),

            if t.message.is_empty() { String::new() } else { format!("  {}", t.message.lines().next().unwrap_or("")) },

            t.signer.map(|s| ui::dim(format!("  [{s}]"))).unwrap_or_default()

            ui::sep() + &ui::dim(plural(t.heads.len(), "head")),

            if t.message.is_empty() { String::new() } else { format!("  {}", ui::subject(subject_of(&t.message))) },

            t.signer.map(|s| ui::sep() + &ui::ok(format!("{} {s}", ui::glyph("✔", "v")))).unwrap_or_default()

        );

    }

    Ok(0)

12 unchanged lines

    };

    let sp = ui::spinner(&format!("Creating workspace at {}…", path.display()));

    let ws = repo.workspace_add(path, heads.as_deref())?;

    sp.done(&format!("{} {} (workspace {})", ui::ok("Workspace created at"), ui::path(ws.root().display()), ui::id(ws.workspace().short(8))));

    sp.done(&format!("{} {} (workspace {})", ui::done("Workspace created at"), ui::path(ws.root().display()), ui::id(ws.workspace().short(8))));

    Ok(0)

}

2 unchanged lines

    for w in repo.workspaces()? {

        println!(

            "{} {} {}{}",

            if w.current { ui::ok("*") } else { " ".into() },

            if w.current { ui::ok(ui::glyph("●", "*")) } else { ui::dim(ui::glyph("○", "o")) },

            ui::id(w.id.short(8)),

            ui::path(w.path.display()),

            w.working_copy.map(|h| ui::dim(format!("  wc #{}", h.short(12)))).unwrap_or_else(|| ui::warn("  (not in view)"))

            w.working_copy.map(|h| ui::sep() + &ui::dim(format!("working copy #{}", h.short(12)))).unwrap_or_else(|| ui::sep() + &ui::warn("not in view"))

        );

    }

    Ok(0)

10 unchanged lines

        _ => anyhow::bail!("{spec:?} is ambiguous"),

    };

    repo.workspace_forget(&w.id)?;

    println!("{} workspace {} at {}; its files were left in place.", ui::ok("Forgot"), ui::id(w.id.short(8)), ui::path(w.path.display()));

    println!("{} workspace {} at {}; its files were left in place.", ui::done("Forgot"), ui::id(w.id.short(8)), ui::path(w.path.display()));

    Ok(0)

}

pub fn lock(path: &str) -> Result<i32> {

    let repo = open()?;

    repo.lock_path(path)?;

    println!("{} {} (advisory, local)", ui::ok("Locked"), ui::path(path));

    println!("{} {} {}", ui::done("Locked"), ui::path(path), ui::dim("(advisory, local)"));

    Ok(0)

}

pub fn unlock(path: &str) -> Result<i32> {

    let repo = open()?;

    repo.unlock_path(path)?;

    println!("{} {}", ui::ok("Unlocked"), ui::path(path));

    println!("{} {}", ui::done("Unlocked"), ui::path(path));

    Ok(0)

}

3 unchanged lines

    let (h1, h2) = repo.split(&h, paths)?;

    let c1 = repo.store().get_change(&h1)?;

    let c2 = repo.store().get_change(&h2)?;

    println!("{} into {} {} and {} {}", ui::ok("Split"), ui::id(short_id(&c1)), ui::hash(format!("#{}", h1.short(12))), ui::id(short_id(&c2)), ui::hash(format!("#{}", h2.short(12))));

    println!("{} into {} {} and {} {}", ui::done("Split"), ui::id(short_id(&c1)), ui::hash(format!("#{}", h1.short(12))), ui::id(short_id(&c2)), ui::hash(format!("#{}", h2.short(12))));

    Ok(0)

}