@plures/runebook 0.4.0

package/src-tauri/src/orchestrator/coordinator.rs

@@ -0,0 +1,232 @@
+//! Parallel execution coordinator.
+
+use crate::core::coordination::{ApiRegistry, CoordinationChannel, CoordinationHandle};
+use crate::core::ownership::OwnershipManager;
+use crate::core::types::*;
+use std::collections::HashMap;
+use tokio::sync::RwLock;
+
+/// Coordinates parallel agent execution
+pub struct ExecutionCoordinator {
+    plan: ExecutionPlan,
+    ownership: OwnershipManager,
+    api_registry: ApiRegistry,
+    agent_status: HashMap<AgentId, AgentStatus>,
+    coordination: CoordinationChannel,
+    coordination_handle: CoordinationHandle,
+}
+
+impl ExecutionCoordinator {
+    pub fn new(plan: ExecutionPlan) -> (Self, CoordinationHandle) {
+        let (coordination, coordination_handle) = CoordinationChannel::new();
+
+        // Initialize ownership manager
+        let mut ownership = OwnershipManager::new();
+        for file_ownership in &plan.file_ownership {
+            ownership.register(file_ownership.clone());
+        }
+
+        // Initialize agent status
+        let mut agent_status = HashMap::new();
+        agent_status.insert(AgentId::Orchestrator, AgentStatus::Running);
+        agent_status.insert(AgentId::Agent1, AgentStatus::Pending);
+        agent_status.insert(AgentId::Agent2, AgentStatus::Pending);
+        agent_status.insert(
+            AgentId::Agent3,
+            AgentStatus::WaitingForDependency(AgentId::Agent2),
+        );
+        agent_status.insert(
+            AgentId::Agent4,
+            AgentStatus::WaitingForDependency(AgentId::Agent3),
+        );
+        agent_status.insert(AgentId::Agent5, AgentStatus::Pending);
+        agent_status.insert(AgentId::Agent6, AgentStatus::Pending);
+
+        let coordinator = Self {
+            plan,
+            ownership,
+            api_registry: ApiRegistry::new(),
+            agent_status,
+            coordination,
+            coordination_handle: coordination_handle.clone(),
+        };
+
+        (coordinator, coordination_handle)
+    }
+
+    /// Process coordination messages and update agent status
+    pub async fn process_coordination(&mut self) -> Result<(), String> {
+        while let Some(message) = self.coordination.try_recv() {
+            match message {
+                CoordinationMessage::AgentReady(agent) => {
+                    self.handle_agent_ready(agent).await?;
+                }
+                CoordinationMessage::ApiPublished(api) => {
+                    self.handle_api_published(api).await?;
+                }
+                CoordinationMessage::TaskCompleted(agent, task_id) => {
+                    self.handle_task_completed(agent, task_id).await?;
+                }
+                CoordinationMessage::CoordinationRequest {
+                    requester,
+                    target_agent,
+                    target_module,
+                    reason,
+                } => {
+                    self.handle_coordination_request(
+                        requester,
+                        target_agent,
+                        target_module,
+                        reason,
+                    )
+                    .await?;
+                }
+                CoordinationMessage::StatusUpdate(agent, status) => {
+                    self.agent_status.insert(agent, status);
+                }
+                CoordinationMessage::CoordinationResponse { .. } => {
+                    // Handle response (for future async coordination)
+                }
+            }
+        }
+        Ok(())
+    }
+
+    async fn handle_agent_ready(&mut self, agent: AgentId) -> Result<(), String> {
+        // Check if agent can start based on dependencies
+        let can_start = self.can_agent_start(agent);
+
+        if can_start {
+            self.agent_status.insert(agent, AgentStatus::Running);
+            log::info!("Agent {:?} started", agent);
+        } else {
+            let dependency = self.get_blocking_dependency(agent);
+            self.agent_status
+                .insert(agent, AgentStatus::WaitingForDependency(dependency));
+            log::info!("Agent {:?} waiting for dependency {:?}", agent, dependency);
+        }
+        Ok(())
+    }
+
+    async fn handle_api_published(&mut self, api: ApiPublished) -> Result<(), String> {
+        self.api_registry.register(api.clone());
+
+        // Check if Agent 3 can start now (depends on Agent 2 APIs)
+        if api.agent == AgentId::Agent2 {
+            if let Some(status) = self.agent_status.get_mut(&AgentId::Agent3) {
+                if matches!(status, AgentStatus::WaitingForDependency(AgentId::Agent2)) {
+                    *status = AgentStatus::Pending;
+                    log::info!("Agent 3 can now start (Agent 2 API published)");
+                }
+            }
+        }
+
+        log::info!("API published: {} by {:?}", api.api_name, api.agent);
+        Ok(())
+    }
+
+    async fn handle_task_completed(
+        &mut self,
+        agent: AgentId,
+        task_id: String,
+    ) -> Result<(), String> {
+        // Update task status in plan
+        if let Some(task) = self.plan.tasks.iter_mut().find(|t| t.id == task_id) {
+            task.status = TaskStatus::Completed;
+        }
+
+        // Check if Agent 4 can start (depends on Agent 3 writing suggestions)
+        if agent == AgentId::Agent3 && task_id == "agent3-2" {
+            if let Some(status) = self.agent_status.get_mut(&AgentId::Agent4) {
+                if matches!(status, AgentStatus::WaitingForDependency(AgentId::Agent3)) {
+                    *status = AgentStatus::Pending;
+                    log::info!("Agent 4 can now start (Agent 3 suggestions written)");
+                }
+            }
+        }
+
+        log::info!("Task completed: {} by {:?}", task_id, agent);
+        Ok(())
+    }
+
+    async fn handle_coordination_request(
+        &mut self,
+        requester: AgentId,
+        target_agent: AgentId,
+        target_module: String,
+        reason: String,
+    ) -> Result<(), String> {
+        // Check ownership
+        if let Some(owner) = self.ownership.get_owner(&target_module) {
+            if owner == requester {
+                // Agent owns the module, no coordination needed
+                return Ok(());
+            }
+
+            // Check if modification is allowed
+            if !self.ownership.can_modify(requester, &target_module) {
+                log::warn!(
+                    "Coordination request denied: {:?} cannot modify {} (owned by {:?})",
+                    requester,
+                    target_module,
+                    owner
+                );
+                return Err(format!(
+                    "Agent {:?} does not own module {}",
+                    owner, target_module
+                ));
+            }
+        }
+
+        log::info!(
+            "Coordination request: {:?} wants to modify {} (owned by {:?}): {}",
+            requester,
+            target_module,
+            target_agent,
+            reason
+        );
+        // In a real implementation, this would notify the target agent
+        Ok(())
+    }
+
+    fn can_agent_start(&self, agent: AgentId) -> bool {
+        match agent {
+            AgentId::Orchestrator => true,
+            AgentId::Agent1 | AgentId::Agent2 | AgentId::Agent5 | AgentId::Agent6 => {
+                // These can start after orchestrator
+                self.agent_status
+                    .get(&AgentId::Orchestrator)
+                    .map(|s| matches!(s, AgentStatus::Running | AgentStatus::Completed))
+                    .unwrap_or(false)
+            }
+            AgentId::Agent3 => {
+                // Agent 3 needs Agent 2 APIs
+                self.api_registry.get_agent_apis(AgentId::Agent2).len() > 0
+            }
+            AgentId::Agent4 => {
+                // Agent 4 needs Agent 3 to write suggestions
+                // Check if agent3-2 task is completed
+                self.plan
+                    .tasks
+                    .iter()
+                    .any(|t| t.id == "agent3-2" && t.status == TaskStatus::Completed)
+            }
+        }
+    }
+
+    fn get_blocking_dependency(&self, agent: AgentId) -> AgentId {
+        match agent {
+            AgentId::Agent3 => AgentId::Agent2,
+            AgentId::Agent4 => AgentId::Agent3,
+            _ => AgentId::Orchestrator,
+        }
+    }
+
+    pub fn get_agent_status(&self, agent: AgentId) -> Option<&AgentStatus> {
+        self.agent_status.get(&agent)
+    }
+
+    pub fn get_plan(&self) -> &ExecutionPlan {
+        &self.plan
+    }
+}

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

