Wrap long warnings onto up to three rows, and clear them with c or a click

Author: dfallman

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## Unreleased
+
+### Added
+
+- `c` clears the warnings under the header, and clicking a warning clears
+  that one. A cleared warning shows again if it changes, or goes away and
+  comes back. The secrets band and a failed refresh cannot be cleared.
+
+### Changed
+
+- A long warning wraps onto up to three rows, when there are rows to
+  spare, instead of being cut off at the end of one. A pane at least 12
+  rows tall has room for three warning rows, up from two.
+
 ## 0.1.15 (2026-10-15)
 
 ### Changed

README.md

@@ -50,7 +50,13 @@ The dashboard has five sections:
 
 Warnings appear under the header for possible secrets, conflicts, an
 `index.lock` held for more than 10 seconds, failed fetches, and config errors.
-When there are more than fit, the last row lists the rest.
+A long warning wraps onto up to three rows when there is room. When there are
+more than fit, the last row lists the rest.
+
+Press `c`, or click a warning, to clear it. A cleared warning shows again if
+it changes, or goes away and comes back. The secrets band cannot be cleared,
+and neither can a failed refresh, which explains why the panes below are
+dimmed.
 
 ### Secret warnings
 
@@ -90,6 +96,7 @@ warning says so, and the last findings stay.
   right-click to return.
 - **Click** a section title to fold it. The **wheel** scrolls what is under the pointer.
 - **Click** `↻` (or press `f`) to fetch now.
+- **Click** a warning to clear it.
 
 ### Keys
 
@@ -105,6 +112,7 @@ warning says so, and the last findings stay.
 | `w` | | wrap long lines |
 | `f` | fetch now | fetch now |
 | `s` | possible secrets | possible secrets |
+| `c` | clear warnings | clear warnings |
 | `?` | help | help |
 | `q` / `Ctrl-C` | quit | quit |
 | `Ctrl-Z` | suspend (`fg` resumes; not on Windows) | suspend |

src/app.rs

