first pass of swarm start fixes

Author: odgrim

src/cli/commands/swarm.rs

@@ -6,7 +6,7 @@ use crate::application::{
     agent_executor::AgentExecutor, resource_monitor::ResourceMonitor,
     task_coordinator::TaskCoordinator, SwarmOrchestrator,
 };
-use crate::cli::service::{SwarmService, TaskQueueService};
+use crate::cli::service::{SwarmService, TaskQueueServiceAdapter};
 use crate::infrastructure::claude::{ClaudeClientAdapter, ClaudeClientConfig};
 use crate::infrastructure::config::ConfigLoader;
 use crate::infrastructure::database::{AgentRepositoryImpl, TaskRepositoryImpl};
@@ -20,7 +20,7 @@ use std::sync::Arc;
 ///
 /// Starts the swarm orchestrator with the specified maximum number of agents.
 pub async fn handle_start(
-    _task_service: &TaskQueueService,
+    _task_service: &TaskQueueServiceAdapter,
     max_agents: usize,
     json_output: bool,
 ) -> Result<()> {
@@ -38,12 +38,15 @@ pub async fn handle_start(
                     "status": "started",
                     "max_agents": max_agents,
                     "message": "Swarm orchestrator started successfully",
-                    "database_initialized": db_initialized
+                    "database_initialized": db_initialized,
+                    "log_file": ".abathur/swarm_daemon.log"
                 });
                 println!("{}", serde_json::to_string_pretty(&output)?);
             } else {
                 println!("Starting swarm orchestrator with {} max agents...", max_agents);
                 println!("Swarm orchestrator started successfully");
+                println!();
+                println!("Daemon logs are written to: .abathur/swarm_daemon.log");
                 if !db_initialized {
                     println!();
                     println!("Note: Full orchestration requires database setup.");
@@ -56,12 +59,15 @@ pub async fn handle_start(
             if json_output {
                 let output = json!({
                     "status": "error",
-                    "message": format!("{}", e)
+                    "message": format!("{}", e),
+                    "log_file": ".abathur/swarm_daemon.log"
                 });
                 println!("{}", serde_json::to_string_pretty(&output)?);
             } else {
                 println!("Failed to start swarm orchestrator: {}", e);
                 println!();
+                println!("Check logs at: .abathur/swarm_daemon.log");
+                println!();
                 println!("To enable full swarm functionality:");
                 println!("  1. Run 'abathur init' to initialize Abathur");
                 println!("  2. Ensure ANTHROPIC_API_KEY environment variable is set");
@@ -75,7 +81,7 @@ pub async fn handle_start(
 ///
 /// Gracefully stops the swarm orchestrator.
 pub async fn handle_stop(
-    _task_service: &TaskQueueService,
+    _task_service: &TaskQueueServiceAdapter,
     json_output: bool,
 ) -> Result<()> {
     let swarm_service = SwarmService::new();
@@ -113,15 +119,15 @@ pub async fn handle_stop(
 ///
 /// Shows the current status of the swarm orchestrator.
 pub async fn handle_status(
-    task_service: &TaskQueueService,
+    task_service: &TaskQueueServiceAdapter,
     json_output: bool,
 ) -> Result<()> {
     let swarm_service = SwarmService::new();
 
-    // Get swarm stats
-    let swarm_stats = swarm_service.get_stats().await?;
+    // Get swarm stats (includes task stats from database)
+    let swarm_stats = swarm_service.get_stats(task_service).await?;
 
-    // Get queue stats
+    // Get queue stats for detailed breakdown
     let queue_stats = task_service.get_queue_stats().await?;
 
     if json_output {

src/cli/commands/task.rs

@@ -1,5 +1,4 @@
 use anyhow::{Context, Result};
-use uuid::Uuid;
 
 use crate::cli::models::TaskStatus;
 use crate::cli::output::table::{format_queue_stats_table, format_task_table};
@@ -12,15 +11,25 @@ pub async fn handle_submit(
     agent_type: String,
     summary: Option<String>,
     priority: u8,
-    dependencies: Vec<Uuid>,
+    dependencies: Vec<String>,
     json: bool,
 ) -> Result<()> {
+    // Resolve dependency prefixes to full UUIDs
+    let mut resolved_deps = Vec::new();
+    for dep_prefix in &dependencies {
+        let dep_id = service
+            .resolve_task_id_prefix(dep_prefix)
+            .await
+            .context(format!("Failed to resolve dependency '{}'", dep_prefix))?;
+        resolved_deps.push(dep_id);
+    }
+
     let task_id = service
         .submit_task(
             description.clone(),
             agent_type.clone(),
             priority,
-            dependencies.clone(),
+            resolved_deps.clone(),
         )
         .await
         .context("Failed to submit task")?;
@@ -31,7 +40,7 @@ pub async fn handle_submit(
             "description": description,
             "agent_type": agent_type,
             "priority": priority,
-            "dependencies": dependencies,
+            "dependencies": resolved_deps,
         });
         if let Some(summary_text) = &summary {
             output["summary"] = serde_json::json!(summary_text);
@@ -83,7 +92,13 @@ pub async fn handle_list(
 }
 
 /// Handle task show command
-pub async fn handle_show(service: &TaskQueueServiceAdapter, task_id: Uuid, json: bool) -> Result<()> {
+pub async fn handle_show(service: &TaskQueueServiceAdapter, task_id_prefix: String, json: bool) -> Result<()> {
+    // Resolve task ID prefix
+    let task_id = service
+        .resolve_task_id_prefix(&task_id_prefix)
+        .await
+        .context(format!("Failed to resolve task ID '{}'", task_id_prefix))?;
+
     let task = service
         .get_task(task_id)
         .await
@@ -144,12 +159,12 @@ pub async fn handle_show(service: &TaskQueueServiceAdapter, task_id: Uuid, json:
 /// Handle task update command
 pub async fn handle_update(
     service: &TaskQueueServiceAdapter,
-    task_ids: Vec<Uuid>,
+    task_id_prefixes: Vec<String>,
     status: Option<String>,
     priority: Option<u8>,
     agent_type: Option<String>,
-    add_dependency: Vec<Uuid>,
-    remove_dependency: Vec<Uuid>,
+    add_dependency: Vec<String>,
+    remove_dependency: Vec<String>,
     retry: bool,
     cancel: bool,
     json: bool,
@@ -168,6 +183,35 @@ pub async fn handle_update(
         ));
     }
 
+    // Resolve all task ID prefixes
+    let mut task_ids = Vec::new();
+    for prefix in &task_id_prefixes {
+        let task_id = service
+            .resolve_task_id_prefix(prefix)
+            .await
+            .context(format!("Failed to resolve task ID '{}'", prefix))?;
+        task_ids.push(task_id);
+    }
+
+    // Resolve dependency prefixes
+    let mut resolved_add_deps = Vec::new();
+    for dep_prefix in &add_dependency {
+        let dep_id = service
+            .resolve_task_id_prefix(dep_prefix)
+            .await
+            .context(format!("Failed to resolve add-dependency '{}'", dep_prefix))?;
+        resolved_add_deps.push(dep_id);
+    }
+
+    let mut resolved_remove_deps = Vec::new();
+    for dep_prefix in &remove_dependency {
+        let dep_id = service
+            .resolve_task_id_prefix(dep_prefix)
+            .await
+            .context(format!("Failed to resolve remove-dependency '{}'", dep_prefix))?;
+        resolved_remove_deps.push(dep_id);
+    }
+
     let mut results = Vec::new();
     let mut errors = Vec::new();
 
@@ -179,8 +223,8 @@ pub async fn handle_update(
                 status.as_deref(),
                 priority,
                 agent_type.clone(),
-                add_dependency.clone(),
-                remove_dependency.clone(),
+                resolved_add_deps.clone(),
+                resolved_remove_deps.clone(),
                 retry,
                 cancel,
             )
@@ -238,3 +282,36 @@ pub async fn handle_status(service: &TaskQueueServiceAdapter, json: bool) -> Res
 
     Ok(())
 }
+
+/// Handle task resolve command
+///
+/// Resolves dependencies for all Pending/Blocked tasks and updates them to Ready
+/// if their dependencies are satisfied.
+pub async fn handle_resolve(service: &TaskQueueServiceAdapter, json: bool) -> Result<()> {
+    let count = service
+        .resolve_dependencies()
+        .await
+        .context("Failed to resolve task dependencies")?;
+
+    if json {
+        let output = serde_json::json!({
+            "status": "success",
+            "tasks_updated": count,
+            "message": format!("{} task(s) updated to Ready status", count)
+        });
+        println!("{}", serde_json::to_string_pretty(&output)?);
+    } else {
+        println!("Task Dependency Resolution");
+        println!("=========================");
+        println!("Tasks updated to Ready: {}", count);
+
+        if count > 0 {
+            println!("\nRun 'abathur task list --status ready' to view ready tasks.");
+        } else {
+            println!("\nNo tasks were ready to be updated.");
+            println!("Check 'abathur task list --status pending' or '--status blocked' for pending tasks.");
+        }
+    }
+
+    Ok(())
+}

src/cli/service/swarm_service.rs

@@ -10,13 +10,12 @@ use std::fs;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 
-/// Persisted swarm state
+/// Persisted swarm state - only tracks process information
+/// Task statistics are derived from the database, not stored here
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct SwarmStateFile {
     state: String,
     max_agents: usize,
-    tasks_processed: u64,
-    tasks_failed: u64,
     pid: Option<u32>,
 }
 
@@ -25,8 +24,6 @@ impl Default for SwarmStateFile {
         Self {
             state: "Stopped".to_string(),
             max_agents: 0,
-            tasks_processed: 0,
-            tasks_failed: 0,
             pid: None,
         }
     }
@@ -129,32 +126,50 @@ impl SwarmService {
         let cwd = std::env::current_dir()
             .context("Failed to get current directory")?;
 
-        // Spawn background process with hidden --__daemon flag
+        // Create log file for daemon stderr/stdout
+        let log_path = cwd.join(".abathur/swarm_daemon.log");
+        let log_file = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&log_path)
+            .context("Failed to create daemon log file")?;
+
+        // Write log header
+        use std::io::Write;
+        let mut header_file = std::fs::OpenOptions::new()
+            .append(true)
+            .open(&log_path)?;
+        writeln!(header_file, "\n=== Daemon starting at {} ===",
+                 chrono::Local::now().format("%Y-%m-%d %H:%M:%S"))?;
+
+        // Spawn background process with hidden --daemon flag
         // This flag will be handled in main.rs to run the orchestrator loop
         #[cfg(unix)]
         let child = Command::new(&exe_path)
             .arg("swarm")
-            .arg("--__daemon")
+            .arg("start")
+            .arg("--daemon")
             .arg("--max-agents")
             .arg(max_agents.to_string())
             .current_dir(&cwd)
             .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
+            .stdout(Stdio::from(log_file.try_clone()?))
+            .stderr(Stdio::from(log_file))
             .spawn()
             .context("Failed to spawn background swarm process")?;
 
         #[cfg(windows)]
         let child = Command::new(&exe_path)
             .arg("swarm")
-            .arg("--__daemon")
+            .arg("start")
+            .arg("--daemon")
             .arg("--max-agents")
             .arg(max_agents.to_string())
             .current_dir(&cwd)
             .creation_flags(0x08000000) // CREATE_NO_WINDOW
             .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
+            .stdout(Stdio::from(log_file.try_clone()?))
+            .stderr(Stdio::from(log_file))
             .spawn()
             .context("Failed to spawn background swarm process")?;
 
@@ -219,7 +234,12 @@ impl SwarmService {
     }
 
     /// Get swarm statistics
-    pub async fn get_stats(&self) -> Result<SwarmStats> {
+    ///
+    /// Combines process state from state file with task statistics from database
+    pub async fn get_stats(
+        &self,
+        task_service: &crate::cli::service::TaskQueueServiceAdapter,
+    ) -> Result<SwarmStats> {
         let mut state = Self::read_state()?;
 
         // Check if the recorded PID is actually alive
@@ -252,13 +272,24 @@ impl SwarmService {
             _ => SwarmState::Stopped,
         };
 
+        // Get task statistics from database (source of truth)
+        let queue_stats = task_service.get_queue_stats().await?;
+
+        // Calculate agent statistics
+        let active_agents = queue_stats.running;
+        let idle_agents = if swarm_state == SwarmState::Running {
+            state.max_agents.saturating_sub(active_agents)
+        } else {
+            0
+        };
+
         Ok(SwarmStats {
             state: swarm_state,
             max_agents: state.max_agents,
-            active_agents: 0,
-            idle_agents: 0,
-            tasks_processed: state.tasks_processed,
-            tasks_failed: state.tasks_failed,
+            active_agents,
+            idle_agents,
+            tasks_processed: queue_stats.completed as u64,
+            tasks_failed: queue_stats.failed as u64,
         })
     }