@plures/runebook 0.4.0

package/src-tauri/src/core/coordination.rs

@@ -0,0 +1,117 @@
+//! Coordination mechanisms for agent communication.
+
+use super::types::{AgentId, ApiPublished, CoordinationMessage};
+use std::collections::HashMap;
+use tokio::sync::mpsc;
+
+/// Coordination channel for agent communication
+pub struct CoordinationChannel {
+    sender: mpsc::UnboundedSender<CoordinationMessage>,
+    receiver: mpsc::UnboundedReceiver<CoordinationMessage>,
+}
+
+impl CoordinationChannel {
+    pub fn new() -> (Self, CoordinationHandle) {
+        let (sender, receiver) = mpsc::unbounded_channel();
+        let channel = Self { sender, receiver };
+        let handle = CoordinationHandle {
+            sender: channel.sender.clone(),
+        };
+        (channel, handle)
+    }
+
+    pub async fn recv(&mut self) -> Option<CoordinationMessage> {
+        self.receiver.recv().await
+    }
+
+    pub fn try_recv(&mut self) -> Option<CoordinationMessage> {
+        self.receiver.try_recv().ok()
+    }
+}
+
+/// Handle for sending coordination messages
+#[derive(Clone)]
+pub struct CoordinationHandle {
+    sender: mpsc::UnboundedSender<CoordinationMessage>,
+}
+
+impl CoordinationHandle {
+    pub fn send(&self, message: CoordinationMessage) -> Result<(), String> {
+        self.sender
+            .send(message)
+            .map_err(|e| format!("Channel closed: {}", e))
+    }
+
+    pub fn agent_ready(&self, agent: AgentId) -> Result<(), String> {
+        self.send(CoordinationMessage::AgentReady(agent))
+    }
+
+    pub fn api_published(&self, api: ApiPublished) -> Result<(), String> {
+        self.send(CoordinationMessage::ApiPublished(api))
+    }
+
+    pub fn task_completed(&self, agent: AgentId, task_id: String) -> Result<(), String> {
+        self.send(CoordinationMessage::TaskCompleted(agent, task_id))
+    }
+
+    pub fn status_update(
+        &self,
+        agent: AgentId,
+        status: super::types::AgentStatus,
+    ) -> Result<(), String> {
+        self.send(CoordinationMessage::StatusUpdate(agent, status))
+    }
+
+    pub fn request_coordination(
+        &self,
+        requester: AgentId,
+        target_agent: AgentId,
+        target_module: String,
+        reason: String,
+    ) -> Result<(), String> {
+        self.send(CoordinationMessage::CoordinationRequest {
+            requester,
+            target_agent,
+            target_module,
+            reason,
+        })
+    }
+}
+
+/// API registry for tracking published APIs
+pub struct ApiRegistry {
+    apis: HashMap<String, ApiPublished>,
+}
+
+impl ApiRegistry {
+    pub fn new() -> Self {
+        Self {
+            apis: HashMap::new(),
+        }
+    }
+
+    pub fn register(&mut self, api: ApiPublished) {
+        self.apis.insert(api.api_name.clone(), api);
+    }
+
+    pub fn is_published(&self, api_name: &str) -> bool {
+        self.apis.contains_key(api_name)
+    }
+
+    pub fn get_api(&self, api_name: &str) -> Option<&ApiPublished> {
+        self.apis.get(api_name)
+    }
+
+    pub fn get_agent_apis(&self, agent: AgentId) -> Vec<&ApiPublished> {
+        self.apis
+            .values()
+            .filter(|api| api.agent == agent)
+            .collect()
+    }
+}
+
+impl Default for ApiRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}

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

@@ -0,0 +1,12 @@
+//! Shared types and interfaces for the RuneBook parallel execution system.
+//!
+//! This module contains types that are shared across all agents and the orchestrator.
+//! All shared types should be defined here to avoid circular dependencies.
+
+pub mod coordination;
+pub mod ownership;
+pub mod types;
+
+pub use coordination::*;
+pub use ownership::*;
+pub use types::*;

