@plures/runebook 0.4.0

package/src-tauri/src/memory/api.rs

@@ -0,0 +1,422 @@
+// Rust API layer for cognitive memory storage
+// Provides: append_event, list_sessions, query_recent_errors, get_context, persist_suggestion
+
+use crate::memory::client::PluresDBClient;
+use crate::memory::encryption::EncryptionProvider;
+use crate::memory::schema::*;
+use anyhow::{Context, Result};
+use chrono::{DateTime, Duration as ChronoDuration, Utc};
+use serde_json::Value;
+use std::collections::HashMap;
+
+/// Main memory store API
+pub struct MemoryStore {
+    pub(crate) client: PluresDBClient,
+    encryption: Option<Box<dyn EncryptionProvider>>,
+}
+
+impl MemoryStore {
+    pub async fn new(client: PluresDBClient) -> Result<Self> {
+        // TODO: Initialize encryption if configured
+        let encryption: Option<Box<dyn EncryptionProvider>> = None;
+
+        Ok(Self { client, encryption })
+    }
+
+    /// Append an event to memory storage
+    pub async fn append_event(&self, event: MemoryEvent) -> Result<()> {
+        let key = format!("memory:event:{}", event.id);
+        let value = serde_json::to_value(&event)?;
+
+        // Encrypt if encryption is enabled
+        let value = if let Some(enc) = &self.encryption {
+            enc.encrypt(&value).await?
+        } else {
+            value
+        };
+
+        self.client.put(&key, &value).await?;
+
+        // Also update session if it's a session event
+        if event.event_type == "session_start" {
+            if let Ok(session) = serde_json::from_value::<Session>(event.data.clone()) {
+                let session_key = format!("memory:session:{}", session.id);
+                self.client
+                    .put(&session_key, &serde_json::to_value(&session)?)
+                    .await?;
+            }
+        }
+
+        // Store provenance if provided
+        if let Some(prov) = event.provenance {
+            let prov_key = format!("memory:provenance:{}", prov.id);
+            self.client
+                .put(&prov_key, &serde_json::to_value(&prov)?)
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    /// List all sessions
+    pub async fn list_sessions(&self) -> Result<Vec<Session>> {
+        let keys = self.client.list("memory:session:").await?;
+        let mut sessions = Vec::new();
+
+        for key in keys {
+            if let Some(value) = self.client.get(&key).await? {
+                // Decrypt if encryption is enabled
+                let value = if let Some(enc) = &self.encryption {
+                    enc.decrypt(&value).await?
+                } else {
+                    value
+                };
+
+                if let Ok(session) = serde_json::from_value::<Session>(value) {
+                    sessions.push(session);
+                }
+            }
+        }
+
+        // Sort by started_at descending
+        sessions.sort_by(|a, b| b.started_at.cmp(&a.started_at));
+
+        Ok(sessions)
+    }
+
+    /// Query recent errors
+    pub async fn query_recent_errors(
+        &self,
+        limit: Option<usize>,
+        since: Option<DateTime<Utc>>,
+        severity: Option<&str>,
+    ) -> Result<Vec<Error>> {
+        let keys = self.client.list("memory:error:").await?;
+        let mut errors = Vec::new();
+
+        for key in keys {
+            if let Some(value) = self.client.get(&key).await? {
+                // Decrypt if encryption is enabled
+                let value = if let Some(enc) = &self.encryption {
+                    enc.decrypt(&value).await?
+                } else {
+                    value
+                };
+
+                if let Ok(error) = serde_json::from_value::<Error>(value) {
+                    // Filter by timestamp
+                    if let Some(since_time) = since {
+                        if error.timestamp < since_time {
+                            continue;
+                        }
+                    }
+
+                    // Filter by severity
+                    if let Some(sev) = severity {
+                        if error.severity != sev {
+                            continue;
+                        }
+                    }
+
+                    errors.push(error);
+                }
+            }
+        }
+
+        // Sort by timestamp descending
+        errors.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+
+        // Apply limit
+        if let Some(limit) = limit {
+            errors.truncate(limit);
+        }
+
+        Ok(errors)
+    }
+
+    /// Get context window for analysis
+    pub async fn get_context(
+        &self,
+        session_id: &str,
+        window: ChronoDuration,
+    ) -> Result<ContextWindow> {
+        let end_time = Utc::now();
+        let start_time = end_time - window;
+
+        // Get session
+        let session_key = format!("memory:session:{}", session_id);
+        let session: Session = if let Some(value) = self.client.get(&session_key).await? {
+            let value = if let Some(enc) = &self.encryption {
+                enc.decrypt(&value).await?
+            } else {
+                value
+            };
+            serde_json::from_value(value).context("Failed to deserialize session")?
+        } else {
+            anyhow::bail!("Session not found: {}", session_id);
+        };
+
+        // Get commands in time window
+        let command_keys = self.client.list("memory:command:").await?;
+        let mut commands = Vec::new();
+        for key in command_keys {
+            if let Some(value) = self.client.get(&key).await? {
+                let value = if let Some(enc) = &self.encryption {
+                    enc.decrypt(&value).await?
+                } else {
+                    value
+                };
+
+                if let Ok(cmd) = serde_json::from_value::<Command>(value) {
+                    if cmd.session_id == session_id
+                        && cmd.started_at >= start_time
+                        && cmd.started_at <= end_time
+                    {
+                        commands.push(cmd);
+                    }
+                }
+            }
+        }
+        commands.sort_by(|a, b| a.started_at.cmp(&b.started_at));
+
+        // Get outputs for these commands
+        let output_keys = self.client.list("memory:output:").await?;
+        let mut outputs = Vec::new();
+        let command_ids: std::collections::HashSet<String> =
+            commands.iter().map(|c| c.id.clone()).collect();
+        for key in output_keys {
+            if let Some(value) = self.client.get(&key).await? {
+                let value = if let Some(enc) = &self.encryption {
+                    enc.decrypt(&value).await?
+                } else {
+                    value
+                };
+
+                if let Ok(output) = serde_json::from_value::<Output>(value) {
+                    if command_ids.contains(&output.command_id) {
+                        outputs.push(output);
+                    }
+                }
+            }
+        }
+        outputs.sort_by(|a, b| a.chunk_index.cmp(&b.chunk_index));
+
+        // Get errors in time window
+        let error_keys = self.client.list("memory:error:").await?;
+        let mut errors = Vec::new();
+        for key in error_keys {
+            if let Some(value) = self.client.get(&key).await? {
+                let value = if let Some(enc) = &self.encryption {
+                    enc.decrypt(&value).await?
+                } else {
+                    value
+                };
+
+                if let Ok(error) = serde_json::from_value::<Error>(value) {
+                    if error.session_id == session_id
+                        && error.timestamp >= start_time
+                        && error.timestamp <= end_time
+                    {
+                        errors.push(error);
+                    }
+                }
+            }
+        }
+        errors.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
+
+        // Get insights
+        let insight_keys = self.client.list("memory:insight:").await?;
+        let mut insights = Vec::new();
+        for key in insight_keys {
+            if let Some(value) = self.client.get(&key).await? {
+                let value = if let Some(enc) = &self.encryption {
+                    enc.decrypt(&value).await?
+                } else {
+                    value
+                };
+
+                if let Ok(insight) = serde_json::from_value::<Insight>(value) {
+                    if insight.session_id.as_ref().map(|s| s.as_str()) == Some(session_id)
+                        && insight.generated_at >= start_time
+                        && insight.generated_at <= end_time
+                    {
+                        insights.push(insight);
+                    }
+                }
+            }
+        }
+        insights.sort_by(|a, b| a.generated_at.cmp(&b.generated_at));
+
+        Ok(ContextWindow {
+            session_id: session_id.to_string(),
+            start_time,
+            end_time,
+            commands,
+            outputs,
+            errors,
+            insights,
+        })
+    }
+
+    /// Persist a suggestion
+    pub async fn persist_suggestion(&self, suggestion: Suggestion) -> Result<()> {
+        let key = format!("memory:suggestion:{}", suggestion.id);
+        let value = serde_json::to_value(&suggestion)?;
+
+        // Encrypt if encryption is enabled
+        let value = if let Some(enc) = &self.encryption {
+            enc.encrypt(&value).await?
+        } else {
+            value
+        };
+
+        self.client.put(&key, &value).await?;
+        Ok(())
+    }
+
+    /// Get all suggestions, optionally filtered by priority
+    pub async fn get_suggestions(
+        &self,
+        priority: Option<&str>,
+        limit: Option<usize>,
+    ) -> Result<Vec<Suggestion>> {
+        let keys = self.client.list("memory:suggestion:").await?;
+        let mut suggestions = Vec::new();
+
+        for key in keys {
+            if let Some(value) = self.client.get(&key).await? {
+                let value = if let Some(enc) = &self.encryption {
+                    enc.decrypt(&value).await?
+                } else {
+                    value
+                };
+
+                if let Ok(suggestion) = serde_json::from_value::<Suggestion>(value) {
+                    // Filter by priority if specified
+                    if let Some(pri) = priority {
+                        if suggestion.priority != pri {
+                            continue;
+                        }
+                    }
+
+                    // Skip dismissed suggestions
+                    if suggestion.dismissed {
+                        continue;
+                    }
+
+                    suggestions.push(suggestion);
+                }
+            }
+        }
+
+        // Sort by rank descending
+        suggestions.sort_by(|a, b| {
+            b.rank
+                .partial_cmp(&a.rank)
+                .unwrap_or(std::cmp::Ordering::Equal)
+        });
+
+        // Apply limit
+        if let Some(limit) = limit {
+            suggestions.truncate(limit);
+        }
+
+        Ok(suggestions)
+    }
+
+    /// Store a command
+    pub async fn store_command(&self, command: Command) -> Result<()> {
+        let key = format!("memory:command:{}", command.id);
+        let value = serde_json::to_value(&command)?;
+
+        let value = if let Some(enc) = &self.encryption {
+            enc.encrypt(&value).await?
+        } else {
+            value
+        };
+
+        self.client.put(&key, &value).await?;
+        Ok(())
+    }
+
+    /// Store an output chunk (with optional compression)
+    pub async fn store_output(&self, output: &mut Output, compress: bool) -> Result<()> {
+        if compress && !output.compressed {
+            use flate2::write::GzEncoder;
+            use flate2::Compression;
+            use std::io::Write;
+
+            let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+            encoder.write_all(&output.content)?;
+            let compressed = encoder.finish()?;
+
+            output.content = compressed;
+            output.compressed = true;
+        }
+
+        let key = format!("memory:output:{}", output.id);
+        let value = serde_json::to_value(output)?;
+
+        let value = if let Some(enc) = &self.encryption {
+            enc.encrypt(&value).await?
+        } else {
+            value
+        };
+
+        self.client.put(&key, &value).await?;
+        Ok(())
+    }
+
+    /// Store an error
+    pub async fn store_error(&self, error: Error) -> Result<()> {
+        let key = format!("memory:error:{}", error.id);
+        let value = serde_json::to_value(&error)?;
+
+        let value = if let Some(enc) = &self.encryption {
+            enc.encrypt(&value).await?
+        } else {
+            value
+        };
+
+        self.client.put(&key, &value).await?;
+        Ok(())
+    }
+
+    /// Store an insight
+    pub async fn store_insight(&self, insight: Insight) -> Result<()> {
+        let key = format!("memory:insight:{}", insight.id);
+        let value = serde_json::to_value(&insight)?;
+
+        let value = if let Some(enc) = &self.encryption {
+            enc.encrypt(&value).await?
+        } else {
+            value
+        };
+
+        self.client.put(&key, &value).await?;
+        Ok(())
+    }
+
+    /// Wipe all memory data (for testing/cleanup)
+    pub async fn wipe_all(&self) -> Result<()> {
+        let prefixes = vec![
+            "memory:session:",
+            "memory:command:",
+            "memory:output:",
+            "memory:error:",
+            "memory:insight:",
+            "memory:suggestion:",
+            "memory:provenance:",
+            "memory:event:",
+        ];
+
+        for prefix in prefixes {
+            let keys = self.client.list(prefix).await?;
+            for key in keys {
+                self.client.delete(&key).await?;
+            }
+        }
+
+        Ok(())
+    }
+}

package/src-tauri/src/memory/client.rs

@@ -0,0 +1,156 @@
+// PluresDB HTTP client wrapper
+// Communicates with PluresDB server via HTTP API
+//
+// NOTE: The HTTP API endpoints used here are placeholders.
+// The actual PluresDB HTTP API may differ. Adjust endpoints
+// based on the actual PluresDB server API documentation.
+// Alternatively, consider using a Rust FFI binding to PluresDB
+// if available, or the SQLiteCompatibleAPI via FFI.
+
+use anyhow::{Context, Result};
+use reqwest::Client;
+use serde_json::Value;
+use std::time::Duration;
+
+pub struct PluresDBClient {
+    client: Client,
+    base_url: String,
+    data_dir: String,
+}
+
+impl PluresDBClient {
+    pub fn new(host: &str, port: u16, data_dir: &str) -> Result<Self> {
+        let base_url = format!("http://{}:{}", host, port);
+
+        let client = Client::builder()
+            .timeout(Duration::from_secs(30))
+            .build()
+            .context("Failed to create HTTP client")?;
+
+        Ok(Self {
+            client,
+            base_url,
+            data_dir: data_dir.to_string(),
+        })
+    }
+
+    /// Put a value into PluresDB
+    pub async fn put(&self, key: &str, value: &Value) -> Result<()> {
+        let url = format!("{}/api/v1/put", self.base_url);
+        let payload = serde_json::json!({
+            "key": key,
+            "value": value,
+        });
+
+        let response = self
+            .client
+            .post(&url)
+            .json(&payload)
+            .send()
+            .await
+            .context("Failed to send PUT request")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            anyhow::bail!("PluresDB PUT failed with status {}: {}", status, text);
+        }
+
+        Ok(())
+    }
+
+    /// Get a value from PluresDB
+    pub async fn get(&self, key: &str) -> Result<Option<Value>> {
+        let url = format!("{}/api/v1/get", self.base_url);
+        let payload = serde_json::json!({
+            "key": key,
+        });
+
+        let response = self
+            .client
+            .post(&url)
+            .json(&payload)
+            .send()
+            .await
+            .context("Failed to send GET request")?;
+
+        if response.status() == 404 {
+            return Ok(None);
+        }
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            anyhow::bail!("PluresDB GET failed with status {}: {}", status, text);
+        }
+
+        let result: Value = response.json().await.context("Failed to parse response")?;
+        Ok(result.get("value").cloned())
+    }
+
+    /// List keys with a prefix
+    pub async fn list(&self, prefix: &str) -> Result<Vec<String>> {
+        let url = format!("{}/api/v1/list", self.base_url);
+        let payload = serde_json::json!({
+            "prefix": prefix,
+        });
+
+        let response = self
+            .client
+            .post(&url)
+            .json(&payload)
+            .send()
+            .await
+            .context("Failed to send LIST request")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            anyhow::bail!("PluresDB LIST failed with status {}: {}", status, text);
+        }
+
+        let result: Value = response.json().await.context("Failed to parse response")?;
+        let keys = result
+            .get("keys")
+            .and_then(|v| v.as_array())
+            .ok_or_else(|| anyhow::anyhow!("Invalid LIST response format"))?;
+
+        Ok(keys
+            .iter()
+            .filter_map(|v| v.as_str().map(|s| s.to_string()))
+            .collect())
+    }
+
+    /// Delete a key
+    pub async fn delete(&self, key: &str) -> Result<()> {
+        let url = format!("{}/api/v1/delete", self.base_url);
+        let payload = serde_json::json!({
+            "key": key,
+        });
+
+        let response = self
+            .client
+            .post(&url)
+            .json(&payload)
+            .send()
+            .await
+            .context("Failed to send DELETE request")?;
+
+        if !response.status().is_success() && response.status() != 404 {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            anyhow::bail!("PluresDB DELETE failed with status {}: {}", status, text);
+        }
+
+        Ok(())
+    }
+
+    /// Check if PluresDB server is available
+    pub async fn health_check(&self) -> Result<bool> {
+        let url = format!("{}/health", self.base_url);
+        match self.client.get(&url).send().await {
+            Ok(response) => Ok(response.status().is_success()),
+            Err(_) => Ok(false),
+        }
+    }
+}

