remem-ai 0.4.3

Persistent memory for Claude Code — single binary, zero subprocesses
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

mod cli;
mod codex_cli;
mod codex_usage;
mod config;
mod http;
mod pricing;
#[cfg(test)]
mod tests;
mod types;
mod usage;

use cli::call_cli;
use codex_cli::call_codex_cli;
use http::call_http;
use pricing::estimate_tokens;
use usage::record_usage;

pub(crate) use types::TokenUsage;
pub use types::UsageContext;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum AiExecutor {
    Http,
    ClaudeCli,
    CodexCli,
}

/// AI call with timeout. HTTP first (fast, ~2-5s), CLI fallback (slow, ~30-60s).
pub async fn call_ai(
    system: &str,
    user_message: &str,
    ctx: UsageContext<'_>,
) -> anyhow::Result<String> {
    let result = match executor_for_operation(ctx.operation) {
        Some(AiExecutor::Http) => call_http(system, user_message).await,
        Some(AiExecutor::ClaudeCli) => call_cli(system, user_message).await,
        Some(AiExecutor::CodexCli) => call_codex_cli(system, user_message).await,
        None => call_auto(system, user_message).await,
    }?;

    let input_tokens = estimate_tokens(system) + estimate_tokens(user_message);
    let output_tokens = estimate_tokens(&result.text);
    record_usage(ctx, &result, input_tokens, output_tokens);
    Ok(result.text)
}

async fn call_auto(system: &str, user_message: &str) -> anyhow::Result<types::AiCallResult> {
    if std::env::var("ANTHROPIC_API_KEY").is_ok() || std::env::var("ANTHROPIC_AUTH_TOKEN").is_ok() {
        match call_http(system, user_message).await {
            Ok(result) => Ok(result),
            Err(http_err) => {
                crate::log::warn(
                    "ai",
                    &format!("HTTP failed, falling back to CLI: {}", http_err),
                );
                call_cli(system, user_message).await
            }
        }
    } else {
        call_cli(system, user_message).await
    }
}

fn executor_for_operation(operation: &str) -> Option<AiExecutor> {
    if matches!(operation, "flush" | "flush-task") {
        return flush_executor();
    }

    for key in executor_env_keys(operation) {
        if let Some(executor) = executor_from_env(key) {
            return Some(executor);
        }
    }
    None
}

fn executor_env_keys(operation: &str) -> &'static [&'static str] {
    match operation {
        "summarize"
        | "session_rollup"
        | "observation_extract"
        | "memory_candidate"
        | "rule_candidate"
        | "index_update" => &["REMEM_SUMMARY_EXECUTOR", "REMEM_EXECUTOR"],
        "flush" | "flush-task" => &["REMEM_FLUSH_EXECUTOR"],
        "compress" => &["REMEM_COMPRESS_EXECUTOR"],
        "dream" => &["REMEM_DREAM_EXECUTOR"],
        _ => &["REMEM_EXECUTOR"],
    }
}

fn flush_executor() -> Option<AiExecutor> {
    executor_from_env("REMEM_FLUSH_EXECUTOR").or_else(|| {
        executor_from_env("REMEM_SUMMARY_EXECUTOR")
            .filter(|executor| *executor == AiExecutor::CodexCli)
    })
}

fn executor_from_env(key: &str) -> Option<AiExecutor> {
    match std::env::var(key).ok()?.as_str() {
        "http" | "anthropic-http" | "anthropic" => Some(AiExecutor::Http),
        "cli" | "claude-cli" | "claude" => Some(AiExecutor::ClaudeCli),
        "codex-cli" | "codex" => Some(AiExecutor::CodexCli),
        _ => None,
    }
}

fn stable_working_dir() -> std::path::PathBuf {
    let data_dir = crate::db::data_dir();
    match std::fs::create_dir_all(&data_dir) {
        Ok(()) => data_dir,
        Err(err) => {
            crate::log::warn(
                "ai",
                &format!(
                    "failed to create AI working dir {}: {}; falling back to temp dir",
                    data_dir.display(),
                    err
                ),
            );
            std::env::temp_dir()
        }
    }
}