enya-agent 0.1.0

package/crates/enact-memory/src/lib.rs

@@ -0,0 +1,67 @@
+pub mod backend;
+pub mod chunker;
+pub mod embeddings;
+pub mod markdown;
+pub mod none;
+pub mod sqlite;
+pub mod traits;
+pub mod vector;
+
+pub use backend::{MemoryBackendKind, classify_memory_backend, default_memory_backend_key};
+pub use chunker::{chunk_markdown, Chunk};
+pub use embeddings::{create_embedding_provider, EmbeddingProvider, NoopEmbedding, OpenAiEmbedding};
+pub use markdown::MarkdownMemory;
+pub use none::NoneMemory;
+pub use sqlite::SqliteMemory;
+pub use traits::{Memory, MemoryCategory, MemoryEntry};
+pub use vector::{bytes_to_vec, cosine_similarity, hybrid_merge, vec_to_bytes, ScoredResult};
+
+use std::path::Path;
+
+pub fn create_memory(backend: &str, workspace_dir: &Path) -> anyhow::Result<Box<dyn Memory>> {
+    match classify_memory_backend(backend) {
+        MemoryBackendKind::Sqlite => Ok(Box::new(SqliteMemory::new(workspace_dir)?)),
+        MemoryBackendKind::Markdown => Ok(Box::new(MarkdownMemory::new(workspace_dir))),
+        MemoryBackendKind::None => Ok(Box::new(NoneMemory::new())),
+        MemoryBackendKind::Unknown => {
+            tracing::warn!(
+                "Unknown memory backend '{}', falling back to markdown",
+                backend
+            );
+            Ok(Box::new(MarkdownMemory::new(workspace_dir)))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn factory_sqlite() {
+        let tmp = tempfile::TempDir::new().unwrap();
+        let mem = create_memory("sqlite", tmp.path()).unwrap();
+        assert_eq!(mem.name(), "sqlite");
+    }
+
+    #[test]
+    fn factory_markdown() {
+        let tmp = tempfile::TempDir::new().unwrap();
+        let mem = create_memory("markdown", tmp.path()).unwrap();
+        assert_eq!(mem.name(), "markdown");
+    }
+
+    #[test]
+    fn factory_none() {
+        let tmp = tempfile::TempDir::new().unwrap();
+        let mem = create_memory("none", tmp.path()).unwrap();
+        assert_eq!(mem.name(), "none");
+    }
+
+    #[test]
+    fn factory_unknown_falls_back_to_markdown() {
+        let tmp = tempfile::TempDir::new().unwrap();
+        let mem = create_memory("redis", tmp.path()).unwrap();
+        assert_eq!(mem.name(), "markdown");
+    }
+}

package/crates/enact-memory/src/markdown.rs

@@ -0,0 +1,127 @@
+use crate::traits::{Memory, MemoryCategory, MemoryEntry};
+use async_trait::async_trait;
+use chrono::Utc;
+use std::path::{Path, PathBuf};
+
+pub struct MarkdownMemory {
+    root: PathBuf,
+}
+
+impl MarkdownMemory {
+    pub fn new(workspace_dir: &Path) -> Self {
+        Self {
+            root: workspace_dir.join("memory"),
+        }
+    }
+
+    fn file_for(&self, key: &str) -> PathBuf {
+        let safe = key
+            .chars()
+            .map(|c| {
+                if c.is_ascii_alphanumeric() || matches!(c, '-' | '_') {
+                    c
+                } else {
+                    '_'
+                }
+            })
+            .collect::<String>();
+        self.root.join(format!("{safe}.md"))
+    }
+
+    fn parse_entry(path: &Path, content: &str) -> Option<MemoryEntry> {
+        let key = path.file_stem()?.to_str()?.to_string();
+        Some(MemoryEntry {
+            id: key.clone(),
+            key,
+            content: content.to_string(),
+            category: MemoryCategory::Conversation,
+            timestamp: Utc::now().to_rfc3339(),
+            session_id: None,
+            score: None,
+        })
+    }
+}
+
+#[async_trait]
+impl Memory for MarkdownMemory {
+    fn name(&self) -> &str {
+        "markdown"
+    }
+
+    async fn store(
+        &self,
+        key: &str,
+        content: &str,
+        _category: MemoryCategory,
+        _session_id: Option<&str>,
+    ) -> anyhow::Result<()> {
+        tokio::fs::create_dir_all(&self.root).await?;
+        tokio::fs::write(self.file_for(key), content).await?;
+        Ok(())
+    }
+
+    async fn recall(
+        &self,
+        query: &str,
+        limit: usize,
+        _session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>> {
+        let mut entries = self.list(None, None).await?;
+        let q = query.to_ascii_lowercase();
+        entries.retain(|e| {
+            e.key.to_ascii_lowercase().contains(&q) || e.content.to_ascii_lowercase().contains(&q)
+        });
+        entries.truncate(limit);
+        Ok(entries)
+    }
+
+    async fn get(&self, key: &str) -> anyhow::Result<Option<MemoryEntry>> {
+        let path = self.file_for(key);
+        if !path.exists() {
+            return Ok(None);
+        }
+        let content = tokio::fs::read_to_string(&path).await?;
+        Ok(Self::parse_entry(&path, &content))
+    }
+
+    async fn list(
+        &self,
+        _category: Option<&MemoryCategory>,
+        _session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>> {
+        let mut out = Vec::new();
+        if !self.root.exists() {
+            return Ok(out);
+        }
+
+        let mut dir = tokio::fs::read_dir(&self.root).await?;
+        while let Some(entry) = dir.next_entry().await? {
+            let path = entry.path();
+            if path.extension().and_then(|e| e.to_str()) != Some("md") {
+                continue;
+            }
+            let content = tokio::fs::read_to_string(&path).await?;
+            if let Some(parsed) = Self::parse_entry(&path, &content) {
+                out.push(parsed);
+            }
+        }
+        Ok(out)
+    }
+
+    async fn forget(&self, key: &str) -> anyhow::Result<bool> {
+        let path = self.file_for(key);
+        if !path.exists() {
+            return Ok(false);
+        }
+        tokio::fs::remove_file(path).await?;
+        Ok(true)
+    }
+
+    async fn count(&self) -> anyhow::Result<usize> {
+        Ok(self.list(None, None).await?.len())
+    }
+
+    async fn health_check(&self) -> bool {
+        tokio::fs::create_dir_all(&self.root).await.is_ok()
+    }
+}

package/crates/enact-memory/src/none.rs

@@ -0,0 +1,61 @@
+use crate::traits::{Memory, MemoryCategory, MemoryEntry};
+use async_trait::async_trait;
+
+#[derive(Default)]
+pub struct NoneMemory;
+
+impl NoneMemory {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[async_trait]
+impl Memory for NoneMemory {
+    fn name(&self) -> &str {
+        "none"
+    }
+
+    async fn store(
+        &self,
+        _key: &str,
+        _content: &str,
+        _category: MemoryCategory,
+        _session_id: Option<&str>,
+    ) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    async fn recall(
+        &self,
+        _query: &str,
+        _limit: usize,
+        _session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>> {
+        Ok(vec![])
+    }
+
+    async fn get(&self, _key: &str) -> anyhow::Result<Option<MemoryEntry>> {
+        Ok(None)
+    }
+
+    async fn list(
+        &self,
+        _category: Option<&MemoryCategory>,
+        _session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>> {
+        Ok(vec![])
+    }
+
+    async fn forget(&self, _key: &str) -> anyhow::Result<bool> {
+        Ok(false)
+    }
+
+    async fn count(&self) -> anyhow::Result<usize> {
+        Ok(0)
+    }
+
+    async fn health_check(&self) -> bool {
+        true
+    }
+}

package/crates/enact-memory/src/sqlite.rs

@@ -0,0 +1,276 @@
+use crate::traits::{Memory, MemoryCategory, MemoryEntry};
+use async_trait::async_trait;
+use chrono::Utc;
+use rusqlite::{Connection, params};
+use std::path::{Path, PathBuf};
+
+pub struct SqliteMemory {
+    db_path: PathBuf,
+}
+
+impl SqliteMemory {
+    pub fn new(workspace_dir: &Path) -> anyhow::Result<Self> {
+        let db_path = workspace_dir.join("memory").join("brain.db");
+        if let Some(parent) = db_path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let this = Self { db_path };
+        this.init_schema()?;
+        Ok(this)
+    }
+
+    fn open(&self) -> anyhow::Result<Connection> {
+        Ok(Connection::open(&self.db_path)?)
+    }
+
+    fn init_schema(&self) -> anyhow::Result<()> {
+        let conn = self.open()?;
+        conn.execute_batch(
+            "
+            CREATE TABLE IF NOT EXISTS memory_entries (
+                id TEXT PRIMARY KEY,
+                key TEXT NOT NULL UNIQUE,
+                content TEXT NOT NULL,
+                category TEXT NOT NULL,
+                timestamp TEXT NOT NULL,
+                session_id TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_memory_key ON memory_entries(key);
+            CREATE INDEX IF NOT EXISTS idx_memory_category ON memory_entries(category);
+            CREATE INDEX IF NOT EXISTS idx_memory_session_id ON memory_entries(session_id);
+            ",
+        )?;
+        Ok(())
+    }
+
+    fn to_category(raw: &str) -> MemoryCategory {
+        match raw {
+            "core" => MemoryCategory::Core,
+            "daily" => MemoryCategory::Daily,
+            "conversation" => MemoryCategory::Conversation,
+            other => MemoryCategory::Custom(other.to_string()),
+        }
+    }
+}
+
+#[async_trait]
+impl Memory for SqliteMemory {
+    fn name(&self) -> &str {
+        "sqlite"
+    }
+
+    async fn store(
+        &self,
+        key: &str,
+        content: &str,
+        category: MemoryCategory,
+        session_id: Option<&str>,
+    ) -> anyhow::Result<()> {
+        let db_path = self.db_path.clone();
+        let key = key.to_string();
+        let content = content.to_string();
+        let category = category.to_string();
+        let session_id = session_id.map(|s| s.to_string());
+
+        tokio::task::spawn_blocking(move || -> anyhow::Result<()> {
+            let conn = Connection::open(db_path)?;
+            conn.execute(
+                "
+                INSERT INTO memory_entries (id, key, content, category, timestamp, session_id)
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6)
+                ON CONFLICT(key)
+                DO UPDATE SET
+                    content=excluded.content,
+                    category=excluded.category,
+                    timestamp=excluded.timestamp,
+                    session_id=excluded.session_id
+                ",
+                params![
+                    uuid::Uuid::new_v4().to_string(),
+                    key,
+                    content,
+                    category,
+                    Utc::now().to_rfc3339(),
+                    session_id,
+                ],
+            )?;
+            Ok(())
+        })
+        .await??;
+
+        Ok(())
+    }
+
+    async fn recall(
+        &self,
+        query: &str,
+        limit: usize,
+        session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>> {
+        let db_path = self.db_path.clone();
+        let query = query.to_string();
+        let session = session_id.map(|s| s.to_string());
+
+        tokio::task::spawn_blocking(move || -> anyhow::Result<Vec<MemoryEntry>> {
+            let conn = Connection::open(db_path)?;
+            let mut out = Vec::new();
+            let like = format!("%{}%", query);
+
+            if let Some(session_id) = session {
+                let mut stmt = conn.prepare(
+                    "
+                    SELECT id, key, content, category, timestamp, session_id
+                    FROM memory_entries
+                    WHERE (key LIKE ?1 OR content LIKE ?1)
+                      AND session_id = ?2
+                    ORDER BY timestamp DESC
+                    LIMIT ?3
+                    ",
+                )?;
+                let rows = stmt.query_map(params![like, session_id, limit as i64], |row| {
+                    let category_raw: String = row.get(3)?;
+                    Ok(MemoryEntry {
+                        id: row.get(0)?,
+                        key: row.get(1)?,
+                        content: row.get(2)?,
+                        category: Self::to_category(&category_raw),
+                        timestamp: row.get(4)?,
+                        session_id: row.get(5)?,
+                        score: None,
+                    })
+                })?;
+
+                for row in rows {
+                    out.push(row?);
+                }
+            } else {
+                let mut stmt = conn.prepare(
+                    "
+                    SELECT id, key, content, category, timestamp, session_id
+                    FROM memory_entries
+                    WHERE key LIKE ?1 OR content LIKE ?1
+                    ORDER BY timestamp DESC
+                    LIMIT ?2
+                    ",
+                )?;
+                let rows = stmt.query_map(params![like, limit as i64], |row| {
+                    let category_raw: String = row.get(3)?;
+                    Ok(MemoryEntry {
+                        id: row.get(0)?,
+                        key: row.get(1)?,
+                        content: row.get(2)?,
+                        category: Self::to_category(&category_raw),
+                        timestamp: row.get(4)?,
+                        session_id: row.get(5)?,
+                        score: None,
+                    })
+                })?;
+
+                for row in rows {
+                    out.push(row?);
+                }
+            }
+
+            Ok(out)
+        })
+        .await?
+    }
+
+    async fn get(&self, key: &str) -> anyhow::Result<Option<MemoryEntry>> {
+        let db_path = self.db_path.clone();
+        let key = key.to_string();
+
+        tokio::task::spawn_blocking(move || -> anyhow::Result<Option<MemoryEntry>> {
+            let conn = Connection::open(db_path)?;
+            let mut stmt = conn.prepare(
+                "SELECT id, key, content, category, timestamp, session_id FROM memory_entries WHERE key = ?1",
+            )?;
+            let mut rows = stmt.query(params![key])?;
+            if let Some(row) = rows.next()? {
+                let category_raw: String = row.get(3)?;
+                return Ok(Some(MemoryEntry {
+                    id: row.get(0)?,
+                    key: row.get(1)?,
+                    content: row.get(2)?,
+                    category: Self::to_category(&category_raw),
+                    timestamp: row.get(4)?,
+                    session_id: row.get(5)?,
+                    score: None,
+                }));
+            }
+            Ok(None)
+        })
+        .await?
+    }
+
+    async fn list(
+        &self,
+        category: Option<&MemoryCategory>,
+        session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>> {
+        let db_path = self.db_path.clone();
+        let category = category.map(|c| c.to_string());
+        let session = session_id.map(|s| s.to_string());
+
+        tokio::task::spawn_blocking(move || -> anyhow::Result<Vec<MemoryEntry>> {
+            let conn = Connection::open(db_path)?;
+            let mut out = Vec::new();
+
+            let sql = match (category.is_some(), session.is_some()) {
+                (false, false) => "SELECT id, key, content, category, timestamp, session_id FROM memory_entries ORDER BY timestamp DESC",
+                (true, false) => "SELECT id, key, content, category, timestamp, session_id FROM memory_entries WHERE category = ?1 ORDER BY timestamp DESC",
+                (false, true) => "SELECT id, key, content, category, timestamp, session_id FROM memory_entries WHERE session_id = ?1 ORDER BY timestamp DESC",
+                (true, true) => "SELECT id, key, content, category, timestamp, session_id FROM memory_entries WHERE category = ?1 AND session_id = ?2 ORDER BY timestamp DESC",
+            };
+
+            let mut stmt = conn.prepare(sql)?;
+            let mut rows = match (category, session) {
+                (None, None) => stmt.query(params![] )?,
+                (Some(c), None) => stmt.query(params![c])?,
+                (None, Some(s)) => stmt.query(params![s])?,
+                (Some(c), Some(s)) => stmt.query(params![c, s])?,
+            };
+
+            while let Some(row) = rows.next()? {
+                let category_raw: String = row.get(3)?;
+                out.push(MemoryEntry {
+                    id: row.get(0)?,
+                    key: row.get(1)?,
+                    content: row.get(2)?,
+                    category: Self::to_category(&category_raw),
+                    timestamp: row.get(4)?,
+                    session_id: row.get(5)?,
+                    score: None,
+                });
+            }
+
+            Ok(out)
+        })
+        .await?
+    }
+
+    async fn forget(&self, key: &str) -> anyhow::Result<bool> {
+        let db_path = self.db_path.clone();
+        let key = key.to_string();
+        tokio::task::spawn_blocking(move || -> anyhow::Result<bool> {
+            let conn = Connection::open(db_path)?;
+            let affected = conn.execute("DELETE FROM memory_entries WHERE key = ?1", params![key])?;
+            Ok(affected > 0)
+        })
+        .await?
+    }
+
+    async fn count(&self) -> anyhow::Result<usize> {
+        let db_path = self.db_path.clone();
+        tokio::task::spawn_blocking(move || -> anyhow::Result<usize> {
+            let conn = Connection::open(db_path)?;
+            let count: i64 = conn.query_row("SELECT COUNT(*) FROM memory_entries", params![], |r| r.get(0))?;
+            Ok(count.max(0) as usize)
+        })
+        .await?
+    }
+
+    async fn health_check(&self) -> bool {
+        self.open().is_ok()
+    }
+}

package/crates/enact-memory/src/traits.rs

@@ -0,0 +1,65 @@
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MemoryEntry {
+    pub id: String,
+    pub key: String,
+    pub content: String,
+    pub category: MemoryCategory,
+    pub timestamp: String,
+    pub session_id: Option<String>,
+    pub score: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum MemoryCategory {
+    Core,
+    Daily,
+    Conversation,
+    Custom(String),
+}
+
+impl std::fmt::Display for MemoryCategory {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Core => write!(f, "core"),
+            Self::Daily => write!(f, "daily"),
+            Self::Conversation => write!(f, "conversation"),
+            Self::Custom(name) => write!(f, "{name}"),
+        }
+    }
+}
+
+#[async_trait]
+pub trait Memory: Send + Sync {
+    fn name(&self) -> &str;
+
+    async fn store(
+        &self,
+        key: &str,
+        content: &str,
+        category: MemoryCategory,
+        session_id: Option<&str>,
+    ) -> anyhow::Result<()>;
+
+    async fn recall(
+        &self,
+        query: &str,
+        limit: usize,
+        session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>>;
+
+    async fn get(&self, key: &str) -> anyhow::Result<Option<MemoryEntry>>;
+
+    async fn list(
+        &self,
+        category: Option<&MemoryCategory>,
+        session_id: Option<&str>,
+    ) -> anyhow::Result<Vec<MemoryEntry>>;
+
+    async fn forget(&self, key: &str) -> anyhow::Result<bool>;
+    async fn count(&self) -> anyhow::Result<usize>;
+    async fn health_check(&self) -> bool;
+}