second-brain-cli 0.13.1

Memory layer for AI coding agents: ingest, recall, and sync across machines
use anyhow::{Result, anyhow};
use second_brain_core::config::Config;

use crate::consolidate;

const DEFAULT_MODEL: &str = "gemma-4-E4B-it-Q4_K_M";
const NO_ENDPOINT: &str = "no LLM endpoint configured; pass --llm-url or add an [llm] section to ~/.second-brain/config.toml";

#[derive(Debug, PartialEq)]
struct Endpoint {
    url: String,
    model: String,
}

fn flag(args: &[String], name: &str) -> Option<String> {
    args.windows(2).find(|w| w[0] == name).map(|w| w[1].clone())
}

fn resolve_endpoint(
    llm_url: Option<String>,
    model: Option<String>,
    load_config: impl FnOnce() -> Result<Config>,
) -> Result<Option<Endpoint>> {
    if let Some(url) = llm_url {
        return Ok(Some(Endpoint {
            url,
            model: model.unwrap_or_else(|| DEFAULT_MODEL.to_string()),
        }));
    }
    let config = load_config().map_err(|e| {
        let detail = format!("{e:#}");
        anyhow!(
            "config.toml unusable: {}",
            detail.split_whitespace().collect::<Vec<_>>().join(" ")
        )
    })?;
    Ok(config.llm.map(|llm| Endpoint {
        url: llm.endpoint,
        model: model.unwrap_or(llm.model),
    }))
}

fn endpoint_from_args(args: &[String]) -> Result<Option<Endpoint>> {
    resolve_endpoint(
        flag(args, "--llm-url"),
        flag(args, "--model"),
        Config::load_default,
    )
}

pub(crate) fn run_consolidate(args: &[String]) -> Result<()> {
    let dry_run = args.iter().any(|a| a == "--dry-run");
    let limit = flag(args, "--limit")
        .and_then(|v| v.parse().ok())
        .unwrap_or(50);
    let concurrency: usize = flag(args, "--concurrency")
        .and_then(|v| v.parse().ok())
        .unwrap_or(3);
    let guard = flag(args, "--guard")
        .map(|v| consolidate::Guard::parse(&v))
        .transpose()?
        .unwrap_or(consolidate::Guard::Retry);
    let endpoint = endpoint_from_args(args)?.ok_or_else(|| anyhow!(NO_ENDPOINT))?;
    consolidate::cmd_consolidate(
        dry_run,
        limit,
        &endpoint.model,
        &endpoint.url,
        concurrency,
        guard,
    )
}

pub(crate) fn run_daily_pipeline(args: &[String]) -> Result<()> {
    let consolidate_limit: usize = flag(args, "--consolidate-limit")
        .and_then(|v| v.parse().ok())
        .unwrap_or(200);
    let enhance = args.iter().any(|a| a == "--enhance");
    let endpoint = endpoint_from_args(args)?;

    cmd_daily_pipeline(endpoint.as_ref(), consolidate_limit, enhance)
}

fn cmd_daily_pipeline(
    endpoint: Option<&Endpoint>,
    consolidate_limit: usize,
    _enhance: bool,
) -> Result<()> {
    println!("=== daily pipeline ===\n");

    match endpoint {
        None => println!("[1/1] skipping consolidation: {NO_ENDPOINT}"),
        Some(endpoint) => {
            println!(
                "[1/1] consolidating up to {} memories...",
                consolidate_limit
            );
            match consolidate::cmd_consolidate(
                false,
                consolidate_limit,
                &endpoint.model,
                &endpoint.url,
                3,
                consolidate::Guard::Retry,
            ) {
                Ok(()) => println!("      consolidation complete"),
                Err(e) => println!("      consolidation failed (non-fatal): {}", e),
            }
        }
    }

    println!("\n=== pipeline complete ===");
    Ok(())
}

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

    fn configured() -> Result<Config> {
        Config::parse("[llm]\nendpoint = \"http://llm.test:1\"\nmodel = \"config-model\"\n")
    }

    fn endpoint(url: &str, model: &str) -> Option<Endpoint> {
        Some(Endpoint {
            url: url.to_string(),
            model: model.to_string(),
        })
    }

    #[test]
    fn llm_url_flag_wins_without_reading_the_config() {
        let resolved = resolve_endpoint(Some("http://flag.test:2".into()), None, || {
            panic!("config must not be read when --llm-url is given")
        })
        .unwrap();
        assert_eq!(resolved, endpoint("http://flag.test:2", DEFAULT_MODEL));
    }

    #[test]
    fn llm_url_flag_keeps_the_model_flag() {
        let resolved = resolve_endpoint(
            Some("http://flag.test:2".into()),
            Some("flag-model".into()),
            configured,
        )
        .unwrap();
        assert_eq!(resolved, endpoint("http://flag.test:2", "flag-model"));
    }

    #[test]
    fn config_supplies_endpoint_and_model_when_flags_are_absent() {
        let resolved = resolve_endpoint(None, None, configured).unwrap();
        assert_eq!(resolved, endpoint("http://llm.test:1", "config-model"));
    }

    #[test]
    fn model_flag_overrides_the_config_model() {
        let resolved = resolve_endpoint(None, Some("flag-model".into()), configured).unwrap();
        assert_eq!(resolved, endpoint("http://llm.test:1", "flag-model"));
    }

    #[test]
    fn no_flag_and_no_llm_section_resolves_to_none() {
        let resolved =
            resolve_endpoint(None, Some("flag-model".into()), || Ok(Config::default())).unwrap();
        assert_eq!(resolved, None);
    }

    #[test]
    fn a_config_that_fails_to_load_is_one_line() {
        let err = resolve_endpoint(None, None, || Config::parse("[llm\nendpoint = 1\n"))
            .unwrap_err()
            .to_string();
        assert!(err.starts_with("config.toml unusable: "), "{err}");
        assert!(!err.contains('\n'), "{err}");
    }
}