enya-agent 0.1.0

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

@@ -0,0 +1,178 @@
+//! MCP (Model Context Protocol) Client for Enact
+//!
+//! This module provides a client for the Model Context Protocol,
+//! allowing Enact to connect to MCP servers and use their tools.
+
+use anyhow::Result;
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::process::Stdio;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::process::{Child, Command};
+use tracing::debug;
+
+/// MCP Tool definition
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct McpTool {
+    pub name: String,
+    pub description: String,
+    pub parameters: serde_json::Value,
+}
+
+/// MCP Client for stdio transport
+pub struct McpStdioClient {
+    process: Child,
+    stdin: tokio::process::ChildStdin,
+    stdout: BufReader<tokio::process::ChildStdout>,
+}
+
+impl McpStdioClient {
+    /// Create a new MCP client connected to a command via stdio
+    pub async fn new(command: &str, args: &[&str]) -> Result<Self> {
+        let mut process = Command::new(command)
+            .args(args)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+
+        let stdin = process.stdin.take().unwrap();
+        let stdout = BufReader::new(process.stdout.take().unwrap());
+
+        let mut client = Self {
+            process,
+            stdin,
+            stdout,
+        };
+
+        // Initialize connection
+        client.initialize().await?;
+
+        Ok(client)
+    }
+
+    async fn initialize(&mut self) -> Result<()> {
+        let init_request = serde_json::json!({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {
+                    "name": "enact-mcp",
+                    "version": "0.1.0"
+                }
+            }
+        });
+
+        self.send_request(&init_request).await?;
+        let response = self.read_response().await?;
+        debug!("MCP initialized: {:?}", response);
+
+        Ok(())
+    }
+
+    async fn send_request(&mut self, request: &serde_json::Value) -> Result<()> {
+        let request_str = request.to_string();
+        debug!("Sending MCP request: {}", request_str);
+        
+        self.stdin.write_all(request_str.as_bytes()).await?;
+        self.stdin.write_all(b"\n").await?;
+        self.stdin.flush().await?;
+        
+        Ok(())
+    }
+
+    async fn read_response(&mut self) -> Result<serde_json::Value> {
+        let mut line = String::new();
+        self.stdout.read_line(&mut line).await?;
+        
+        debug!("Received MCP response: {}", line);
+        let response: serde_json::Value = serde_json::from_str(&line)?;
+        Ok(response)
+    }
+
+    /// List available tools from the MCP server
+    pub async fn list_tools(&mut self) -> Result<Vec<McpTool>> {
+        let request = serde_json::json!({
+            "jsonrpc": "2.0",
+            "id": 2,
+            "method": "tools/list"
+        });
+
+        self.send_request(&request).await?;
+        let response = self.read_response().await?;
+
+        let tools = response
+            .get("result")
+            .and_then(|r| r.get("tools"))
+            .and_then(|t| t.as_array())
+            .map(|arr| {
+                arr.iter()
+                    .filter_map(|tool| {
+                        Some(McpTool {
+                            name: tool.get("name")?.as_str()?.to_string(),
+                            description: tool.get("description")?.as_str()?.to_string(),
+                            parameters: tool.get("parameters")?.clone(),
+                        })
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        Ok(tools)
+    }
+
+    /// Call a tool on the MCP server
+    pub async fn call_tool(&mut self, name: &str, arguments: serde_json::Value) -> Result<String> {
+        let request = serde_json::json!({
+            "jsonrpc": "2.0",
+            "id": 3,
+            "method": "tools/call",
+            "params": {
+                "name": name,
+                "arguments": arguments
+            }
+        });
+
+        self.send_request(&request).await?;
+        let response = self.read_response().await?;
+
+        if let Some(error) = response.get("error") {
+            anyhow::bail!("MCP tool error: {:?}", error);
+        }
+
+        let content = response
+            .get("result")
+            .and_then(|r| r.get("content"))
+            .and_then(|c| c.as_array())
+            .and_then(|arr| arr.first())
+            .and_then(|item| item.get("text"))
+            .and_then(|t| t.as_str())
+            .unwrap_or("No content returned");
+
+        Ok(content.to_string())
+    }
+}
+
+impl Drop for McpStdioClient {
+    fn drop(&mut self) {
+        let _ = self.process.start_kill();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mcp_tool_creation() {
+        let tool = McpTool {
+            name: "test".to_string(),
+            description: "Test tool".to_string(),
+            parameters: serde_json::json!({}),
+        };
+        assert_eq!(tool.name, "test");
+    }
+}

package/crates/enact-memory/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "enact-memory"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Local-first memory backends for Enact"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["memory", "storage", "sqlite", "local"]
+categories.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+async-trait.workspace = true
+chrono.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+tokio.workspace = true
+uuid.workspace = true
+tracing.workspace = true
+rusqlite = { version = "0.32", features = ["bundled"] }
+reqwest.workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true

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

@@ -0,0 +1,20 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MemoryBackendKind {
+    Sqlite,
+    Markdown,
+    None,
+    Unknown,
+}
+
+pub fn classify_memory_backend(name: &str) -> MemoryBackendKind {
+    match name.trim().to_ascii_lowercase().as_str() {
+        "sqlite" => MemoryBackendKind::Sqlite,
+        "markdown" | "md" => MemoryBackendKind::Markdown,
+        "none" | "noop" => MemoryBackendKind::None,
+        _ => MemoryBackendKind::Unknown,
+    }
+}
+
+pub fn default_memory_backend_key() -> &'static str {
+    "sqlite"
+}

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

@@ -0,0 +1,230 @@
+//! Line-based markdown chunker — splits documents into semantic chunks.
+//!
+//! Splits on markdown headings and paragraph boundaries, respecting
+//! a max token limit per chunk. Preserves heading context.
+
+/// A single chunk of text with metadata.
+#[derive(Debug, Clone)]
+pub struct Chunk {
+    pub index: usize,
+    pub content: String,
+    pub heading: Option<String>,
+}
+
+/// Split markdown text into chunks, each under `max_tokens` approximate tokens.
+///
+/// Strategy:
+/// 1. Split on `## ` and `# ` headings (keeps heading with its content)
+/// 2. If a section exceeds `max_tokens`, split on blank lines (paragraphs)
+/// 3. If a paragraph still exceeds, split on line boundaries
+///
+/// Token estimation: ~4 chars per token (rough English average).
+pub fn chunk_markdown(text: &str, max_tokens: usize) -> Vec<Chunk> {
+    if text.trim().is_empty() {
+        return Vec::new();
+    }
+
+    let max_chars = max_tokens * 4;
+    let sections = split_on_headings(text);
+    let mut chunks = Vec::new();
+
+    for (heading, body) in sections {
+        let full = if let Some(ref h) = heading {
+            format!("{h}\n{body}")
+        } else {
+            body.clone()
+        };
+
+        if full.len() <= max_chars {
+            chunks.push(Chunk {
+                index: chunks.len(),
+                content: full.trim().to_string(),
+                heading: heading.clone(),
+            });
+        } else {
+            // Split on paragraphs (blank lines)
+            let paragraphs = split_on_blank_lines(&body);
+            let mut current = heading
+                .as_ref()
+                .map_or_else(String::new, |h| format!("{h}\n"));
+
+            for para in paragraphs {
+                if current.len() + para.len() > max_chars && !current.trim().is_empty() {
+                    chunks.push(Chunk {
+                        index: chunks.len(),
+                        content: current.trim().to_string(),
+                        heading: heading.clone(),
+                    });
+                    current = heading
+                        .as_ref()
+                        .map_or_else(String::new, |h| format!("{h}\n"));
+                }
+
+                if para.len() > max_chars {
+                    // Paragraph too big — split on lines
+                    if !current.trim().is_empty() {
+                        chunks.push(Chunk {
+                            index: chunks.len(),
+                            content: current.trim().to_string(),
+                            heading: heading.clone(),
+                        });
+                        current = heading
+                            .as_ref()
+                            .map_or_else(String::new, |h| format!("{h}\n"));
+                    }
+                    for line_chunk in split_on_lines(&para, max_chars) {
+                        chunks.push(Chunk {
+                            index: chunks.len(),
+                            content: line_chunk.trim().to_string(),
+                            heading: heading.clone(),
+                        });
+                    }
+                } else {
+                    current.push_str(&para);
+                    current.push('\n');
+                }
+            }
+
+            if !current.trim().is_empty() {
+                chunks.push(Chunk {
+                    index: chunks.len(),
+                    content: current.trim().to_string(),
+                    heading: heading.clone(),
+                });
+            }
+        }
+    }
+
+    // Filter out empty chunks
+    chunks.retain(|c| !c.content.is_empty());
+
+    // Re-index
+    for (i, chunk) in chunks.iter_mut().enumerate() {
+        chunk.index = i;
+    }
+
+    chunks
+}
+
+/// Split text into `(heading, body)` sections.
+fn split_on_headings(text: &str) -> Vec<(Option<String>, String)> {
+    let mut sections = Vec::new();
+    let mut current_heading: Option<String> = None;
+    let mut current_body = String::new();
+
+    for line in text.lines() {
+        if line.starts_with("# ") || line.starts_with("## ") || line.starts_with("### ") {
+            if !current_body.trim().is_empty() || current_heading.is_some() {
+                sections.push((current_heading.take(), current_body.clone()));
+                current_body.clear();
+            }
+            current_heading = Some(line.to_string());
+        } else {
+            current_body.push_str(line);
+            current_body.push('\n');
+        }
+    }
+
+    if !current_body.trim().is_empty() || current_heading.is_some() {
+        sections.push((current_heading, current_body));
+    }
+
+    sections
+}
+
+/// Split text on blank lines (paragraph boundaries)
+fn split_on_blank_lines(text: &str) -> Vec<String> {
+    let mut paragraphs = Vec::new();
+    let mut current = String::new();
+
+    for line in text.lines() {
+        if line.trim().is_empty() {
+            if !current.trim().is_empty() {
+                paragraphs.push(current.clone());
+                current.clear();
+            }
+        } else {
+            current.push_str(line);
+            current.push('\n');
+        }
+    }
+
+    if !current.trim().is_empty() {
+        paragraphs.push(current);
+    }
+
+    paragraphs
+}
+
+/// Split text on line boundaries to fit within `max_chars`
+fn split_on_lines(text: &str, max_chars: usize) -> Vec<String> {
+    let mut chunks = Vec::new();
+    let mut current = String::new();
+
+    for line in text.lines() {
+        if current.len() + line.len() + 1 > max_chars && !current.is_empty() {
+            chunks.push(current.clone());
+            current.clear();
+        }
+        current.push_str(line);
+        current.push('\n');
+    }
+
+    if !current.is_empty() {
+        chunks.push(current);
+    }
+
+    chunks
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_text() {
+        assert!(chunk_markdown("", 512).is_empty());
+        assert!(chunk_markdown("   ", 512).is_empty());
+    }
+
+    #[test]
+    fn single_short_paragraph() {
+        let chunks = chunk_markdown("Hello world", 512);
+        assert_eq!(chunks.len(), 1);
+        assert_eq!(chunks[0].content, "Hello world");
+        assert!(chunks[0].heading.is_none());
+    }
+
+    #[test]
+    fn heading_sections() {
+        let text = "# Title\nSome intro.\n\n## Section A\nContent A.\n\n## Section B\nContent B.";
+        let chunks = chunk_markdown(text, 512);
+        assert!(chunks.len() >= 3);
+    }
+
+    #[test]
+    fn respects_max_tokens() {
+        let long_text: String = (0..200).fold(String::new(), |mut s, i| {
+            use std::fmt::Write;
+            let _ = writeln!(
+                s,
+                "This is sentence number {i} with some extra words to fill it up."
+            );
+            s
+        });
+        let chunks = chunk_markdown(&long_text, 50);
+        assert!(chunks.len() > 1);
+        for chunk in &chunks {
+            assert!(chunk.content.len() <= 300);
+        }
+    }
+
+    #[test]
+    fn indexes_are_sequential() {
+        let text = "# A\nContent A\n\n# B\nContent B\n\n# C\nContent C";
+        let chunks = chunk_markdown(text, 512);
+        for (i, chunk) in chunks.iter().enumerate() {
+            assert_eq!(chunk.index, i);
+        }
+    }
+}

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

@@ -0,0 +1,221 @@
+//! Embedding providers for semantic memory search
+
+use async_trait::async_trait;
+
+/// Trait for embedding providers — convert text to vectors
+#[async_trait]
+pub trait EmbeddingProvider: Send + Sync {
+    /// Provider name
+    fn name(&self) -> &str;
+
+    /// Embedding dimensions
+    fn dimensions(&self) -> usize;
+
+    /// Embed a batch of texts into vectors
+    async fn embed(&self, texts: &[&str]) -> anyhow::Result<Vec<Vec<f32>>>;
+
+    /// Embed a single text
+    async fn embed_one(&self, text: &str) -> anyhow::Result<Vec<f32>> {
+        let mut results = self.embed(&[text]).await?;
+        results
+            .pop()
+            .ok_or_else(|| anyhow::anyhow!("Empty embedding result"))
+    }
+}
+
+// ── Noop provider (keyword-only fallback) ────────────────────
+
+/// No-op embedding provider that returns empty vectors
+pub struct NoopEmbedding;
+
+#[async_trait]
+impl EmbeddingProvider for NoopEmbedding {
+    fn name(&self) -> &str {
+        "none"
+    }
+
+    fn dimensions(&self) -> usize {
+        0
+    }
+
+    async fn embed(&self, _texts: &[&str]) -> anyhow::Result<Vec<Vec<f32>>> {
+        Ok(Vec::new())
+    }
+}
+
+// ── OpenAI-compatible embedding provider ─────────────────────
+
+/// OpenAI-compatible embedding provider
+pub struct OpenAiEmbedding {
+    base_url: String,
+    api_key: String,
+    model: String,
+    dims: usize,
+    client: reqwest::Client,
+}
+
+impl OpenAiEmbedding {
+    pub fn new(base_url: &str, api_key: &str, model: &str, dims: usize) -> Self {
+        Self {
+            base_url: base_url.trim_end_matches('/').to_string(),
+            api_key: api_key.to_string(),
+            model: model.to_string(),
+            dims,
+            client: reqwest::Client::new(),
+        }
+    }
+
+    fn embeddings_url(&self) -> String {
+        let url = reqwest::Url::parse(&self.base_url).ok();
+        let has_embeddings = url
+            .as_ref()
+            .map(|u| u.path().trim_end_matches('/').ends_with("/embeddings"))
+            .unwrap_or(false);
+
+        if has_embeddings {
+            return self.base_url.clone();
+        }
+
+        let has_path = url
+            .as_ref()
+            .map(|u| {
+                let path = u.path().trim_end_matches('/');
+                !path.is_empty() && path != "/"
+            })
+            .unwrap_or(false);
+
+        if has_path {
+            format!("{}/embeddings", self.base_url)
+        } else {
+            format!("{}/v1/embeddings", self.base_url)
+        }
+    }
+}
+
+#[async_trait]
+impl EmbeddingProvider for OpenAiEmbedding {
+    fn name(&self) -> &str {
+        "openai"
+    }
+
+    fn dimensions(&self) -> usize {
+        self.dims
+    }
+
+    async fn embed(&self, texts: &[&str]) -> anyhow::Result<Vec<Vec<f32>>> {
+        if texts.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let body = serde_json::json!({
+            "model": self.model,
+            "input": texts,
+        });
+
+        let resp = self
+            .client
+            .post(self.embeddings_url())
+            .header("Authorization", format!("Bearer {}", self.api_key))
+            .header("Content-Type", "application/json")
+            .json(&body)
+            .send()
+            .await?;
+
+        if !resp.status().is_success() {
+            let status = resp.status();
+            let text = resp.text().await.unwrap_or_default();
+            anyhow::bail!("Embedding API error {status}: {text}");
+        }
+
+        let json: serde_json::Value = resp.json().await?;
+        let data = json
+            .get("data")
+            .and_then(|d| d.as_array())
+            .ok_or_else(|| anyhow::anyhow!("Invalid embedding response: missing 'data'"))?;
+
+        let mut embeddings = Vec::with_capacity(data.len());
+        for item in data {
+            let embedding = item
+                .get("embedding")
+                .and_then(|e| e.as_array())
+                .ok_or_else(|| anyhow::anyhow!("Invalid embedding item"))?;
+
+            #[allow(clippy::cast_possible_truncation)]
+            let vec: Vec<f32> = embedding
+                .iter()
+                .filter_map(|v| v.as_f64().map(|f| f as f32))
+                .collect();
+
+            embeddings.push(vec);
+        }
+
+        Ok(embeddings)
+    }
+}
+
+// ── Factory ──────────────────────────────────────────────────
+
+/// Create an embedding provider
+pub fn create_embedding_provider(
+    provider: &str,
+    api_key: Option<&str>,
+    model: &str,
+    dims: usize,
+) -> Box<dyn EmbeddingProvider> {
+    match provider {
+        "openai" => {
+            let key = api_key.unwrap_or("");
+            Box::new(OpenAiEmbedding::new(
+                "https://api.openai.com",
+                key,
+                model,
+                dims,
+            ))
+        }
+        name if name.starts_with("custom:") => {
+            let base_url = name.strip_prefix("custom:").unwrap_or("");
+            let key = api_key.unwrap_or("");
+            Box::new(OpenAiEmbedding::new(base_url, key, model, dims))
+        }
+        _ => Box::new(NoopEmbedding),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn noop_name() {
+        let p = NoopEmbedding;
+        assert_eq!(p.name(), "none");
+        assert_eq!(p.dimensions(), 0);
+    }
+
+    #[tokio::test]
+    async fn noop_embed_returns_empty() {
+        let p = NoopEmbedding;
+        let result = p.embed(&["hello"]).await.unwrap();
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn factory_none() {
+        let p = create_embedding_provider("none", None, "model", 1536);
+        assert_eq!(p.name(), "none");
+    }
+
+    #[test]
+    fn factory_openai() {
+        let p = create_embedding_provider("openai", Some("key"), "text-embedding-3-small", 1536);
+        assert_eq!(p.name(), "openai");
+        assert_eq!(p.dimensions(), 1536);
+    }
+
+    #[test]
+    fn factory_custom_url() {
+        let p = create_embedding_provider("custom:http://localhost:1234", None, "model", 768);
+        assert_eq!(p.name(), "openai");
+        assert_eq!(p.dimensions(), 768);
+    }
+}