niuse 0.1.8

A personal engineering companion built on niucode
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Open-loop commands: list, add, and close promises.

use anyhow::{bail, Context, Result};
use niuse_core::model::one_line;
use niuse_core::policy::secret_reason;
use niuse_core::{Date, LoopItem, Store};
use serde::Serialize;

use super::normalize_id;

#[derive(Debug, Serialize)]
struct LoopJson {
    id: String,
    text: String,
    due: Option<String>,
    done: bool,
    overdue: bool,
}

pub fn loops_list(store: &Store, all: bool, json: bool, overdue_only: bool) -> Result<()> {
    let today = Date::today();
    let loops = store.loops()?;
    if json {
        let items: Vec<LoopJson> = loops
            .iter()
            .filter(|item| all || !item.done)
            .filter(|item| !overdue_only || item.is_overdue(today))
            .map(|item| LoopJson {
                id: format!("l-{}", item.id),
                text: item.text.clone(),
                due: item.due.map(|due| due.to_string()),
                done: item.done,
                overdue: item.is_overdue(today),
            })
            .collect();
        println!("{}", serde_json::to_string_pretty(&items)?);
        return Ok(());
    }
    let open = loops.iter().filter(|item| !item.done).count();
    if overdue_only {
        let overdue = loops.iter().filter(|item| item.is_overdue(today)).count();
        println!("{overdue} 条逾期");
    } else {
        println!("{} 条承诺 · {} 条未完成", loops.len(), open);
    }
    for item in &loops {
        if item.done && !all {
            continue;
        }
        if overdue_only && !item.is_overdue(today) {
            continue;
        }
        let mark = if item.done { "x" } else { " " };
        let due = match item.due {
            Some(due) if item.is_overdue(today) => format!("（截止 {due}，已逾期）"),
            Some(due) => format!("（截止 {due}）"),
            None => String::new(),
        };
        println!("[{mark}] l-{} {}{due}", item.id, item.text);
    }
    Ok(())
}

pub fn loops_add(store: &Store, text: &str, due: Option<&str>) -> Result<()> {
    let text = one_line(text.trim().to_string());
    if text.is_empty() {
        bail!("loop text is empty");
    }
    if let Some(reason) = secret_reason(&text) {
        bail!("refusing to store: looks like a {reason}");
    }
    let due = match due {
        Some(value) => {
            Some(Date::parse(value).with_context(|| format!("invalid due date {value:?}"))?)
        }
        None => None,
    };
    let item = store.add_loop(LoopItem::new(text, due))?;
    if let Err(error) = store.append_metric("loop", &item.id) {
        eprintln!("warning: cannot record metric: {error:#}");
    }
    match item.due {
        Some(due) => println!("l-{} {} (due {due})", item.id, item.text),
        None => println!("l-{} {}", item.id, item.text),
    }
    Ok(())
}

pub fn loops_done(store: &Store, id: &str) -> Result<()> {
    let id = normalize_id(id);
    if store.close_loop(&id)? {
        println!("closed l-{id}");
    } else {
        bail!("no loop l-{id}");
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn manual_loop_persists_with_due_date() {
        let directory = tempfile::tempdir().unwrap();
        let store = Store::at(directory.path().join(".niuse"));
        store.init().unwrap();
        loops_add(&store, "check the pin", Some("2026-10-30")).unwrap();
        let loops = store.loops().unwrap();
        assert_eq!(loops.len(), 1);
        assert_eq!(loops[0].text, "check the pin");
        assert_eq!(loops[0].due, Date::parse("2026-10-30"));
    }

    #[test]
    fn manual_loop_rejects_a_bad_due_date() {
        let directory = tempfile::tempdir().unwrap();
        let store = Store::at(directory.path().join(".niuse"));
        store.init().unwrap();
        assert!(loops_add(&store, "check", Some("2026-13-01")).is_err());
        assert!(store.loops().unwrap().is_empty());
    }
}