package/src-tauri/src/core/ownership.rs

@@ -0,0 +1,61 @@
+//! File ownership boundaries and coordination rules.
+
+use super::types::{AgentId, FileOwnership};
+use std::collections::HashMap;
+
+/// Manages file ownership boundaries
+pub struct OwnershipManager {
+    ownership_map: HashMap<String, FileOwnership>,
+}
+
+impl OwnershipManager {
+    pub fn new() -> Self {
+        Self {
+            ownership_map: HashMap::new(),
+        }
+    }
+
+    /// Register file ownership
+    pub fn register(&mut self, ownership: FileOwnership) {
+        self.ownership_map.insert(ownership.path.clone(), ownership);
+    }
+
+    /// Check if an agent can modify a file
+    pub fn can_modify(&self, agent: AgentId, path: &str) -> bool {
+        if let Some(ownership) = self.ownership_map.get(path) {
+            ownership.owner == agent || (ownership.shared && ownership.owner == agent)
+        } else {
+            // If not registered, allow (for now - orchestrator should register all)
+            true
+        }
+    }
+
+    /// Check if an agent can read a file
+    pub fn can_read(&self, _agent: AgentId, path: &str) -> bool {
+        // All agents can read shared files
+        if let Some(ownership) = self.ownership_map.get(path) {
+            ownership.shared || true // For now, allow all reads
+        } else {
+            true
+        }
+    }
+
+    /// Get owner of a file
+    pub fn get_owner(&self, path: &str) -> Option<AgentId> {
+        self.ownership_map.get(path).map(|o| o.owner)
+    }
+
+    /// Get all files owned by an agent
+    pub fn get_agent_files(&self, agent: AgentId) -> Vec<&FileOwnership> {
+        self.ownership_map
+            .values()
+            .filter(|o| o.owner == agent)
+            .collect()
+    }
+}
+
+impl Default for OwnershipManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/src-tauri/src/core/types.rs

