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}");
}
}