@plures/runebook 0.4.0

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

@@ -0,0 +1,110 @@
+// Migration and versioning mechanism for schema evolution
+
+use crate::memory::api::MemoryStore;
+use anyhow::{Context, Result};
+use serde_json::Value;
+
+const SCHEMA_VERSION_KEY: &str = "memory:schema:version";
+const CURRENT_SCHEMA_VERSION: u32 = 1;
+
+/// Run all pending migrations
+pub async fn run_migrations(store: &MemoryStore) -> Result<()> {
+    let current_version = get_current_version(store).await?;
+
+    if current_version < CURRENT_SCHEMA_VERSION {
+        // Run migrations sequentially
+        for version in (current_version + 1)..=CURRENT_SCHEMA_VERSION {
+            migrate_to_version(store, version)
+                .await
+                .with_context(|| format!("Failed to migrate to version {}", version))?;
+        }
+
+        // Update version
+        set_version(store, CURRENT_SCHEMA_VERSION).await?;
+    }
+
+    Ok(())
+}
+
+async fn get_current_version(store: &MemoryStore) -> Result<u32> {
+    let client = &store.client;
+
+    match client.get(SCHEMA_VERSION_KEY).await? {
+        Some(value) => {
+            if let Some(version) = value.as_u64() {
+                Ok(version as u32)
+            } else {
+                Ok(0)
+            }
+        }
+        None => Ok(0),
+    }
+}
+
+async fn set_version(store: &MemoryStore, version: u32) -> Result<()> {
+    let client = &store.client;
+    let value = serde_json::json!(version);
+    client.put(SCHEMA_VERSION_KEY, &value).await?;
+    Ok(())
+}
+
+async fn migrate_to_version(store: &MemoryStore, version: u32) -> Result<()> {
+    match version {
+        1 => {
+            // Initial schema version - no migration needed
+            // This is where we would migrate from version 0 to 1
+            Ok(())
+        }
+        _ => {
+            anyhow::bail!("Unknown migration version: {}", version);
+        }
+    }
+}
+
+/// Get migration status
+pub async fn get_migration_status(store: &MemoryStore) -> Result<MigrationStatus> {
+    let current_version = get_current_version(store).await?;
+
+    Ok(MigrationStatus {
+        current_version,
+        target_version: CURRENT_SCHEMA_VERSION,
+        is_up_to_date: current_version >= CURRENT_SCHEMA_VERSION,
+    })
+}
+
+#[derive(Debug, Clone)]
+pub struct MigrationStatus {
+    pub current_version: u32,
+    pub target_version: u32,
+    pub is_up_to_date: bool,
+}
+
+// Future migration examples:
+//
+// async fn migrate_to_version_2(store: &MemoryStore) -> Result<()> {
+//     // Example: Add a new field to all sessions
+//     let keys = store.client.list("memory:session:").await?;
+//     for key in keys {
+//         if let Some(mut value) = store.client.get(&key).await? {
+//             // Add new field
+//             value["new_field"] = serde_json::json!("default_value");
+//             store.client.put(&key, &value).await?;
+//         }
+//     }
+//     Ok(())
+// }
+//
+// async fn migrate_to_version_3(store: &MemoryStore) -> Result<()> {
+//     // Example: Rename a field across all commands
+//     let keys = store.client.list("memory:command:").await?;
+//     for key in keys {
+//         if let Some(mut value) = store.client.get(&key).await? {
+//             if let Some(old_value) = value.get("old_field_name").cloned() {
+//                 value["new_field_name"] = old_value;
+//                 value.as_object_mut().unwrap().remove("old_field_name");
+//                 store.client.put(&key, &value).await?;
+//             }
+//         }
+//     }
+//     Ok(())
+// }

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

@@ -0,0 +1,28 @@
+// PluresDB cognitive memory storage module
+// Local-first "cognitive memory" for terminal events, commands, outputs, errors, insights, and suggestions
+
+pub mod api;
+pub mod client;
+pub mod encryption;
+pub mod migration;
+pub mod schema;
+
+#[cfg(test)]
+mod tests;
+
+pub use api::MemoryStore;
+pub use client::PluresDBClient;
+pub use schema::*;
+
+use anyhow::Result;
+
+/// Initialize the memory store with PluresDB connection
+pub async fn init_memory_store(host: &str, port: u16, data_dir: &str) -> Result<MemoryStore> {
+    let client = PluresDBClient::new(host, port, data_dir)?;
+    let store = MemoryStore::new(client).await?;
+
+    // Run migrations
+    migration::run_migrations(&store).await?;
+
+    Ok(store)
+}

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