@@ -0,0 +1,132 @@
+//! Shared types for the parallel execution system.
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Agent identifier
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum AgentId {
+    Orchestrator,
+    Agent1, // Event capture
+    Agent2, // Storage APIs
+    Agent3, // Analysis pipeline
+    Agent4, // Surfaces
+    Agent5, // Nix + CI scaffolding
+    Agent6, // Finalization
+}
+
+impl AgentId {
+    pub fn name(&self) -> &'static str {
+        match self {
+            AgentId::Orchestrator => "orchestrator",
+            AgentId::Agent1 => "agent1-event-capture",
+            AgentId::Agent2 => "agent2-storage-apis",
+            AgentId::Agent3 => "agent3-analysis-pipeline",
+            AgentId::Agent4 => "agent4-surfaces",
+            AgentId::Agent5 => "agent5-nix-ci",
+            AgentId::Agent6 => "agent6-finalization",
+        }
+    }
+}
+
+/// Agent execution status
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AgentStatus {
+    Pending,
+    Running,
+    WaitingForDependency(AgentId),
+    Completed,
+    Failed(String),
+}
+
+/// Task breakdown item
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Task {
+    pub id: String,
+    pub description: String,
+    pub owner: AgentId,
+    pub dependencies: Vec<AgentId>,
+    pub status: TaskStatus,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TaskStatus {
+    NotStarted,
+    InProgress,
+    Completed,
+    Blocked(String),
+}
+
+/// Roadmap item
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RoadmapItem {
+    pub phase: String,
+    pub description: String,
+    pub agents: Vec<AgentId>,
+    pub dependencies: Vec<String>, // Phase IDs
+}
+
+/// Interface stub definition
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InterfaceStub {
+    pub name: String,
+    pub module_path: String,
+    pub owner: AgentId,
+    pub signature: String,
+    pub description: String,
+}
+
+/// File ownership boundary
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileOwnership {
+    pub path: String,
+    pub owner: AgentId,
+    pub description: String,
+    pub shared: bool, // If true, other agents can read but not modify
+}
+
+/// API publication event
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ApiPublished {
+    pub agent: AgentId,
+    pub api_name: String,
+    pub interface_path: String,
+    pub version: String,
+    pub timestamp: chrono::DateTime<chrono::Utc>,
+}
+
+/// Coordination message
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum CoordinationMessage {
+    /// Agent is ready to start
+    AgentReady(AgentId),
+    /// Agent has published an API
+    ApiPublished(ApiPublished),
+    /// Agent has completed a task
+    TaskCompleted(AgentId, String), // agent, task_id
+    /// Agent needs coordination to modify another agent's module
+    CoordinationRequest {
+        requester: AgentId,
+        target_agent: AgentId,
+        target_module: String,
+        reason: String,
+    },
+    /// Orchestrator approval/rejection
+    CoordinationResponse {
+        request_id: String,
+        approved: bool,
+        reason: Option<String>,
+    },
+    /// Agent status update
+    StatusUpdate(AgentId, AgentStatus),
+}
+
+/// Execution plan
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExecutionPlan {
+    pub roadmap: Vec<RoadmapItem>,
+    pub tasks: Vec<Task>,
+    pub interfaces: Vec<InterfaceStub>,
+    pub file_ownership: Vec<FileOwnership>,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+}

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

@@ -0,0 +1,5 @@
+//! Parallel execution system.
+
+pub mod runner;
+
+pub use runner::*;

package/src-tauri/src/execution/runner.rs

@@ -0,0 +1,143 @@
+//! Parallel execution runner.
+
+use crate::agents::*;
+use crate::core::coordination::CoordinationHandle;
+use crate::core::types::AgentId;
+use crate::orchestrator::{create_execution_plan, ExecutionCoordinator};
+use std::sync::Arc;
+use tokio::sync::{Mutex, RwLock};
+
+/// Runs agents in parallel according to the execution plan
+pub struct ParallelExecutionRunner {
+    coordinator: Arc<RwLock<ExecutionCoordinator>>,
+    coordination_handle: CoordinationHandle,
+    agent1: Arc<Mutex<Agent1>>,
+    agent2: Arc<Mutex<Agent2>>,
+    agent3: Arc<Mutex<Agent3>>,
+    agent4: Arc<Mutex<Agent4>>,
+    agent5: Arc<Mutex<Agent5>>,
+    agent6: Arc<Mutex<Agent6>>,
+}
+
+impl ParallelExecutionRunner {
+    pub fn new() -> (Self, CoordinationHandle) {
+        let plan = create_execution_plan();
+        let (coordinator, coordination_handle) = ExecutionCoordinator::new(plan);
+        let coordinator = Arc::new(RwLock::new(coordinator));
+
+        (
+            Self {
+                coordinator,
+                coordination_handle: coordination_handle.clone(),
+                agent1: Arc::new(Mutex::new(Agent1::new())),
+                agent2: Arc::new(Mutex::new(Agent2::new())),
+                agent3: Arc::new(Mutex::new(Agent3::new())),
+                agent4: Arc::new(Mutex::new(Agent4::new())),
+                agent5: Arc::new(Mutex::new(Agent5::new())),
+                agent6: Arc::new(Mutex::new(Agent6::new())),
+            },
+            coordination_handle,
+        )
+    }
+
+    /// Execute all agents according to the parallel execution plan
+    pub async fn execute(&mut self) -> Result<(), String> {
+        log::info!("Starting parallel execution...");
+
+        // Phase 1: Orchestrator (already done via create_execution_plan)
+        log::info!("Phase 1: Orchestrator completed (roadmap, tasks, interfaces, ownership)");
+
+        // Phase 2: Agent 1 and Agent 2 run in parallel
+        log::info!("Phase 2: Starting Agent 1 and Agent 2 in parallel...");
+        let agent1_handle = {
+            let agent = Arc::clone(&self.agent1);
+            let handle = self.coordination_handle.clone();
+            tokio::spawn(async move {
+                let mut agent = agent.lock().await;
+                agent.initialize(handle.clone()).await?;
+                agent.execute().await
+            })
+        };
+
+        let agent2_handle = {
+            let agent = Arc::clone(&self.agent2);
+            let handle = self.coordination_handle.clone();
+            tokio::spawn(async move {
+                let mut agent = agent.lock().await;
+                agent.initialize(handle.clone()).await?;
+                agent.execute().await
+            })
+        };
+
+        // Wait for both to complete
+        let (result1, result2) = tokio::join!(agent1_handle, agent2_handle);
+        result1.map_err(|e| format!("Agent 1 error: {:?}", e))??;
+        result2.map_err(|e| format!("Agent 2 error: {:?}", e))??;
+
+        // Process coordination messages
+        self.coordinator
+            .write()
+            .await
+            .process_coordination()
+            .await?;
+
+        // Phase 3: Agent 3 starts after Agent 2 publishes APIs
+        log::info!("Phase 3: Starting Agent 3 (after Agent 2 APIs published)...");
+        {
+            let mut agent = self.agent3.lock().await;
+            agent.initialize(self.coordination_handle.clone()).await?;
+            agent.execute().await?;
+        }
+
+        // Process coordination messages
+        self.coordinator
+            .write()
+            .await
+            .process_coordination()
+            .await?;
+
+        // Phase 4: Agent 4 starts after Agent 3 writes suggestions
+        log::info!("Phase 4: Starting Agent 4 (after Agent 3 writes suggestions)...");
+        {
+            let mut agent = self.agent4.lock().await;
+            agent.initialize(self.coordination_handle.clone()).await?;
+            agent.execute().await?;
+        }
+
+        // Phase 5: Agent 5 and Agent 6 run continuously
+        log::info!("Phase 5: Starting Agent 5 and Agent 6 (continuous)...");
+        let agent5_handle = {
+            let agent = Arc::clone(&self.agent5);
+            let handle = self.coordination_handle.clone();
+            tokio::spawn(async move {
+                let mut agent = agent.lock().await;
+                agent.initialize(handle.clone()).await?;
+                agent.execute().await
+            })
+        };
+
+        let agent6_handle = {
+            let agent = Arc::clone(&self.agent6);
+            let handle = self.coordination_handle.clone();
+            tokio::spawn(async move {
+                let mut agent = agent.lock().await;
+                agent.initialize(handle.clone()).await?;
+                agent.execute().await
+            })
+        };
+
+        // Wait for continuous agents (they run in background)
+        let (result5, result6) = tokio::join!(agent5_handle, agent6_handle);
+        result5.map_err(|e| format!("Agent 5 error: {:?}", e))??;
+        result6.map_err(|e| format!("Agent 6 error: {:?}", e))??;
+
+        // Finalize Agent 6
+        {
+            let mut agent = self.agent6.lock().await;
+            agent.finalize().await?;
+        }
+
+        log::info!("Parallel execution completed!");
+        Ok(())
+    }
+}

package/src-tauri/src/lib.rs

@@ -0,0 +1,161 @@
+pub mod agents;
+pub mod core;
+pub mod execution;
+pub mod memory;
+pub mod orchestrator;
+
+use std::collections::HashMap;
+use std::process::Command;
+
+// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
+#[tauri::command]
+fn greet(name: &str) -> String {
+    format!("Hello, {}! You've been greeted from Rust!", name)
+}
+
+#[tauri::command]
+async fn memory_inspect(
+    host: Option<String>,
+    port: Option<u16>,
+    data_dir: Option<String>,
+) -> Result<String, String> {
+    use crate::memory::*;
+
+    let host = host.as_deref().unwrap_or("localhost");
+    let port = port.unwrap_or(34567);
+    let data_dir = data_dir.as_deref().unwrap_or("./pluresdb-data");
+
+    match init_memory_store(host, port, data_dir).await {
+        Ok(store) => {
+            let sessions = store
+                .list_sessions()
+                .await
+                .map_err(|e| format!("Failed to list sessions: {}", e))?;
+            let errors = store
+                .query_recent_errors(Some(10), None, None)
+                .await
+                .map_err(|e| format!("Failed to query errors: {}", e))?;
+            let suggestions = store
+                .get_suggestions(None, Some(10))
+                .await
+                .map_err(|e| format!("Failed to get suggestions: {}", e))?;
+
+            let mut output = String::new();
+            output.push_str("=== RuneBook Cognitive Memory ===\n\n");
+            output.push_str(&format!("Sessions: {}\n", sessions.len()));
+            output.push_str(&format!("Recent Errors: {}\n", errors.len()));
+            output.push_str(&format!("Active Suggestions: {}\n\n", suggestions.len()));
+
+            if !sessions.is_empty() {
+                output.push_str("=== Recent Sessions ===\n");
+                for session in sessions.iter().take(5) {
+                    output.push_str(&format!(
+                        "  {} - {} (started: {})\n",
+                        session.id,
+                        session.shell_type,
+                        session.started_at.format("%Y-%m-%d %H:%M:%S")
+                    ));
+                }
+                output.push_str("\n");
+            }
+
+            if !errors.is_empty() {
+                output.push_str("=== Recent Errors ===\n");
+                for error in errors.iter().take(5) {
+                    output.push_str(&format!(
+                        "  [{}] {} - {}\n",
+                        error.severity, error.error_type, error.message
+                    ));
+                }
+                output.push_str("\n");
+            }
+
+            if !suggestions.is_empty() {
+                output.push_str("=== Top Suggestions ===\n");
+                for suggestion in suggestions.iter().take(5) {
+                    output.push_str(&format!(
+                        "  [{}] {} - {}\n",
+                        suggestion.priority, suggestion.title, suggestion.description
+                    ));
+                }
+            }
+
+            Ok(output)
+        }
+        Err(e) => Err(format!("Failed to initialize memory store: {}", e)),
+    }
+}
+
+#[tauri::command]
+async fn execute_terminal_command(
+    command: String,
+    args: Vec<String>,
+    env: HashMap<String, String>,
+    cwd: String,
+) -> Result<String, String> {
+    // Basic input validation to prevent common issues
+    if command.trim().is_empty() {
+        return Err("Command cannot be empty".to_string());
+    }
+
+    // Prevent command chaining attacks via common shell operators
+    let dangerous_chars = ['|', ';', '&', '>', '<', '`', '$', '(', ')'];
+    if command.chars().any(|c| dangerous_chars.contains(&c)) {
+        return Err("Command contains potentially dangerous characters. RuneBook executes commands directly without shell interpretation for security.".to_string());
+    }
+
+    // Validate environment variable keys (no special chars)
+    for key in env.keys() {
+        if !key.chars().all(|c| c.is_alphanumeric() || c == '_') {
+            return Err(format!("Invalid environment variable name: {}", key));
+        }
+    }
+
+    // Note: This executes the command directly without a shell, which prevents
+    // shell injection attacks. Command::new does not interpret shell syntax.
+    let mut cmd = Command::new(&command);
+
+    // Add arguments - each arg is passed as-is, not interpreted by a shell
+    cmd.args(&args);
+
+    // Add environment variables
+    for (key, value) in env {
+        cmd.env(key, value);
+    }
+
+    // Set working directory if provided
+    if !cwd.is_empty() {
+        cmd.current_dir(&cwd);
+    }
+
+    // Execute command
+    match cmd.output() {
+        Ok(output) => {
+            let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+            let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+            if output.status.success() {
+                Ok(stdout)
+            } else {
+                Err(format!("Command failed: {}\n{}", stderr, stdout))
+            }
+        }
+        Err(e) => Err(format!("Failed to execute command: {}", e)),
+    }
+}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    // Initialize logger (ignore error if already initialized)
+    let _ = env_logger::try_init();
+
+    tauri::Builder::default()
+        .plugin(tauri_plugin_opener::init())
+        .invoke_handler(tauri::generate_handler![
+            greet,
+            execute_terminal_command,
+            memory_inspect
+        ])
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}

package/src-tauri/src/main.rs

@@ -0,0 +1,6 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    runebook_lib::run()
+}