second-brain-cli 0.13.2

Memory layer for AI coding agents: ingest, recall, and sync across machines
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 {
    /// `args` are the words after `digest`.
    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"
        );
    }
}