@@ -93,6 +93,8 @@ pub enum Action {
     Help,
     Quit,
     ToggleWrap,
+    /// Hides these warnings until they change.
+    Clear(Vec<String>),
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -156,6 +158,11 @@ pub struct App {
     pub snap: Option<Arc<Snapshot>>,
     pub error: Option<String>,
     pub config_warning: Option<String>,
+    /// Warnings cleared from view, by key. A key is dropped once its
+    /// warning is gone, so the warning shows again if it comes back.
+    pub cleared: HashSet<String>,
+    /// Filled by draw: keys of the warnings that `c` clears.
+    pub clearable: Vec<String>,
     /// The work tree's folder name, shown before the branch.
     pub repo_name: Option<String>,
     pub fetch: FetchStatus,
@@ -223,6 +230,8 @@ impl App {
             snap: None,
             error: None,
             config_warning: None,
+            cleared: HashSet::new(),
+            clearable: Vec::new(),
             repo_name: None,
             fetch,
             live: Vec::new(),
@@ -444,6 +453,10 @@ impl App {
                 self.wrap = !self.wrap;
                 Vec::new()
             }
+            Action::Clear(keys) => {
+                self.cleared.extend(keys);
+                Vec::new()
+            }
         }
     }
 
@@ -482,6 +495,7 @@ impl App {
             KeyCode::Char('f') => return self.perform(Action::Fetch),
             KeyCode::Char('?') => return self.perform(Action::Help),
             KeyCode::Char('s') => return self.open_leaks(),
+            KeyCode::Char('c') => return self.perform(Action::Clear(self.clearable.clone())),
             _ => {}
         }
         if self.stack.is_empty() {

src/ui/detail.rs

@@ -443,6 +443,7 @@ const DASHBOARD_HELP: &[(&str, &str)] = &[
     ("space", "fold section"),
     ("g G", "top / bottom"),
     ("s", "possible secrets"),
+    ("c", "clear warnings"),
     ("f", "fetch now"),
     ("?", "close help"),
     ("q", "quit"),
@@ -461,6 +462,7 @@ const DETAIL_HELP: &[(&str, &str)] = &[
     ("g G", "top / bottom"),
     ("w", "wrap long lines"),
     ("s", "possible secrets"),
+    ("c", "clear warnings"),
     ("f", "fetch now"),
     ("?", "close help"),
     ("q", "quit"),

src/ui/fmt.rs

@@ -69,6 +69,45 @@ pub fn truncate_right(s: &str, max: usize) -> String {
     format!("{}…", &s[..end])
 }
 
+/// Wraps `s` at spaces into at most `lines` lines of `max` cells, breaking
+/// a word only when it alone is wider. Text past the last line is cut,
+/// and that line ends in `…`.
+pub fn wrap_words(s: &str, max: usize, lines: usize) -> Vec<String> {
+    let (max, lines) = (max.max(1), lines.max(1));
+    let mut out = Vec::new();
+    let mut cur = String::new();
+    let mut used = 0;
+    for word in s.split(' ').filter(|w| !w.is_empty()) {
+        let w = width(word);
+        if used > 0 && used + 1 + w <= max {
+            cur.push(' ');
+            cur.push_str(word);
+            used += 1 + w;
+            continue;
+        }
+        if used > 0 {
+            out.push(std::mem::take(&mut cur));
+            used = 0;
+        }
+        for (_, g, gw) in clusters(word) {
+            if used + gw > max && used > 0 {
+                out.push(std::mem::take(&mut cur));
+                used = 0;
+            }
+            cur.push_str(g);
+            used += gw;
+        }
+    }
+    if used > 0 || out.is_empty() {
+        out.push(cur);
+    }
+    if out.len() > lines {
+        let rest = out.split_off(lines - 1).join(" ");
+        out.push(truncate_right(&rest, max));
+    }
+    out
+}
+
 /// Compact age: `now`, `45s`, `12m`, `3h`, `2d`, `5w`, `3mo`, `2y`. A time
 /// more than a minute ahead, after the clock was set back, is `in 3h`;
 /// less is clock skew, and `now`.
@@ -161,6 +200,27 @@ mod tests {
         assert!(width(&truncate_left("日本語", 1)) <= 1);
     }
 
+    #[test]
+    fn wrap_words_breaks_at_spaces_and_cuts_the_last_line() {
+        assert_eq!(
+            wrap_words("fetch failed: offline", 30, 3),
+            ["fetch failed: offline"]
+        );
+        assert_eq!(
+            wrap_words("config.toml: ignored colour, fetch_interval", 20, 3),
+            ["config.toml: ignored", "colour,", "fetch_interval"]
+        );
+        assert_eq!(
+            wrap_words("one two three four five six", 9, 2),
+            ["one two", "three fo…"]
+        );
+        assert_eq!(wrap_words("abcdefgh", 3, 3), ["abc", "def", "gh"]);
+        assert_eq!(wrap_words("", 10, 3), [""]);
+        for line in wrap_words(&"日本語 ".repeat(9), 5, 3) {
+            assert!(width(&line) <= 5, "{line:?}");
+        }
+    }
+
     #[test]
     fn truncate_right_fits() {
         assert_eq!(truncate_right("hello world", 6), "hello…");

src/ui/mod.rs

@@ -14,18 +14,21 @@ use ratatui::widgets::Paragraph;
 
 use crate::app::{Action, App, STALE_LOCK, Target};
 use crate::model::{Head, Leak, LeakSource, RepoOp, Snapshot};
-use fmt::{age_changes_in, rel_age, truncate_right, width};
+use fmt::{age_changes_in, rel_age, truncate_right, width, wrap_words};
 use layout::Density;
 use theme::Theme;
 
 const SPINNER: [&str; 10] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/// Most rows a long warning wraps onto.
+const WARNING_LINES: usize = 3;
 
 /// Draws the whole UI and records the hit map for the next input.
 pub fn draw(f: &mut Frame, app: &mut App, theme: &Theme) {
     app.hits.clear();
     app.nav.clear();
     app.row_targets.clear();
     app.detail_targets.clear();
+    app.clearable.clear();
     app.age_wake.set(None);
     let area = f.area();
     if area.width == 0 || area.height == 0 {
@@ -54,6 +57,7 @@ pub fn draw(f: &mut Frame, app: &mut App, theme: &Theme) {
     let mut y = area.y;
     let mut left = area.height;
     let max_warnings = match area.height {
+        h if h >= 12 => 3,
         h if h >= 8 => 2,
         h if h >= 5 => 1,
         _ => 0,
@@ -83,19 +87,41 @@ pub fn draw(f: &mut Frame, app: &mut App, theme: &Theme) {
     let mut band = None;
     let mut error_shown = false;
     let rows = max_warnings.min((left - hint_rows) as usize);
-    for w in fit_warnings(warnings(app, &snap, theme, area.width as usize), rows) {
-        let r = Rect::new(area.x, y, area.width, 1);
-        f.render_widget(
-            Paragraph::new(fit_line(w.line, area.width as usize)).style(w.fill),
-            r,
-        );
+    let mut all = warnings(app, &snap, theme, area.width as usize);
+    // A cleared warning that has gone shows again if it comes back.
+    app.cleared
+        .retain(|k| all.iter().any(|w| w.key.as_ref() == Some(k)));
+    all.retain(|w| !w.key.as_ref().is_some_and(|k| app.cleared.contains(k)));
+    app.clearable = all.iter().filter_map(|w| w.key.clone()).collect();
+    for w in &mut all {
+        if let Some(k) = &w.key {
+            w.action = Some(Action::Clear(vec![k.clone()]));
+        }
+    }
+    let shown = fit_warnings(all, rows);
+    // Rows the warnings leave free let a long one wrap.
+    let mut spare = rows - shown.len();
+    for w in shown {
+        let lines = match &w.text {
+            Some((text, style)) => {
+                let max = 1 + spare.min(WARNING_LINES - 1);
+                let lines = warning_lines(text, *style, area.width as usize, max);
+                spare -= lines.len() - 1;
+                lines
+            }
+            None => vec![fit_line(w.line, area.width as usize)],
+        };
+        let r = Rect::new(area.x, y, area.width, lines.len() as u16);
+        f.render_widget(Paragraph::new(lines).style(w.fill), r);
         if let Some(action) = w.action {
+            if matches!(action, Action::Open(_)) {
+                band = Some(r);
+            }
             app.hits.clicks.push((r, action));
-            band = Some(r);
         }
         error_shown |= w.error;
-        y += 1;
-        left -= 1;
+        y += r.height;
+        left -= r.height;
     }
 
     let body = Rect::new(area.x, y, area.width, left - hint_rows);
@@ -353,6 +379,9 @@ struct Warning {
     text: Option<(String, Style)>,
     /// The refresh error: the body below is stale.
     error: bool,
+    /// What clearing it remembers; `None` for the secrets band and the
+    /// refresh error, which cannot be cleared.
+    key: Option<String>,
 }
 
 /// Fits `warnings` into `rows`: when there are more, the last row carries
@@ -372,26 +401,45 @@ fn fit_warnings(mut warnings: Vec<Warning>, rows: usize) -> Vec<Warning> {
                 .iter()
                 .filter_map(|w| w.text.as_ref().map(|t| t.0.as_str()))
                 .collect();
+            let keys: Vec<String> = rest.iter().filter_map(|w| w.key.clone()).collect();
             warnings.push(Warning {
                 line: Line::from(Span::styled(format!(" ⚠ {}", joined.join(" · ")), style)),
                 fill: Style::new(),
-                action: None,
+                action: (!keys.is_empty()).then_some(Action::Clear(keys)),
                 text: None,
                 error: rest.iter().any(|w| w.error),
+                key: None,
             });
         }
         None => {}
     }
     warnings
 }
 
+/// `text` after the warning glyph, wrapped onto at most `max` rows of
+/// `cols` cells, the later rows lined up under the first.
+fn warning_lines(text: &str, style: Style, cols: usize, max: usize) -> Vec<Line<'static>> {
+    wrap_words(text, cols.saturating_sub(3), max)
+        .into_iter()
+        .enumerate()
+        .map(|(i, part)| {
+            let lead = if i == 0 { " ⚠ " } else { "   " };
+            fit_line(
+                Line::from(Span::styled(format!("{lead}{part}"), style)),
+                cols,
+            )
+        })
+        .collect()
+}
+
 fn warnings(app: &App, snap: &Snapshot, theme: &Theme, cols: usize) -> Vec<Warning> {
     let err = Style::new().fg(theme.err).add_modifier(Modifier::BOLD);
     let warn = Style::new().fg(theme.warn);
     let line = |text: String, style: Style| Warning {
         line: Line::from(Span::styled(format!(" ⚠ {text}"), style)),
         fill: Style::new(),
         action: None,
+        key: Some(text.clone()),
         text: Some((text, style)),
         error: false,
     };
@@ -404,12 +452,14 @@ fn warnings(app: &App, snap: &Snapshot, theme: &Theme, cols: usize) -> Vec<Warni
             action: Some(Action::Open(Target::Leaks)),
             text: None,
             error: false,
+            key: None,
         });
     }
     // Next, so that it is never what a shared row cuts off.
     if let Some(e) = &app.error {
         out.push(Warning {
             error: true,
+            key: None,
             ..line(e.clone(), err)
         });
     }
@@ -425,7 +475,11 @@ fn warnings(app: &App, snap: &Snapshot, theme: &Theme, cols: usize) -> Vec<Warni
         out.push(line(format!("{conflicts} conflict{s}"), err));
     }
     if let Some(age) = app.lock_age().filter(|a| *a >= STALE_LOCK) {
-        out.push(line(format!("index.lock held {}", age_for(app, age)), warn));
+        // Keyed without the age, which changes each second.
+        out.push(Warning {
+            key: Some("index.lock".into()),
+            ..line(format!("index.lock held {}", age_for(app, age)), warn)
+        });
     }
     if let Some(e) = &app.fetch.last_error {
         out.push(line(format!("fetch failed: {}", e.label()), warn));
@@ -440,23 +494,26 @@ fn warnings(app: &App, snap: &Snapshot, theme: &Theme, cols: usize) -> Vec<Warni
 }
 
 fn hint_bar(f: &mut Frame, app: &mut App, theme: &Theme, r: Rect) {
-    let items: &[(&str, &str, Action)] = if app.stack.is_empty() {
-        &[
+    let mut items: Vec<(&str, &str, Action)> = if app.stack.is_empty() {
+        vec![
             ("?", "help", Action::Help),
             ("f", "fetch", Action::Fetch),
             ("q", "quit", Action::Quit),
         ]
     } else {
-        &[
+        vec![
             ("esc", "back", Action::Back),
             ("w", "wrap", Action::ToggleWrap),
             ("q", "quit", Action::Quit),
         ]
     };
+    if !app.clearable.is_empty() {
+        items.insert(2, ("c", "clear", Action::Clear(app.clearable.clone())));
+    }
     let key_style = Style::new().fg(theme.accent).add_modifier(Modifier::BOLD);
     let mut spans = Vec::new();
     let mut x = 0usize;
-    for (key, label, action) in items {
+    for (key, label, action) in &items {
         let item_w = 1 + width(key) + 1 + width(label) + 1;
         if x + item_w > r.width as usize {
             break;