agentmem 0.1.1

Local-first memory engine for AI coding agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Future daemon / service binary.
//!
//! `agentmemd` is intended to become the long-running local process that can:
//!
//! - coordinate multiple agent clients
//! - hold a warm in-memory index
//! - serialize writes safely
//! - expose local IPC / sockets later
//! - provide observability and health checks
//!
//! For now it is intentionally conservative and only boots, validates config,
//! opens the store, and waits until interrupted.

use std::process;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

use agentmem::cli::output::{
    print_error, print_field, print_heading, print_info, print_success,
};
use agentmem::config::{resolve_local_config_path, Config};
use agentmem::store::Store;

/// Poll interval while idle.
///
/// This is intentionally simple for v1 bootstrap mode.
const IDLE_INTERVAL: Duration = Duration::from_secs(5);

fn main() {
    let code = match run() {
        Ok(()) => 0,
        Err(error) => {
            print_error(&error);
            1
        }
    };

    process::exit(code);
}

fn run() -> agentmem::Result<()> {
    print_heading("agentmemd");
    print_info("starting local daemon");

    let config_path = resolve_local_config_path()?;
    let config = Config::load(&config_path)?;
    let store = Store::open_locked(config)?;

    let info = store.info();

    print_success("store opened");
    print_field("Project", info.project_name.as_str());
    print_field("Path", &info.path.to_string());
    print_field("Entries", &store.len().to_string());

    let running = Arc::new(AtomicBool::new(true));

    // Placeholder loop until real signal handling / IPC arrives.
    while running.load(Ordering::Relaxed) {
        thread::sleep(IDLE_INTERVAL);
    }

    Ok(())
}