bigger fold triangles, ages on changes, repo name in header, version in help

- fold triangles are ▼/▶ instead of the small ▾/▸
- each change shows how long ago its file was written, hidden before
  the squares when the path would run short
- the UI wakes when an age on screen next reads differently, so ages
  tick each second under a minute and are never stale; polling keeps
  its own timer so this does not refresh git more often
- the header starts with the repo's folder name when there is room
- the help box title shows the version, centered

Author: dfallman

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "gitst"
-version = "0.1.13"
+version = "0.1.14"
 edition = "2024"
 description = "Live, glanceable git status TUI for small terminal panes"
 license = "MIT"

Cargo.toml

@@ -1,6 +1,7 @@
 //! UI state and input handling. Drawing fills in the hit map and navigation
 //! list; input is resolved against whatever was drawn last.
 
+use std::cell::Cell;
 use std::collections::{BTreeSet, HashMap, HashSet};
 use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
@@ -155,6 +156,8 @@ pub struct App {
     pub snap: Option<Arc<Snapshot>>,
     pub error: Option<String>,
     pub config_warning: Option<String>,
+    /// The work tree's folder name, shown before the branch.
+    pub repo_name: Option<String>,
     pub fetch: FetchStatus,
     pub live: Vec<ActivityEvent>,
     pub pulses: HashMap<String, Instant>,
@@ -185,6 +188,8 @@ pub struct App {
     pub detail_targets: Vec<Option<Target>>,
     /// Filled by draw: rows of the section or detail body, for paging.
     pub page: usize,
+    /// Filled by draw: how long until an age on screen reads differently.
+    pub age_wake: Cell<Option<Duration>>,
     /// Whether something on screen may have changed since the last draw.
     pub redraw: bool,
 }
@@ -218,6 +223,7 @@ impl App {
             snap: None,
             error: None,
             config_warning: None,
+            repo_name: None,
             fetch,
             live: Vec::new(),
             pulses: HashMap::new(),
@@ -238,6 +244,7 @@ impl App {
             row_targets: HashMap::new(),
             detail_targets: Vec::new(),
             page: 10,
+            age_wake: Cell::new(None),
             redraw: true,
         }
     }
@@ -341,6 +348,7 @@ impl App {
             .filter(|a| *a < STALE_LOCK)
             .map(|a| (STALE_LOCK - a).max(Duration::from_millis(200)));
         let wake = self.base_wakeup(ttl);
+        let wake = self.age_wake.get().map_or(wake, |a| a.min(wake));
         lock.map_or(wake, |l| l.min(wake))
     }
 

src/app.rs

@@ -127,6 +127,10 @@ fn run(
         },
     );
     app.config_warning = warning;