@@ -0,0 +1,13 @@
+//! Orchestrator for parallel agent execution.
+//!
+//! The orchestrator:
+//! 1. Creates roadmap and task breakdown
+//! 2. Stubs interfaces
+//! 3. Assigns file ownership boundaries
+//! 4. Coordinates agent execution
+
+pub mod coordinator;
+pub mod planner;
+
+pub use coordinator::*;
+pub use planner::*;

package/src-tauri/src/orchestrator/planner.rs

@@ -0,0 +1,304 @@
+//! Execution plan creation and task breakdown.
+
+use crate::core::types::*;
+
+/// Creates the execution plan with roadmap, tasks, interfaces, and ownership
+pub fn create_execution_plan() -> ExecutionPlan {
+    let roadmap = create_roadmap();
+    let tasks = create_task_breakdown();
+    let interfaces = create_interface_stubs();
+    let file_ownership = create_file_ownership();
+
+    ExecutionPlan {
+        roadmap,
+        tasks,
+        interfaces,
+        file_ownership,
+        created_at: chrono::Utc::now(),
+    }
+}
+
+fn create_roadmap() -> Vec<RoadmapItem> {
+    vec![
+        RoadmapItem {
+            phase: "phase-1-orchestration".to_string(),
+            description:
+                "Orchestrator creates roadmap, task breakdown, stubs interfaces, assigns ownership"
+                    .to_string(),
+            agents: vec![AgentId::Orchestrator],
+            dependencies: vec![],
+        },
+        RoadmapItem {
+            phase: "phase-2-parallel-agents".to_string(),
+            description: "Agent 1 (event capture) and Agent 2 (storage APIs) run in parallel"
+                .to_string(),
+            agents: vec![AgentId::Agent1, AgentId::Agent2],
+            dependencies: vec!["phase-1-orchestration".to_string()],
+        },
+        RoadmapItem {
+            phase: "phase-3-analysis".to_string(),
+            description: "Agent 3 (analysis pipeline) starts after Agent 2 publishes APIs"
+                .to_string(),
+            agents: vec![AgentId::Agent3],
+            dependencies: vec!["phase-2-parallel-agents".to_string()],
+        },
+        RoadmapItem {
+            phase: "phase-4-surfaces".to_string(),
+            description: "Agent 4 (surfaces) starts after Agent 3 writes suggestions to store"
+                .to_string(),
+            agents: vec![AgentId::Agent4],
+            dependencies: vec!["phase-3-analysis".to_string()],
+        },
+        RoadmapItem {
+            phase: "phase-5-continuous".to_string(),
+            description: "Agent 5 (nix + CI) and Agent 6 (finalization) run continuously"
+                .to_string(),
+            agents: vec![AgentId::Agent5, AgentId::Agent6],
+            dependencies: vec!["phase-1-orchestration".to_string()],
+        },
+    ]
+}
+
+fn create_task_breakdown() -> Vec<Task> {
+    vec![
+        // Orchestrator tasks
+        Task {
+            id: "orch-1".to_string(),
+            description: "Create roadmap and task breakdown".to_string(),
+            owner: AgentId::Orchestrator,
+            dependencies: vec![],
+            status: TaskStatus::NotStarted,
+        },
+        Task {
+            id: "orch-2".to_string(),
+            description: "Stub all interfaces".to_string(),
+            owner: AgentId::Orchestrator,
+            dependencies: vec![],
+            status: TaskStatus::NotStarted,
+        },
+        Task {
+            id: "orch-3".to_string(),
+            description: "Assign file ownership boundaries".to_string(),
+            owner: AgentId::Orchestrator,
+            dependencies: vec![],
+            status: TaskStatus::NotStarted,
+        },
+        // Agent 1 tasks
+        Task {
+            id: "agent1-1".to_string(),
+            description: "Implement event capture system".to_string(),
+            owner: AgentId::Agent1,
+            dependencies: vec![AgentId::Orchestrator],
+            status: TaskStatus::NotStarted,
+        },
+        // Agent 2 tasks
+        Task {
+            id: "agent2-1".to_string(),
+            description: "Implement storage APIs".to_string(),
+            owner: AgentId::Agent2,
+            dependencies: vec![AgentId::Orchestrator],
+            status: TaskStatus::NotStarted,
+        },
+        Task {
+            id: "agent2-2".to_string(),
+            description: "Publish storage API interface".to_string(),
+            owner: AgentId::Agent2,
+            dependencies: vec![AgentId::Agent2], // Depends on agent2-1
+            status: TaskStatus::NotStarted,
+        },
+        // Agent 3 tasks
+        Task {
+            id: "agent3-1".to_string(),
+            description: "Implement analysis pipeline".to_string(),
+            owner: AgentId::Agent3,
+            dependencies: vec![AgentId::Agent2], // Waits for Agent 2 APIs
+            status: TaskStatus::NotStarted,
+        },
+        Task {
+            id: "agent3-2".to_string(),
+            description: "Write suggestions to store".to_string(),
+            owner: AgentId::Agent3,
+            dependencies: vec![AgentId::Agent3], // Depends on agent3-1
+            status: TaskStatus::NotStarted,
+        },
+        // Agent 4 tasks
+        Task {
+            id: "agent4-1".to_string(),
+            description: "Implement suggestion surfaces".to_string(),
+            owner: AgentId::Agent4,
+            dependencies: vec![AgentId::Agent3], // Waits for Agent 3 suggestions
+            status: TaskStatus::NotStarted,
+        },
+        // Agent 5 tasks (continuous)
+        Task {
+            id: "agent5-1".to_string(),
+            description: "Set up Nix scaffolding".to_string(),
+            owner: AgentId::Agent5,
+            dependencies: vec![AgentId::Orchestrator],
+            status: TaskStatus::NotStarted,
+        },
+        Task {
+            id: "agent5-2".to_string(),
+            description: "Set up CI scaffolding".to_string(),
+            owner: AgentId::Agent5,
+            dependencies: vec![AgentId::Orchestrator],
+            status: TaskStatus::NotStarted,
+        },
+        // Agent 6 tasks (continuous, finalizes at end)
+        Task {
+            id: "agent6-1".to_string(),
+            description: "Finalize integration and testing".to_string(),
+            owner: AgentId::Agent6,
+            dependencies: vec![AgentId::Orchestrator],
+            status: TaskStatus::NotStarted,
+        },
+    ]
+}
+
+fn create_interface_stubs() -> Vec<InterfaceStub> {
+    vec![
+        // Agent 1 interfaces
+        InterfaceStub {
+            name: "EventCapture".to_string(),
+            module_path: "src/lib/agent/capture.ts".to_string(),
+            owner: AgentId::Agent1,
+            signature: "captureCommandStart(command: string, args: string[], cwd: string): Promise<void>".to_string(),
+            description: "Capture command start event".to_string(),
+        },
+        InterfaceStub {
+            name: "EventCapture".to_string(),
+            module_path: "src/lib/agent/capture.ts".to_string(),
+            owner: AgentId::Agent1,
+            signature: "captureCommandResult(commandId: string, result: CommandResult): Promise<void>".to_string(),
+            description: "Capture command result event".to_string(),
+        },
+        // Agent 2 interfaces
+        InterfaceStub {
+            name: "StorageApi".to_string(),
+            module_path: "src-tauri/src/memory/api.rs".to_string(),
+            owner: AgentId::Agent2,
+            signature: "async fn append_event(event: MemoryEvent) -> Result<()>".to_string(),
+            description: "Append event to storage".to_string(),
+        },
+        InterfaceStub {
+            name: "StorageApi".to_string(),
+            module_path: "src-tauri/src/memory/api.rs".to_string(),
+            owner: AgentId::Agent2,
+            signature: "async fn list_sessions() -> Result<Vec<Session>>".to_string(),
+            description: "List all sessions".to_string(),
+        },
+        InterfaceStub {
+            name: "StorageApi".to_string(),
+            module_path: "src-tauri/src/memory/api.rs".to_string(),
+            owner: AgentId::Agent2,
+            signature: "async fn persist_suggestion(suggestion: Suggestion) -> Result<()>".to_string(),
+            description: "Persist suggestion to store".to_string(),
+        },
+        // Agent 3 interfaces
+        InterfaceStub {
+            name: "AnalysisPipeline".to_string(),
+            module_path: "src/lib/agent/analysis-pipeline.ts".to_string(),
+            owner: AgentId::Agent3,
+            signature: "enqueueFailure(commandId: string, events: TerminalObserverEvent[]): Promise<string | null>".to_string(),
+            description: "Enqueue command failure for analysis".to_string(),
+        },
+        // Agent 4 interfaces
+        InterfaceStub {
+            name: "SuggestionSurface".to_string(),
+            module_path: "src/lib/agent/surfaces.ts".to_string(),
+            owner: AgentId::Agent4,
+            signature: "displaySuggestion(suggestion: Suggestion): void".to_string(),
+            description: "Display suggestion on surface".to_string(),
+        },
+    ]
+}
+
+fn create_file_ownership() -> Vec<FileOwnership> {
+    vec![
+        // Core/shared types
+        FileOwnership {
+            path: "src-tauri/src/core".to_string(),
+            owner: AgentId::Orchestrator,
+            description: "Shared types and coordination mechanisms".to_string(),
+            shared: true,
+        },
+        // Agent 1 ownership
+        FileOwnership {
+            path: "src/lib/agent/capture.ts".to_string(),
+            owner: AgentId::Agent1,
+            description: "Event capture implementation".to_string(),
+            shared: false,
+        },
+        FileOwnership {
+            path: "src/lib/core/observer.ts".to_string(),
+            owner: AgentId::Agent1,
+            description: "Terminal observer core".to_string(),
+            shared: false,
+        },
+        // Agent 2 ownership
+        FileOwnership {
+            path: "src-tauri/src/memory".to_string(),
+            owner: AgentId::Agent2,
+            description: "Storage APIs and memory schema".to_string(),
+            shared: false,
+        },
+        // Agent 3 ownership
+        FileOwnership {
+            path: "src/lib/agent/analysis-pipeline.ts".to_string(),
+            owner: AgentId::Agent3,
+            description: "Analysis pipeline implementation".to_string(),
+            shared: false,
+        },
+        FileOwnership {
+            path: "src/lib/agent/analysis-service.ts".to_string(),
+            owner: AgentId::Agent3,
+            description: "Analysis service".to_string(),
+            shared: false,
+        },
+        FileOwnership {
+            path: "src/lib/agent/analyzers".to_string(),
+            owner: AgentId::Agent3,
+            description: "Analysis analyzers".to_string(),
+            shared: false,
+        },
+        // Agent 4 ownership
+        FileOwnership {
+            path: "src/lib/agent/surfaces.ts".to_string(),
+            owner: AgentId::Agent4,
+            description: "Suggestion surfaces implementation".to_string(),
+            shared: false,
+        },
+        FileOwnership {
+            path: "integrations".to_string(),
+            owner: AgentId::Agent4,
+            description: "Integration surfaces (tmux, wezterm, vim, etc.)".to_string(),
+            shared: false,
+        },
+        // Agent 5 ownership
+        FileOwnership {
+            path: "flake.nix".to_string(),
+            owner: AgentId::Agent5,
+            description: "Nix flake configuration".to_string(),
+            shared: false,
+        },
+        FileOwnership {
+            path: "shell.nix".to_string(),
+            owner: AgentId::Agent5,
+            description: "Nix shell environment".to_string(),
+            shared: false,
+        },
+        FileOwnership {
+            path: ".github/workflows".to_string(),
+            owner: AgentId::Agent5,
+            description: "CI/CD workflows".to_string(),
+            shared: false,
+        },
+        // Agent 6 ownership
+        FileOwnership {
+            path: "ValidationChecklist.md".to_string(),
+            owner: AgentId::Agent6,
+            description: "Validation checklist updates".to_string(),
+            shared: false,
+        },
+    ]
+}

package/src-tauri/tauri.conf.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "RuneBook",
+  "version": "0.3.0",
+  "identifier": "com.runebook.app",
+  "build": {
+    "beforeDevCommand": "npm run dev",
+    "devUrl": "http://localhost:1420",
+    "beforeBuildCommand": "npm run build",
+    "frontendDist": "../build"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "RuneBook",
+        "width": 800,
+        "height": 600
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ]
+  }
+}