second-brain-cli 0.12.0

Memory layer for AI coding agents: ingest, recall, and sync across machines
use anyhow::Result;
use commands::consolidate_args::{run_consolidate, run_daily_pipeline};
use commands::doctor::{cmd_doctor, cmd_status, cmd_whoami};
use commands::ingest::{cmd_ingest, cmd_reingest};
use commands::maintenance::{cmd_backfill_session_dates, cmd_prune_relations, cmd_vacuum};
use commands::recall::{cmd_recall, cmd_remember};
use commands::setup::cmd_setup;
use commands::sync::{
    cmd_sync, cmd_sync_backfill, cmd_sync_compact, cmd_sync_export, cmd_sync_import, cmd_sync_key,
    cmd_sync_status, cmd_sync_trust,
};

mod api;
mod bins;
mod claude_hooks;
mod claude_mcp;
mod commands;
mod consolidate;
mod daemon;
mod launchd;
mod ordered_json;
mod redact;
mod tokens;

fn main() {
    tracing_subscriber::fmt()
        .with_writer(std::io::stderr)
        .with_env_filter(
            tracing_subscriber::EnvFilter::from_default_env()
                .add_directive("second_brain=info".parse().unwrap()),
        )
        .init();

    let args: Vec<String> = std::env::args().collect();
    let cmd = args.get(1).map(|s| s.as_str()).unwrap_or("help");

    if let Err(e) = run(cmd, &args) {
        eprintln!("error: {e:#}");
        std::process::exit(1);
    }
}

fn run(cmd: &str, args: &[String]) -> Result<()> {
    match cmd {
        "ingest" => {
            let source = args.get(2).map(|s| s.as_str()).unwrap_or("claude-code");
            cmd_ingest(source)
        }
        "recall" => {
            let query = args.get(2).map(|s| s.as_str()).unwrap_or("");
            cmd_recall(query)
        }
        "remember" => {
            let content = args[2..].join(" ");
            cmd_remember(&content)
        }
        "status" => cmd_status(),
        "whoami" => cmd_whoami(),
        "setup" => cmd_setup(),
        "watch" => {
            eprintln!("watch is deprecated — the daemon handles file watching automatically");
            Ok(())
        }
        "sync" => {
            let peer = args
                .get(2)
                .ok_or_else(|| anyhow::anyhow!("usage: sb sync <peer-host>"))?;
            cmd_sync(peer, args)
        }
        "sync-export" => {
            let after_seq = parse_after_seq(args);
            cmd_sync_export(after_seq)
        }
        "sync-import" => cmd_sync_import(),
        "sync-status" => cmd_sync_status(),
        "sync-key" => cmd_sync_key(),
        "sync-backfill" => cmd_sync_backfill(),
        "backfill-session-dates" => {
            let dry_run = args.iter().any(|a| a == "--dry-run");
            let reemit = args.iter().any(|a| a == "--reemit");
            cmd_backfill_session_dates(dry_run, reemit)
        }
        "sync-compact" => {
            let dry_run = args.iter().any(|a| a == "--dry-run");
            let ops: Vec<String> = args
                .windows(2)
                .find(|w| w[0] == "--ops")
                .map(|w| w[1].split(',').map(|s| s.trim().to_string()).collect())
                .unwrap_or_else(|| vec!["delete".to_string()]);
            cmd_sync_compact(&ops, dry_run)
        }
        "prune-relations" => cmd_prune_relations(),
        "doctor" => {
            let repair = args.iter().any(|a| a == "--repair");
            let dry_run = args.iter().any(|a| a == "--dry-run");
            cmd_doctor(repair, dry_run)
        }
        "vacuum" => cmd_vacuum(),
        "redact" => redact::cmd_redact(args.iter().any(|a| a == "--dry-run")),
        "sync-trust" => {
            let host = args
                .get(2)
                .ok_or_else(|| anyhow::anyhow!("usage: sb sync-trust <host>"))?;
            cmd_sync_trust(host)
        }
        "start" => daemon::control(daemon::Action::Start),
        "stop" => daemon::control(daemon::Action::Stop),
        "restart" => daemon::control(daemon::Action::Restart),
        "reingest" => {
            if args.iter().any(|a| a == "--clean") {
                anyhow::bail!(
                    "--clean was removed: raw ids come from the transcript, so deleting raws \
                     before a re-ingest would delete them on every peer for good"
                );
            }
            cmd_reingest()
        }
        "consolidate" => run_consolidate(args),
        "daily-pipeline" => run_daily_pipeline(args),
        "hook" => {
            commands::hook::cmd_hook(args.get(2).map(String::as_str));
            Ok(())
        }
        "digest" => commands::digest::cmd_digest(&args[2..]),
        _ => {
            println!("second-brain CLI");
            println!();
            println!("Usage: sb <command> [args]");
            println!();
            println!("Commands:");
            println!(
                "  ingest [source]     Ingest conversation history (claude-code, cursor, all)"
            );
            println!("  recall <query>      Search the brain");
            println!("  remember <text>     Store new knowledge");
            println!(
                "  setup               One-command install: systemd service, MCP config, first ingest"
            );
            println!("  start               Start the daemon");
            println!("  stop                Stop the daemon");
            println!("  restart             Restart the daemon");
            println!("  status              Show brain stats");
            println!("  sync <peer>         Bidirectional sync with a peer");
            println!("  sync-export         Export changes as JSONL to stdout");
            println!("  sync-import         Import JSONL changes from stdin");
            println!("  sync-status         Show sync state for all peers");
            println!("  sync-key            Print the base64 sync key to copy to paired devices");
            println!("  sync-backfill       Backfill sync log for existing data");
            println!(
                "  backfill-session-dates  Date memories from this machine's transcripts (--dry-run, --reemit)"
            );
            println!(
                "  sync-compact        Collapse duplicate sync_log rows (--dry-run, --ops delete,create)"
            );
            println!("  prune-relations     Delete relations whose endpoints no longer resolve");
            println!(
                "  doctor              Check the install and store, with a fix for each failure (--repair, --dry-run)"
            );
            println!("  vacuum              Reclaim free pages in brain.db after a repair");
            println!(
                "  redact --dry-run    Count stored secrets the daemon's redaction pass would remove"
            );
            println!(
                "  sync-trust <host>   Fetch and pin a host's SSH key after fingerprint review"
            );
            println!("  reingest            Re-ingest all conversations");
            println!("  consolidate         Distill raw memories via local LLM");
            println!("  daily-pipeline      End-of-day: consolidate → daily → export → enhance");
            println!("  hook <name>         Run a Claude Code hook on the event JSON from stdin");
            println!(
                "  digest              What agents decided, abandoned and left blocked on you \
                 (--since 24h, --project X)"
            );
            Ok(())
        }
    }
}

fn parse_after_seq(args: &[String]) -> u64 {
    for (i, arg) in args.iter().enumerate() {
        if arg == "--after-seq"
            && let Some(val) = args.get(i + 1)
        {
            return val.parse().unwrap_or(0);
        }
    }
    0
}