+    app.repo_name = repo
+        .root
+        .file_name()
+        .map(|n| n.to_string_lossy().into_owned());
     // Without a watcher, fall back to refreshing every few seconds.
     let (_watch, poll) = match watch::spawn(&repo, worker.sender()) {
         Ok(h) => (Some(h), None),
@@ -144,24 +148,31 @@ fn run(
     // Ages, the spinner and pulses change with time alone, so a redraw is
     // due by this time even if every message until then is one that does
     // not redraw, such as a pointer move.
+    // Polling keeps its own time, so redraws for ages, which can come each
+    // second, do not refresh any more often.
     let mut due = Instant::now();
+    let mut poll_due = poll.map(|p| Instant::now() + p);
     loop {
         if app.take_redraw() {
             app.now = SystemTime::now();
             terminal.draw(|f| ui::draw(f, &mut app, theme))?;
-            let wait = poll.map_or(app.next_wakeup(), |p| p.min(app.next_wakeup()));
-            due = Instant::now() + wait;
+            due = Instant::now() + app.next_wakeup();
         }
-        let first = match ui_rx.recv_timeout(due.saturating_duration_since(Instant::now())) {
+        let until = poll_due.map_or(due, |p| p.min(due));
+        let first = match ui_rx.recv_timeout(until.saturating_duration_since(Instant::now())) {
             Ok(m) => Some(m),
             Err(RecvTimeoutError::Timeout) => None,
             Err(RecvTimeoutError::Disconnected) => break,
         };
-        if Instant::now() >= due {
+        let now = Instant::now();
+        if now >= due {
             app.redraw = true;
-            if poll.is_some() {
-                let _ = worker.send(WorkerMsg::Refresh);
-            }
+        }
+        if let (Some(p), Some(at)) = (poll, poll_due)
+            && now >= at
+        {
+            let _ = worker.send(WorkerMsg::Refresh);
+            poll_due = Some(now + p);
         }
         let mut quit = false;
         app.now = SystemTime::now();

src/main.rs

@@ -1,25 +1,29 @@
 //! The stacked, collapsible dashboard.
 
 use std::collections::HashSet;
-use std::time::{Duration, Instant};
+use std::time::{Duration, Instant, UNIX_EPOCH};
 
 use ratatui::Frame;
 use ratatui::layout::Rect;
 use ratatui::style::{Modifier, Style};
 use ratatui::text::{Line, Span};
 use ratatui::widgets::{Block, BorderType, Paragraph};
 
-use super::fmt::{clock, rel_age, truncate_left};
+use super::fmt::{clock, truncate_left, width};
 use super::layout::{Density, SectionId, SectionReq, Slot, allocate};
 use super::theme::Theme;
-use super::{leak_marker, line_lr, now_secs, spans_width, truncate_spans};
+use super::{age_of, leak_marker, line_lr, spans_width, truncate_spans};
 use crate::activity::{ActivityKind, merged};
 use crate::app::{Action, App, NavItem, ScrollTarget, Target};
 use crate::model::{Change, Commit, Counts, Snapshot};
 
 /// Most activity rows kept in the section.
 const ACTIVITY_ROWS: usize = 100;
 const METER_CELLS: usize = 5;
+/// Path cells a change row keeps before it gives up its age.
+const MIN_PATH: usize = 20;
+/// Cells set aside for a change's age: a space and up to `12mo`.
+const AGE_RESERVE: usize = 5;
 
 struct Row {
     line: Line<'static>,
@@ -253,7 +257,7 @@ fn pad_right(mut spans: Vec<Span<'static>>) -> Vec<Span<'static>> {
 
 fn title_spans(s: &Section, expanded: bool, theme: &Theme) -> Vec<Span<'static>> {
     let mut spans = vec![
-        Span::styled(if expanded { "▾ " } else { "▸ " }, theme.dim),
+        Span::styled(if expanded { "▼ " } else { "▶ " }, theme.dim),
         Span::styled(s.id.title(), Style::new().add_modifier(Modifier::BOLD)),
     ];
     if let Some(n) = s.count {
@@ -435,12 +439,28 @@ fn changes(snap: &Snapshot, app: &App, theme: &Theme, w: usize, d: Density) -> S
         .filter(|l| l.source.oid().is_none())
         .map(|l| l.path.as_str())
         .collect();
+    // The age goes before the squares do: only while the path keeps room.
+    let fixed = 3 + stats_w + if d.stats { 1 + METER_CELLS } else { 0 } + 2;
+    let path_room = w.saturating_sub(fixed + 1);
+    let ages: Vec<Option<String>> = if d.ages && path_room >= MIN_PATH + AGE_RESERVE {
+        snap.changes
+            .iter()
+            .map(|c| {
+                let t = c.modified?.duration_since(UNIX_EPOCH).ok()?;
+                Some(age_of(app, t.as_secs() as i64))
+            })
+            .collect()
+    } else {
+        Vec::new()
+    };
+    let age_w = ages.iter().flatten().map(|a| width(a)).max();
     let ttl = Duration::from_secs(app.pulse_secs);
     let now = Instant::now();
     let mut rows: Vec<Row> = snap
         .changes
         .iter()
-        .map(|c| {
+        .enumerate()
+        .map(|(i, c)| {
             let mut left = status_spans(c, theme);
             left.push(Span::raw(" "));
             let mut right = Vec::new();
@@ -470,6 +490,10 @@ fn changes(snap: &Snapshot, app: &App, theme: &Theme, w: usize, d: Density) -> S
             };
             right.push(Span::raw(" "));
             right.push(pulse);
+            if let Some(age_w) = age_w {
+                let age = ages[i].as_deref().unwrap_or("");
+                right.push(Span::styled(format!(" {age:>age_w$}"), theme.dim));
+            }
             let display = match &c.orig_path {
                 Some(orig) => format!("{orig} → {}", c.path),
                 None => c.path.clone(),
@@ -543,7 +567,7 @@ fn activity(snap: &Snapshot, app: &App, theme: &Theme, w: usize, d: Density) ->
 
 fn age_span(time: i64, app: &App, theme: &Theme, d: Density) -> Vec<Span<'static>> {
     if d.ages {
-        vec![Span::styled(rel_age(now_secs(app) - time), theme.dim)]
+        vec![Span::styled(age_of(app, time), theme.dim)]
     } else {
         Vec::new()
     }

src/ui/dashboard.rs

@@ -9,10 +9,10 @@ use ratatui::widgets::{
 };
 
 use super::dashboard::{commit_row, meter, row, stats_spans};
-use super::fmt::{clock, clusters, rel_age, truncate_left, width};
+use super::fmt::{clock, clusters, truncate_left, width};
 use super::layout::Density;
 use super::theme::Theme;
-use super::{now_secs, spans_width};
+use super::{age_of, spans_width};
 use crate::app::{App, ScrollTarget, Target};
 use crate::model::{
     Commit, CommitDetail, DetailData, DiffBlock, DiffKind, Leak, LeakSource, Snapshot,
@@ -225,11 +225,7 @@ fn commit_lines(
         Span::styled(" commit ", theme.dim),
         Span::styled(c.oid.clone(), Style::new().fg(theme.modified)),
     ])));
-    let when = format!(
-        " · {} ago · {}",
-        rel_age(now_secs(app) - c.time),
-        clock(c.time)
-    );
+    let when = format!(" · {} ago · {}", age_of(app, c.time), clock(c.time));
     out.push(plain(Line::from(vec![
         Span::raw(format!(" {}", c.author)),
         Span::styled(when, theme.dim),
@@ -525,10 +521,13 @@ pub fn draw_help(f: &mut Frame, app: &mut App, theme: &Theme, area: Rect) {
     let block = Block::bordered()
         .border_type(BorderType::Rounded)
         .border_style(Style::new().fg(theme.accent))
-        .title(Span::styled(
-            " gitst ",
-            Style::new().add_modifier(Modifier::BOLD),
-        ));
+        .title(
+            Line::from(Span::styled(
+                concat!(" gitst ", env!("CARGO_PKG_VERSION"), " "),
+                Style::new().add_modifier(Modifier::BOLD),
+            ))
+            .centered(),
+        );
     let inner = block.inner(r);
     f.render_widget(Clear, r);
     f.render_widget(block, r);

src/ui/detail.rs

@@ -87,6 +87,49 @@ pub fn rel_age(secs: i64) -> String {
     }
 }
 
+/// Seconds until `rel_age(secs)` reads differently, as `secs` grows by one
+/// a second.
+pub fn age_changes_in(secs: i64) -> i64 {
+    const DAY: i64 = 86_400;
+    if secs < -60 {
+        // `in …` counts down: it changes as the age drops below the unit it
+        // shows, and becomes `now` once less than a minute ahead.
+        let ahead = secs.saturating_neg();
+        let unit = unit_of(ahead);
+        return (ahead % unit + 1).min(ahead - 60);
+    }
+    if secs < 10 {
+        return 10 - secs;
+    }
+    // A unit's count changes each unit, and the unit itself at the end of
+    // its range, which need not fall on a whole number of units.
+    let end = match secs {
+        s if s < 60 => 60,
+        s if s < 3600 => 3600,
+        s if s < DAY => DAY,
+        s if s < 7 * DAY => 7 * DAY,
+        s if s < 60 * DAY => 60 * DAY,
+        s if s < 365 * DAY => 365 * DAY,
+        _ => return 365 * DAY - secs % (365 * DAY),
+    };
+    let unit = unit_of(secs);
+    (unit - secs % unit).min(end - secs)
+}
+
+/// The unit `rel_age` counts a non-negative age in.
+fn unit_of(secs: i64) -> i64 {
+    const DAY: i64 = 86_400;
+    match secs {
+        s if s < 60 => 1,
+        s if s < 3600 => 60,
+        s if s < DAY => 3600,
+        s if s < 7 * DAY => DAY,
+        s if s < 60 * DAY => 7 * DAY,
+        s if s < 365 * DAY => 30 * DAY,
+        _ => 365 * DAY,
+    }
+}
+
 /// Local wall-clock `HH:MM` for a unix time.
 pub fn clock(unix: i64) -> String {
     match Local.timestamp_opt(unix, 0) {
@@ -156,6 +199,46 @@ mod tests {
         assert_eq!(rel_age(800 * 86400), "2y");
     }
 
+    #[test]
+    fn age_changes_exactly_when_its_label_does() {
+        const DAY: i64 = 86_400;
+        let starts = [
+            -400 * DAY,
+            -61 * DAY,
+            -8 * DAY,
+            -DAY - 5,
+            -3601,
+            -125,
+            -61,
+            -60,
+            0,
+            9,
+            10,
+            59,
+            60,
+            3599,
+            DAY - 1,
+            7 * DAY - 1,
+            60 * DAY - 1,
+            365 * DAY - 1,
+            400 * DAY,
+        ];
+        for s in starts {
+            let n = age_changes_in(s);
+            assert!(n >= 1, "{s}: {n}");
+            // Checking each second is too slow for the longest units.
+            if n <= 2 * DAY {
+                for k in 1..n {
+                    assert_eq!(rel_age(s + k), rel_age(s), "{s}+{k}");
+                }
+            }
+            assert_ne!(rel_age(s + n), rel_age(s), "{s}+{n}");
+        }
+        assert_eq!(age_changes_in(59 * DAY), DAY, "8w becomes 2mo");
+        assert!(age_changes_in(i64::MAX) >= 1);
+        assert!(age_changes_in(i64::MIN) >= 1);
+    }
+
     #[test]
     fn clock_is_hh_mm() {
         let c = clock(1_790_484_333);