@@ -0,0 +1,275 @@
+// Schema definitions for cognitive memory storage
+// Defines tables/collections: sessions, commands, outputs, errors, insights, suggestions, provenance
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// Session metadata - represents a terminal session
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Session {
+    pub id: String,
+    pub started_at: DateTime<Utc>,
+    pub ended_at: Option<DateTime<Utc>>,
+    pub shell_type: String, // bash, zsh, nushell, etc.
+    pub initial_cwd: String,
+    pub hostname: Option<String>,
+    pub user: Option<String>,
+    pub metadata: serde_json::Value, // Additional session metadata
+}
+
+/// Normalized command record
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Command {
+    pub id: String,
+    pub session_id: String,
+    pub command: String, // Normalized command (e.g., "git" not "/usr/bin/git")
+    pub args: Vec<String>,
+    pub env_summary: serde_json::Value, // Sanitized environment variables
+    pub cwd: String,
+    pub started_at: DateTime<Utc>,
+    pub ended_at: Option<DateTime<Utc>>,
+    pub exit_code: Option<i32>,
+    pub success: bool,
+    pub duration_ms: Option<u64>,
+    pub pid: Option<u32>,
+}
+
+/// Output chunk - stdout/stderr output, optionally compressed
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Output {
+    pub id: String,
+    pub command_id: String,
+    pub stream_type: String, // "stdout" or "stderr"
+    pub chunk_index: u32,
+    pub content: Vec<u8>, // Raw bytes (may be compressed)
+    pub compressed: bool, // Whether content is gzip-compressed
+    pub size_bytes: u64,  // Uncompressed size
+    pub timestamp: DateTime<Utc>,
+}
+
+/// Classified error record
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Error {
+    pub id: String,
+    pub command_id: String,
+    pub session_id: String,
+    pub error_type: String, // "exit_code", "stderr", "timeout", "permission", etc.
+    pub severity: String,   // "low", "medium", "high", "critical"
+    pub message: String,
+    pub stderr_snippet: Option<String>, // First 500 chars of stderr
+    pub exit_code: Option<i32>,
+    pub timestamp: DateTime<Utc>,
+    pub context: serde_json::Value, // Additional error context
+}
+
+/// AI/heuristic annotation/insight
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Insight {
+    pub id: String,
+    pub command_id: Option<String>, // Optional: linked to specific command
+    pub session_id: Option<String>, // Optional: linked to specific session
+    pub insight_type: String,       // "pattern", "optimization", "warning", "tip", "correlation"
+    pub title: String,
+    pub description: String,
+    pub confidence: f64, // 0.0 to 1.0
+    pub source: String,  // "heuristic", "ai", "rule", etc.
+    pub generated_at: DateTime<Utc>,
+    pub metadata: serde_json::Value,
+}
+
+/// Ranked suggestion
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Suggestion {
+    pub id: String,
+    pub suggestion_type: String, // "command", "optimization", "shortcut", "warning", "tip"
+    pub priority: String,        // "low", "medium", "high"
+    pub rank: f64,               // Ranking score (higher = more relevant)
+    pub title: String,
+    pub description: String,
+    pub command: Option<String>,   // Suggested command
+    pub args: Option<Vec<String>>, // Suggested arguments
+    pub context: serde_json::Value,
+    pub created_at: DateTime<Utc>,
+    pub dismissed: bool,
+    pub applied: bool,
+}
+
+/// Provenance information - tracks source, confidence, model/tool used
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Provenance {
+    pub id: String,
+    pub entity_type: String, // "command", "output", "error", "insight", "suggestion"
+    pub entity_id: String,
+    pub source: String,          // "terminal", "ai", "heuristic", "user", etc.
+    pub confidence: Option<f64>, // 0.0 to 1.0
+    pub model: Option<String>,   // AI model name if applicable
+    pub tool: Option<String>,    // Tool/function name if applicable
+    pub created_at: DateTime<Utc>,
+    pub metadata: serde_json::Value,
+}
+
+/// Event wrapper for append_event API
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MemoryEvent {
+    pub id: String,
+    pub event_type: String, // "command", "output", "error", "session_start", "session_end"
+    pub timestamp: DateTime<Utc>,
+    pub session_id: String,
+    pub data: serde_json::Value, // Event-specific data
+    pub provenance: Option<Provenance>,
+}
+
+/// Context window for analysis
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ContextWindow {
+    pub session_id: String,
+    pub start_time: DateTime<Utc>,
+    pub end_time: DateTime<Utc>,
+    pub commands: Vec<Command>,
+    pub outputs: Vec<Output>,
+    pub errors: Vec<Error>,
+    pub insights: Vec<Insight>,
+}
+
+impl Session {
+    pub fn new(shell_type: String, initial_cwd: String) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            started_at: Utc::now(),
+            ended_at: None,
+            shell_type,
+            initial_cwd,
+            hostname: None,
+            user: None,
+            metadata: serde_json::json!({}),
+        }
+    }
+}
+
+impl Command {
+    pub fn new(session_id: String, command: String, args: Vec<String>, cwd: String) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            session_id,
+            command,
+            args,
+            env_summary: serde_json::json!({}),
+            cwd,
+            started_at: Utc::now(),
+            ended_at: None,
+            exit_code: None,
+            success: false,
+            duration_ms: None,
+            pid: None,
+        }
+    }
+}
+
+impl Output {
+    pub fn new(
+        command_id: String,
+        stream_type: String,
+        chunk_index: u32,
+        content: Vec<u8>,
+    ) -> Self {
+        let size_bytes = content.len() as u64;
+        Self {
+            id: Uuid::new_v4().to_string(),
+            command_id,
+            stream_type,
+            chunk_index,
+            content,
+            compressed: false,
+            size_bytes,
+            timestamp: Utc::now(),
+        }
+    }
+}
+
+impl Error {
+    pub fn new(
+        command_id: String,
+        session_id: String,
+        error_type: String,
+        severity: String,
+        message: String,
+    ) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            command_id,
+            session_id,
+            error_type,
+            severity,
+            message,
+            stderr_snippet: None,
+            exit_code: None,
+            timestamp: Utc::now(),
+            context: serde_json::json!({}),
+        }
+    }
+}
+
+impl Insight {
+    pub fn new(
+        insight_type: String,
+        title: String,
+        description: String,
+        confidence: f64,
+        source: String,
+    ) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            command_id: None,
+            session_id: None,
+            insight_type,
+            title,
+            description,
+            confidence,
+            source,
+            generated_at: Utc::now(),
+            metadata: serde_json::json!({}),
+        }
+    }
+}
+
+impl Suggestion {
+    pub fn new(
+        suggestion_type: String,
+        priority: String,
+        rank: f64,
+        title: String,
+        description: String,
+    ) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            suggestion_type,
+            priority,
+            rank,
+            title,
+            description,
+            command: None,
+            args: None,
+            context: serde_json::json!({}),
+            created_at: Utc::now(),
+            dismissed: false,
+            applied: false,
+        }
+    }
+}
+
+impl Provenance {
+    pub fn new(entity_type: String, entity_id: String, source: String) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            entity_type,
+            entity_id,
+            source,
+            confidence: None,
+            model: None,
+            tool: None,
+            created_at: Utc::now(),
+            metadata: serde_json::json!({}),
+        }
+    }
+}

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

