use std::time::Duration;
use anyhow::{Context, Result};
use reqwest::StatusCode;
use second_brain_core::digest::{DEFAULT_WINDOW, Digest};
use crate::api;
const USAGE: &str = "usage: sb digest [--since <span>] [--project <slug>]";
#[derive(Debug, PartialEq, Eq)]
pub(crate) struct DigestArgs {
since: String,
project: Option<String>,
}
impl DigestArgs {
pub(crate) fn parse(args: &[String]) -> Result<DigestArgs> {
let mut parsed = DigestArgs {
since: DEFAULT_WINDOW.to_string(),
project: None,
};
let mut words = args.iter();
while let Some(flag) = words.next() {
let slot = match flag.as_str() {
"--since" => &mut parsed.since,
"--project" => parsed.project.insert(String::new()),
other => anyhow::bail!("unexpected argument {other:?}\n{USAGE}"),
};
*slot = words
.next()
.with_context(|| format!("{flag} needs a value\n{USAGE}"))?
.clone();
}
Ok(parsed)
}
}
pub(crate) fn cmd_digest(args: &[String]) -> Result<()> {
let args = DigestArgs::parse(args)?;
let (status, body) = fetch(&args)?;
println!("{}", digest_output(status, &body)?);
Ok(())
}
fn fetch(args: &DigestArgs) -> Result<(StatusCode, String)> {
let client = api::client(Duration::from_secs(30))?;
let mut query = vec![("since", args.since.as_str())];
if let Some(project) = &args.project {
query.push(("project", project.as_str()));
}
let resp = client
.get(format!("{}/v1/digest", api::base_url()))
.query(&query)
.send()
.context("daemon not reachable; is it running?")?;
if resp.status() == StatusCode::UNAUTHORIZED {
api::daemon_ok(resp)?;
anyhow::bail!("the daemon rejected the API token");
}
let status = resp.status();
let body = resp.text().context("reading the daemon's digest answer")?;
Ok((status, body))
}
fn digest_output(status: StatusCode, body: &str) -> Result<String> {
if !status.is_success() {
let message = api::error_message(body);
if message.is_empty() {
anyhow::bail!("digest request failed ({status})");
}
anyhow::bail!("digest request failed ({status}): {message}");
}
let digest: Digest =
serde_json::from_str(body).context("the daemon's digest answer is not a digest")?;
Ok(digest.render())
}
#[cfg(test)]
mod tests {
use chrono::{TimeZone, Utc};
use second_brain_core::digest::Window;
use super::*;
fn words(args: &[&str]) -> Vec<String> {
args.iter().map(|a| a.to_string()).collect()
}
#[test]
fn digest_args_default_to_the_default_window_and_every_project() {
assert_eq!(
DigestArgs::parse(&[]).unwrap(),
DigestArgs {
since: DEFAULT_WINDOW.to_string(),
project: None,
}
);
}
#[test]
fn digest_args_take_since_and_project() {
assert_eq!(
DigestArgs::parse(&words(&["--since", "7d", "--project", "x"])).unwrap(),
DigestArgs {
since: "7d".to_string(),
project: Some("x".to_string()),
}
);
}
#[test]
fn digest_args_refuse_a_flag_without_a_value_or_an_unknown_word() {
let err = DigestArgs::parse(&words(&["--project"])).unwrap_err();
assert!(
err.to_string().contains("--project needs a value"),
"{err:#}"
);
let err = DigestArgs::parse(&words(&["--projet", "x"])).unwrap_err();
assert!(err.to_string().contains("\"--projet\""), "{err:#}");
}
#[test]
fn a_digest_answer_prints_its_render() {
let window = Window {
since: Utc.with_ymd_and_hms(2026, 11, 1, 0, 0, 0).unwrap(),
until: Utc.with_ymd_and_hms(2026, 11, 2, 0, 0, 0).unwrap(),
};
let digest = Digest::assemble(window, None, &[], &[Some("x".to_string()), None]);
let body = serde_json::to_value(&digest).unwrap().to_string();
assert_eq!(
digest_output(StatusCode::OK, &body).unwrap(),
digest.render()
);
}
#[test]
fn a_refused_digest_surfaces_the_daemons_message() {
let body = r#"{"error":"unknown span \"3w\"; use 90m, 24h or 7d"}"#;
let err = digest_output(StatusCode::BAD_REQUEST, body).unwrap_err();
let text = err.to_string();
assert!(text.contains("400"), "{text}");
assert!(
text.contains("unknown span \"3w\"; use 90m, 24h or 7d"),
"{text}"
);
}
#[test]
fn a_plain_text_refusal_surfaces_its_body() {
let err =
digest_output(StatusCode::INTERNAL_SERVER_ERROR, "database is locked\n").unwrap_err();
assert_eq!(
err.to_string(),
"digest request failed (500 Internal Server Error): database is locked"
);
}
}