enact_memory/

config.rs

//! Memory configuration with unified config resolution
//!
//! Configuration is resolved in order:
//! 1. `ENACT_MEMORY_CONFIG_PATH` environment variable
//! 2. `./memory.yaml` in current working directory
//! 3. `~/.enact/memory.yaml`
//! 4. Hardcoded defaults

use serde::{Deserialize, Serialize};

/// Episodic memory configuration (subset for YAML)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EpisodicConfig {
    /// Directory for session snapshots (relative to workspace)
    #[serde(default = "default_snapshot_dir")]
    pub snapshot_dir: String,

    /// Maximum snapshots to retain before cleanup
    #[serde(default = "default_max_snapshots")]
    pub max_snapshots: usize,

    /// Maximum entries per daily log before rolling
    #[serde(default = "default_max_daily_entries")]
    pub max_daily_entries: usize,

    /// Whether to automatically consolidate to semantic memory
    #[serde(default = "default_auto_consolidate")]
    pub auto_consolidate: bool,

    /// Time of day to run consolidation (HH:MM format)
    #[serde(default = "default_consolidation_time")]
    pub consolidation_time: String,

    /// Number of days to retain episodic logs
    #[serde(default = "default_retention_days")]
    pub retention_days: u32,

    /// Whether to include timestamps in entries
    #[serde(default = "default_include_timestamps")]
    pub include_timestamps: bool,
}

impl Default for EpisodicConfig {
    fn default() -> Self {
        Self {
            snapshot_dir: default_snapshot_dir(),
            max_snapshots: default_max_snapshots(),
            max_daily_entries: default_max_daily_entries(),
            auto_consolidate: default_auto_consolidate(),
            consolidation_time: default_consolidation_time(),
            retention_days: default_retention_days(),
            include_timestamps: default_include_timestamps(),
        }
    }
}

fn default_snapshot_dir() -> String {
    "memory/sessions".to_string()
}

fn default_max_snapshots() -> usize {
    50
}

fn default_max_daily_entries() -> usize {
    100
}

fn default_auto_consolidate() -> bool {
    true
}

fn default_consolidation_time() -> String {
    "03:00".to_string()
}

fn default_retention_days() -> u32 {
    30
}

fn default_include_timestamps() -> bool {
    true
}

/// Main memory configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryConfig {
    /// Memory backend type: "sqlite", "markdown", or "none"
    #[serde(default = "default_backend")]
    pub backend: String,

    /// Path to SQLite database file (relative to workspace)
    #[serde(default = "default_db_path")]
    pub db_path: String,

    /// Directory for markdown memory files (relative to workspace)
    #[serde(default = "default_markdown_dir")]
    pub markdown_dir: String,

    /// Episodic memory configuration
    #[serde(default)]
    pub episodic: EpisodicConfig,
}

impl Default for MemoryConfig {
    fn default() -> Self {
        Self {
            backend: default_backend(),
            db_path: default_db_path(),
            markdown_dir: default_markdown_dir(),
            episodic: EpisodicConfig::default(),
        }
    }
}

fn default_backend() -> String {
    "sqlite".to_string()
}

fn default_db_path() -> String {
    "memory/brain.db".to_string()
}

fn default_markdown_dir() -> String {
    "memory".to_string()
}

impl MemoryConfig {
    /// Load configuration from file
    pub fn from_file(path: &std::path::Path) -> anyhow::Result<Self> {
        let content = std::fs::read_to_string(path)?;
        let config: MemoryConfig = serde_yaml::from_str(&content)?;
        Ok(config)
    }
}

/// Load the default memory configuration using unified config resolution.
///
/// Resolution order:
/// 1. `ENACT_MEMORY_CONFIG_PATH` environment variable
/// 2. `./memory.yaml` in current working directory
/// 3. `~/.enact/memory.yaml`
/// 4. Hardcoded defaults
///
/// # Example
///
/// ```rust,no_run
/// use enact_memory::config::load_default_memory_config;
///
/// let config = load_default_memory_config();
/// println!("Backend: {}", config.backend);
/// ```
pub fn load_default_memory_config() -> MemoryConfig {
    // Use unified config resolution from enact-config
    if let Some(path) = enact_config::resolve_config_file("memory.yaml", "ENACT_MEMORY_CONFIG_PATH")
    {
        match MemoryConfig::from_file(&path) {
            Ok(config) => {
                tracing::debug!("Loaded memory config from {:?}", path);
                return config;
            }
            Err(e) => {
                tracing::warn!("Failed to load memory config from {:?}: {}", path, e);
            }
        }
    }

    // Fall back to hardcoded defaults
    tracing::debug!("Using default memory configuration");
    MemoryConfig::default()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_memory_config() {
        let config = MemoryConfig::default();
        assert_eq!(config.backend, "sqlite");
        assert_eq!(config.db_path, "memory/brain.db");
        assert_eq!(config.markdown_dir, "memory");
    }

    #[test]
    fn test_default_episodic_config() {
        let config = EpisodicConfig::default();
        assert_eq!(config.snapshot_dir, "memory/sessions");
        assert_eq!(config.max_snapshots, 50);
        assert_eq!(config.max_daily_entries, 100);
        assert!(config.auto_consolidate);
        assert_eq!(config.consolidation_time, "03:00");
        assert_eq!(config.retention_days, 30);
        assert!(config.include_timestamps);
    }

    #[test]
    fn test_config_serialization() {
        let config = MemoryConfig::default();
        let yaml = serde_yaml::to_string(&config).unwrap();
        let deserialized: MemoryConfig = serde_yaml::from_str(&yaml).unwrap();
        assert_eq!(deserialized.backend, config.backend);
        assert_eq!(deserialized.db_path, config.db_path);
    }

    #[test]
    fn test_load_default_memory_config_fallback() {
        // When no config file exists, should return defaults
        let config = load_default_memory_config();
        assert_eq!(config.backend, "sqlite");
    }

    #[test]
    fn test_from_file() {
        let temp_dir = tempfile::tempdir().unwrap();
        let config_path = temp_dir.path().join("memory.yaml");

        std::fs::write(
            &config_path,
            r#"
backend: markdown
db_path: "custom/db.sqlite"
markdown_dir: "custom/memory"
episodic:
  snapshot_dir: "custom/sessions"
  max_snapshots: 100
  max_daily_entries: 200
  auto_consolidate: false
  consolidation_time: "02:00"
  retention_days: 60
  include_timestamps: false
"#,
        )
        .unwrap();

        let config = MemoryConfig::from_file(&config_path).unwrap();
        assert_eq!(config.backend, "markdown");
        assert_eq!(config.db_path, "custom/db.sqlite");
        assert_eq!(config.markdown_dir, "custom/memory");
        assert_eq!(config.episodic.snapshot_dir, "custom/sessions");
        assert_eq!(config.episodic.max_snapshots, 100);
        assert_eq!(config.episodic.max_daily_entries, 200);
        assert!(!config.episodic.auto_consolidate);
        assert_eq!(config.episodic.consolidation_time, "02:00");
        assert_eq!(config.episodic.retention_days, 60);
        assert!(!config.episodic.include_timestamps);
    }
}