// Configuration for poc-memory // // Loaded from ~/.config/poc-memory/config.jsonl (or POC_MEMORY_CONFIG env). // Falls back to sensible defaults if no config file exists. // // Format: JSONL — one JSON object per line. // First line with "config" key: global settings. // Lines with "group" key: context loading groups (order preserved). // // Example: // {"config": {"user_name": "Alice", "data_dir": "~/.claude/memory"}} // {"group": "identity", "keys": ["identity"]} // {"group": "orientation", "keys": ["where-am-i.md"], "source": "file"} use std::path::PathBuf; use std::sync::OnceLock; static CONFIG: OnceLock = OnceLock::new(); #[derive(Debug, Clone, PartialEq)] pub enum ContextSource { Store, File, Journal, } #[derive(Debug, Clone)] pub struct ContextGroup { pub label: String, pub keys: Vec, pub source: ContextSource, } #[derive(Debug, Clone)] pub struct Config { /// Display name for the human user in transcripts/prompts. pub user_name: String, /// Display name for the AI assistant. pub assistant_name: String, /// Base directory for memory data (store, logs, status). pub data_dir: PathBuf, /// Directory containing Claude session transcripts. pub projects_dir: PathBuf, /// Core node keys that should never be decayed/deleted. pub core_nodes: Vec, /// How many days of journal to include in load-context. pub journal_days: u32, /// Max journal entries to include in load-context. pub journal_max: usize, /// Ordered context groups for session-start loading. pub context_groups: Vec, /// Max concurrent LLM calls in the daemon. pub llm_concurrency: usize, /// Total agent runs per consolidation cycle. pub agent_budget: usize, /// Directory containing prompt templates for agents. pub prompts_dir: PathBuf, /// Separate Claude config dir for background agent work (daemon jobs). /// If set, passed as CLAUDE_CONFIG_DIR so the daemon authenticates /// with different OAuth credentials than the interactive session. pub agent_config_dir: Option, /// OpenAI-compatible API base URL for direct LLM calls (e.g. vllm). /// When set, agents use this instead of shelling out to claude CLI. pub api_base_url: Option, /// API key for the direct API endpoint. pub api_key: Option, /// Model name to use with the direct API endpoint. pub api_model: Option, } impl Default for Config { fn default() -> Self { let home = PathBuf::from(std::env::var("HOME").expect("HOME not set")); Self { user_name: "User".to_string(), assistant_name: "Assistant".to_string(), data_dir: home.join(".claude/memory"), projects_dir: home.join(".claude/projects"), core_nodes: vec!["identity".to_string(), "core-practices".to_string()], journal_days: 7, journal_max: 20, context_groups: vec![ ContextGroup { label: "identity".into(), keys: vec!["identity".into()], source: ContextSource::Store, }, ContextGroup { label: "core-practices".into(), keys: vec!["core-practices".into()], source: ContextSource::Store, }, ], llm_concurrency: 1, agent_budget: 1000, prompts_dir: home.join("poc/memory/prompts"), agent_config_dir: None, api_base_url: None, api_key: None, api_model: None, } } } impl Config { fn load_from_file() -> Self { let path = std::env::var("POC_MEMORY_CONFIG") .map(PathBuf::from) .unwrap_or_else(|_| { PathBuf::from(std::env::var("HOME").expect("HOME not set")) .join(".config/poc-memory/config.jsonl") }); let mut config = Config::default(); let Ok(content) = std::fs::read_to_string(&path) else { return config; }; let mut context_groups: Vec = Vec::new(); // Parse as a stream of JSON values (handles multi-line objects) let stream = serde_json::Deserializer::from_str(&content) .into_iter::(); for result in stream { let Ok(obj) = result else { continue }; // Global config line if let Some(cfg) = obj.get("config") { if let Some(s) = cfg.get("user_name").and_then(|v| v.as_str()) { config.user_name = s.to_string(); } if let Some(s) = cfg.get("assistant_name").and_then(|v| v.as_str()) { config.assistant_name = s.to_string(); } if let Some(s) = cfg.get("data_dir").and_then(|v| v.as_str()) { config.data_dir = expand_home(s); } if let Some(s) = cfg.get("projects_dir").and_then(|v| v.as_str()) { config.projects_dir = expand_home(s); } if let Some(arr) = cfg.get("core_nodes").and_then(|v| v.as_array()) { config.core_nodes = arr.iter() .filter_map(|v| v.as_str().map(|s| s.to_string())) .collect(); } if let Some(d) = cfg.get("journal_days").and_then(|v| v.as_u64()) { config.journal_days = d as u32; } if let Some(m) = cfg.get("journal_max").and_then(|v| v.as_u64()) { config.journal_max = m as usize; } if let Some(n) = cfg.get("llm_concurrency").and_then(|v| v.as_u64()) { config.llm_concurrency = n.max(1) as usize; } if let Some(n) = cfg.get("agent_budget").and_then(|v| v.as_u64()) { config.agent_budget = n as usize; } if let Some(s) = cfg.get("prompts_dir").and_then(|v| v.as_str()) { config.prompts_dir = expand_home(s); } if let Some(s) = cfg.get("agent_config_dir").and_then(|v| v.as_str()) { config.agent_config_dir = Some(expand_home(s)); } if let Some(s) = cfg.get("api_base_url").and_then(|v| v.as_str()) { config.api_base_url = Some(s.to_string()); } if let Some(s) = cfg.get("api_key").and_then(|v| v.as_str()) { config.api_key = Some(s.to_string()); } if let Some(s) = cfg.get("api_model").and_then(|v| v.as_str()) { config.api_model = Some(s.to_string()); } continue; } // Context group line if let Some(label) = obj.get("group").and_then(|v| v.as_str()) { let keys = obj.get("keys") .and_then(|v| v.as_array()) .map(|arr| arr.iter() .filter_map(|v| v.as_str().map(|s| s.to_string())) .collect()) .unwrap_or_default(); let source = match obj.get("source").and_then(|v| v.as_str()) { Some("file") => ContextSource::File, Some("journal") => ContextSource::Journal, _ => ContextSource::Store, }; context_groups.push(ContextGroup { label: label.to_string(), keys, source }); } } if !context_groups.is_empty() { config.context_groups = context_groups; } config } } fn expand_home(path: &str) -> PathBuf { if let Some(rest) = path.strip_prefix("~/") { PathBuf::from(std::env::var("HOME").expect("HOME not set")).join(rest) } else { PathBuf::from(path) } } /// Get the global config (loaded once on first access). pub fn get() -> &'static Config { CONFIG.get_or_init(Config::load_from_file) }