package/src-tauri/src/memory/encryption.rs

@@ -0,0 +1,79 @@
+// Encryption hooks interface for cognitive memory
+// Provides abstraction for encrypting/decrypting stored data
+
+use anyhow::Result;
+use async_trait::async_trait;
+use serde_json::Value;
+
+/// Encryption provider trait
+/// If PluresDB supports encryption natively, use that.
+/// Otherwise, implement this trait for application-level encryption.
+#[async_trait]
+pub trait EncryptionProvider: Send + Sync {
+    /// Encrypt a JSON value
+    async fn encrypt(&self, value: &Value) -> Result<Value>;
+
+    /// Decrypt a JSON value
+    async fn decrypt(&self, value: &Value) -> Result<Value>;
+}
+
+/// No-op encryption provider (for when encryption is disabled)
+pub struct NoOpEncryption;
+
+#[async_trait]
+impl EncryptionProvider for NoOpEncryption {
+    async fn encrypt(&self, value: &Value) -> Result<Value> {
+        Ok(value.clone())
+    }
+
+    async fn decrypt(&self, value: &Value) -> Result<Value> {
+        Ok(value.clone())
+    }
+}
+
+// TODO: Implement AES-256-GCM encryption provider
+// This would use a key derived from user configuration or keychain
+// Example implementation:
+//
+// pub struct Aes256GcmEncryption {
+//     key: [u8; 32],
+// }
+//
+// #[async_trait]
+// impl EncryptionProvider for Aes256GcmEncryption {
+//     async fn encrypt(&self, value: &Value) -> Result<Value> {
+//         // Serialize to JSON string
+//         let json_str = serde_json::to_string(value)?;
+//         // Encrypt using AES-256-GCM
+//         // Return encrypted data as base64-encoded string in JSON
+//         // ...
+//     }
+//
+//     async fn decrypt(&self, value: &Value) -> Result<Value> {
+//         // Extract encrypted data from JSON
+//         // Decrypt using AES-256-GCM
+//         // Deserialize back to JSON Value
+//         // ...
+//     }
+// }
+
+// TODO: Check if PluresDB has native encryption support
+// If yes, create a PluresDBNativeEncryption provider that uses PluresDB's encryption APIs
+// Example:
+//
+// pub struct PluresDBNativeEncryption {
+//     // PluresDB handles encryption internally
+// }
+//
+// #[async_trait]
+// impl EncryptionProvider for PluresDBNativeEncryption {
+//     async fn encrypt(&self, value: &Value) -> Result<Value> {
+//         // PluresDB encrypts automatically, just pass through
+//         Ok(value.clone())
+//     }
+//
+//     async fn decrypt(&self, value: &Value) -> Result<Value> {
+//         // PluresDB decrypts automatically, just pass through
+//         Ok(value.clone())
+//     }
+// }