@@ -0,0 +1,192 @@
+// Tests for cognitive memory storage
+// Property tests and integration tests
+
+#[cfg(test)]
+mod tests {
+    use crate::memory::api::MemoryStore;
+    use crate::memory::client::PluresDBClient;
+    use crate::memory::migration;
+    use crate::memory::schema::*;
+    use crate::memory::*;
+    use chrono::Duration as ChronoDuration;
+    use chrono::Utc;
+
+    // Integration test: store events then query
+    #[tokio::test]
+    async fn test_store_and_query_events() {
+        // This test requires a PluresDB server running
+        // Skip if server is not available
+        let client = match PluresDBClient::new("localhost", 34567, "./test-pluresdb-data") {
+            Ok(c) => c,
+            Err(_) => {
+                eprintln!("Skipping test: PluresDB server not available");
+                return;
+            }
+        };
+
+        // Check if server is available
+        if !client.health_check().await.unwrap_or(false) {
+            eprintln!("Skipping test: PluresDB server not responding");
+            return;
+        }
+
+        let store = MemoryStore::new(client).await.unwrap();
+
+        // Create a test session
+        let session = Session::new("bash".to_string(), "/tmp".to_string());
+        let session_key = format!("memory:session:{}", session.id);
+        store
+            .client
+            .put(&session_key, &serde_json::to_value(&session).unwrap())
+            .await
+            .unwrap();
+
+        // Create a test command
+        let mut command = Command::new(
+            session.id.clone(),
+            "echo".to_string(),
+            vec!["hello".to_string()],
+            "/tmp".to_string(),
+        );
+        command.exit_code = Some(0);
+        command.success = true;
+        command.ended_at = Some(Utc::now());
+        command.duration_ms = Some(100);
+
+        store.store_command(command.clone()).await.unwrap();
+
+        // Create a test error
+        let error = Error::new(
+            command.id.clone(),
+            session.id.clone(),
+            "exit_code".to_string(),
+            "low".to_string(),
+            "Test error".to_string(),
+        );
+        store.store_error(error.clone()).await.unwrap();
+
+        // Query recent errors
+        let errors = store
+            .query_recent_errors(Some(10), None, None)
+            .await
+            .unwrap();
+        assert!(errors.len() > 0);
+        assert!(errors.iter().any(|e| e.id == error.id));
+
+        // Get context window
+        let context = store
+            .get_context(&session.id, ChronoDuration::hours(1))
+            .await
+            .unwrap();
+        assert_eq!(context.session_id, session.id);
+        assert!(context.commands.len() > 0);
+        assert!(context.errors.len() > 0);
+
+        // List sessions
+        let sessions = store.list_sessions().await.unwrap();
+        assert!(sessions.iter().any(|s| s.id == session.id));
+
+        // Cleanup
+        store.wipe_all().await.unwrap();
+    }
+
+    // Property test: schema roundtrip
+    #[tokio::test]
+    async fn test_schema_roundtrip() {
+        let client = match PluresDBClient::new("localhost", 34567, "./test-pluresdb-data") {
+            Ok(c) => c,
+            Err(_) => {
+                eprintln!("Skipping test: PluresDB server not available");
+                return;
+            }
+        };
+
+        if !client.health_check().await.unwrap_or(false) {
+            eprintln!("Skipping test: PluresDB server not responding");
+            return;
+        }
+
+        let store = MemoryStore::new(client).await.unwrap();
+
+        // Test Session roundtrip
+        let session = Session::new("zsh".to_string(), "/home/user".to_string());
+        let session_key = format!("memory:session:{}", session.id);
+        store
+            .client
+            .put(&session_key, &serde_json::to_value(&session).unwrap())
+            .await
+            .unwrap();
+
+        let retrieved_value = store.client.get(&session_key).await.unwrap().unwrap();
+        let retrieved: Session = serde_json::from_value(retrieved_value).unwrap();
+        assert_eq!(session.id, retrieved.id);
+        assert_eq!(session.shell_type, retrieved.shell_type);
+        assert_eq!(session.initial_cwd, retrieved.initial_cwd);
+
+        // Test Command roundtrip
+        let command = Command::new(
+            session.id.clone(),
+            "ls".to_string(),
+            vec!["-la".to_string()],
+            "/home/user".to_string(),
+        );
+        let command_key = format!("memory:command:{}", command.id);
+        store
+            .client
+            .put(&command_key, &serde_json::to_value(&command).unwrap())
+            .await
+            .unwrap();
+
+        let retrieved_value = store.client.get(&command_key).await.unwrap().unwrap();
+        let retrieved: Command = serde_json::from_value(retrieved_value).unwrap();
+        assert_eq!(command.id, retrieved.id);
+        assert_eq!(command.command, retrieved.command);
+        assert_eq!(command.args, retrieved.args);
+
+        // Test Suggestion roundtrip
+        let suggestion = Suggestion::new(
+            "tip".to_string(),
+            "medium".to_string(),
+            0.8,
+            "Test Tip".to_string(),
+            "This is a test suggestion".to_string(),
+        );
+        store.persist_suggestion(suggestion.clone()).await.unwrap();
+
+        let suggestions = store.get_suggestions(None, None).await.unwrap();
+        assert!(suggestions.iter().any(|s| s.id == suggestion.id));
+
+        // Cleanup
+        store.wipe_all().await.unwrap();
+    }
+
+    // Test migration system
+    #[tokio::test]
+    async fn test_migrations() {
+        let client = match PluresDBClient::new("localhost", 34567, "./test-pluresdb-data") {
+            Ok(c) => c,
+            Err(_) => {
+                eprintln!("Skipping test: PluresDB server not available");
+                return;
+            }
+        };
+
+        if !client.health_check().await.unwrap_or(false) {
+            eprintln!("Skipping test: PluresDB server not responding");
+            return;
+        }
+
+        let store = MemoryStore::new(client).await.unwrap();
+
+        // Run migrations
+        migration::run_migrations(&store).await.unwrap();
+
+        // Check migration status
+        let status = migration::get_migration_status(&store).await.unwrap();
+        assert!(status.is_up_to_date);
+        assert_eq!(status.target_version, status.current_version);
+
+        // Cleanup
+        store.wipe_all().await.unwrap();
+    }
+}