second-brain-cli 0.13.3

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

use super::ingest::queued_reason;
use crate::api;

pub(crate) fn cmd_recall(query: &str) -> Result<()> {
    if query.is_empty() {
        anyhow::bail!("usage: sb recall <query>");
    }

    let api = api::base_url();
    let client = api::client(std::time::Duration::from_secs(30))?;

    let resp = api::daemon_ok(
        client
            .post(format!("{api}/v1/recall"))
            .json(&serde_json::json!({ "query": query, "limit": 10 }))
            .send()
            .context("daemon not reachable — is it running?")?,
    )
    .context("recall request failed")?;

    let body: serde_json::Value = resp.json()?;
    let memories = body["memories"].as_array();

    if memories.is_none() || memories.unwrap().is_empty() {
        println!("no memories found for: \"{query}\"");
        return Ok(());
    }

    for (i, m) in memories.unwrap().iter().enumerate() {
        let score = m["score"]
            .as_f64()
            .map(|s| format!("score: {:.4}, ", s))
            .unwrap_or_default();
        let mtype = m["memory_type"].as_str().unwrap_or("unknown");
        let source = m["source"].as_str().unwrap_or("unknown");
        let machine = m["machine_name"].as_str().unwrap_or("");
        let project = m["project_path"].as_str().unwrap_or("");
        let content = m["content"].as_str().unwrap_or("");
        let preview: String = content.chars().take(200).collect();

        let mut meta = format!("{score}type: {mtype}, source: {source}");
        if !project.is_empty() {
            meta.push_str(&format!(", project: {project}"));
        }
        if !machine.is_empty() {
            meta.push_str(&format!(", machine: {machine}"));
        }
        println!("{}. ({meta})", i + 1);
        println!("   {preview}\n");
    }

    Ok(())
}

pub(crate) fn cmd_remember(content: &str) -> Result<()> {
    if content.is_empty() {
        anyhow::bail!("usage: sb remember <text>");
    }

    let api = api::base_url();
    let client = api::client(std::time::Duration::from_secs(30))?;

    let resp = api::daemon_ok(
        client
            .post(format!("{api}/v1/remember"))
            .json(&serde_json::json!({
                "content": content,
                "source": "cli",
            }))
            .send()
            .context("daemon not reachable — is it running?")?,
    )
    .context("remember request failed")?;

    let body: serde_json::Value = resp.json()?;
    println!("{}", remember_line(&body, content));
    Ok(())
}

fn remember_line(body: &serde_json::Value, content: &str) -> String {
    let id = body["id"].as_str().unwrap_or("unknown");
    if queued_reason(body).is_some() {
        return format!(
            "queued [{id}]: {content} (store maintenance is running; saved when it finishes)"
        );
    }
    format!("remembered [{id}]: {content}")
}

#[cfg(test)]
mod queued_tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn remember_prints_queued_or_remembered() {
        let queued = json!({"queued": true, "id": "abc"});
        assert_eq!(
            remember_line(&queued, "note"),
            "queued [abc]: note (store maintenance is running; saved when it finishes)"
        );
        assert_eq!(
            remember_line(&json!({"id": "abc"}), "note"),
            "remembered [abc]: note"
        );
    }
}