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_backup, cmd_prune_relations, cmd_vacuum,
};
use commands::recall::{cmd_recall, cmd_remember};
use commands::setup::cmd_setup;
use commands::sync::{
cmd_sync, cmd_sync_compact, cmd_sync_export, cmd_sync_import, cmd_sync_key, cmd_sync_snapshot,
cmd_sync_status, cmd_sync_trust,
};
mod api;
mod bins;
mod claude_code;
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);
let hello = args
.iter()
.position(|arg| arg == "--hello")
.and_then(|i| args.get(i + 1));
cmd_sync_export(after_seq, hello.map(String::as_str))
}
"sync-snapshot" => {
let hello = args
.iter()
.position(|arg| arg == "--hello")
.and_then(|i| args.get(i + 1));
cmd_sync_snapshot(
hello.map(String::as_str),
args.iter().any(|a| a == "--apply"),
)
}
"sync-import" => cmd_sync_import(),
"sync-serve" => commands::sync_serve::cmd_sync_serve(&args[2..]),
"sync-status" => cmd_sync_status(),
"sync-key" => cmd_sync_key(),
"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(),
"backup" => cmd_backup(&args[2..]),
"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..]),
"device" => commands::device::cmd_device(&args[2..]),
"recovery" => commands::recovery::cmd_recovery(&args[2..]),
"restore" => commands::restore::cmd_restore(&args[2..]),
"pair" => commands::pair::cmd_pair(&args[2..]),
"delete" => commands::delete::cmd_delete(&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-status Show sync state for all peers");
println!(
" sync-key Retired: the daemon keeps sync keys; pair devices instead"
);
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!(
" backup <dest> Write a copy of the data dir that `sb restore` accepts, while the daemon runs"
);
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)"
);
println!(
" device list|remove Show this sync identity's devices, or remove one (--keep <name>, --yes)"
);
println!(
" recovery [new|remove] Show this identity's recovery phrases, make one, or retire one (remove <fingerprint>)"
);
println!(
" restore <backup> Restore a data-dir copy with its recovery phrase (stdin), --code <code> or --own-keys"
);
println!(
" pair [<code>] Show a code to add a device, or join with one (--host <host>, --discard-local, --restore-keys, --stop-waiting)"
);
println!(
" delete Permanently delete a memory, session or project everywhere \
(--memory <id> | --session <id> | --project <path>, --yes; --status <id>)"
);
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
}