second-brain-cli 0.13.1

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

use crate::api;

pub(crate) fn cmd_prune_relations() -> Result<()> {
    let api_base = api::base_url();
    let client = api::client(std::time::Duration::from_secs(1800))?;

    #[derive(serde::Deserialize)]
    struct PruneResp {
        pruned: u64,
    }

    let resp: PruneResp = api::daemon_ok(
        client
            .post(format!("{api_base}/v1/sync/prune-relations"))
            .send()
            .context("calling prune-relations on daemon")?,
    )?
    .json()?;

    eprintln!("pruned {} dangling relations", resp.pruned);
    Ok(())
}

pub(crate) fn cmd_vacuum() -> Result<()> {
    let api = api::base_url();
    let client = api::client(std::time::Duration::from_secs(3600))?;
    let resp: serde_json::Value = api::daemon_ok(
        client
            .post(format!("{api}/v1/maintenance/vacuum"))
            .send()
            .context("calling vacuum on daemon")?,
    )?
    .json()?;
    let before = resp["bytes_before"].as_u64().unwrap_or(0);
    let after = resp["bytes_after"].as_u64().unwrap_or(0);
    println!(
        "vacuumed brain.db: {:.1} MB -> {:.1} MB",
        before as f64 / 1e6,
        after as f64 / 1e6
    );
    Ok(())
}

pub(crate) fn cmd_backfill_session_dates(dry_run: bool, reemit: bool) -> Result<()> {
    let api_base = api::base_url();
    // Every transcript on the machine is read once, which takes minutes.
    let client = api::client(std::time::Duration::from_secs(1800))?;

    let report: serde_json::Value = api::daemon_ok(
        client
            .post(format!("{api_base}/v1/backfill-session-at"))
            .json(&serde_json::json!({"dry_run": dry_run, "reemit": reemit}))
            .send()
            .context("calling backfill-session-at on daemon")?,
    )?
    .json()?;

    let tiers = [
        "transcript_line",
        "conversation_start",
        "transcript_start",
        "file_mtime",
        "remembered_at",
        "unknown",
    ];
    println!(
        "{}undated rows: {}",
        if dry_run { "dry run, " } else { "" },
        report["candidates"]
    );
    println!("{:<20} {:>8} {:>8}", "evidence", "all", "live");
    for tier in tiers {
        println!(
            "{:<20} {:>8} {:>8}",
            tier,
            report["all"][tier].as_u64().unwrap_or(0),
            report["live"][tier].as_u64().unwrap_or(0)
        );
    }
    println!(
        "fallback conversations skipped: {}",
        report["fallback_conversations_skipped"]
    );
    println!(
        "written: {}, reemitted: {}",
        report["written"], report["reemitted"]
    );
    for s in report["sample"].as_array().into_iter().flatten() {
        let content: String = s["content"]
            .as_str()
            .unwrap_or("")
            .chars()
            .take(80)
            .map(|c| if c == '\n' { ' ' } else { c })
            .collect();
        println!(
            "  {} {:<18} created {} {}: {}",
            s["session_at"]
                .as_str()
                .unwrap_or("")
                .get(..10)
                .unwrap_or(""),
            s["tier"].as_str().unwrap_or(""),
            s["created_at"]
                .as_str()
                .unwrap_or("")
                .get(..10)
                .unwrap_or(""),
            s["source"].as_str().unwrap_or(""),
            content
        );
    }
    Ok(())
}