handoff-mcp-server 0.3.0 → 0.6.0

package/src/storage/tasks.rs

@@ -1,6 +1,8 @@
+use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 
 use anyhow::{Context, Result};
+use chrono::Utc;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -23,6 +25,26 @@ pub struct TaskData {
     pub links: Vec<String>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub done_criteria: Vec<DoneCriterion>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<Schedule>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub dependencies: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub order: Option<u32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Schedule {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start_date: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub due_date: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub estimate_hours: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub actual_hours: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub milestone: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -37,6 +59,12 @@ pub struct TaskIndex {
     pub id: String,
     pub title: String,
     pub status: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<Schedule>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub dependencies: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub order: Option<u32>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub children: Vec<TaskIndex>,
 }
@@ -45,6 +73,14 @@ pub struct TaskIndex {
 pub struct TaskSummary {
     pub total: u32,
     pub by_status: std::collections::HashMap<String, u32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub total_estimate_hours: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub total_actual_hours: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub completion_rate: Option<f64>,
+    #[serde(default)]
+    pub overdue_count: u32,
 }
 
 const VALID_STATUSES: &[&str] = &[
@@ -269,9 +305,17 @@ pub fn build_task_index(
     let mut tree = Vec::new();
     let mut summary = TaskSummary {
         total: 0,
-        by_status: std::collections::HashMap::new(),
+        by_status: HashMap::new(),
+        total_estimate_hours: None,
+        total_actual_hours: None,
+        completion_rate: None,
+        overdue_count: 0,
     };
     let mut done_count: u32 = 0;
+    let mut estimate_sum: f64 = 0.0;
+    let mut actual_sum: f64 = 0.0;
+    let mut has_hours = false;
+    let today = Utc::now().format("%Y-%m-%d").to_string();
 
     build_index_recursive(
         tasks_dir,
@@ -279,17 +323,37 @@ pub fn build_task_index(
         &mut summary,
         &mut done_count,
         done_task_limit,
+        &mut estimate_sum,
+        &mut actual_sum,
+        &mut has_hours,
+        &today,
     )?;
 
+    if has_hours {
+        summary.total_estimate_hours = Some(estimate_sum);
+        summary.total_actual_hours = Some(actual_sum);
+    }
+
+    if summary.total > 0 {
+        let done = *summary.by_status.get("done").unwrap_or(&0) as f64;
+        let skipped = *summary.by_status.get("skipped").unwrap_or(&0) as f64;
+        summary.completion_rate = Some((done + skipped) / summary.total as f64);
+    }
+
     Ok((tree, summary))
 }
 
+#[allow(clippy::too_many_arguments)]
 fn build_index_recursive(
     dir: &Path,
     tree: &mut Vec<TaskIndex>,
     summary: &mut TaskSummary,
     done_count: &mut u32,
     done_task_limit: u32,
+    estimate_sum: &mut f64,
+    actual_sum: &mut f64,
+    has_hours: &mut bool,
+    today: &str,
 ) -> Result<()> {
     if !dir.exists() {
         return Ok(());
@@ -316,6 +380,22 @@ fn build_index_recursive(
         summary.total += 1;
         *summary.by_status.entry(status.clone()).or_insert(0) += 1;
 
+        if let Some(ref sched) = data.schedule {
+            if let Some(est) = sched.estimate_hours {
+                *estimate_sum += est;
+                *has_hours = true;
+            }
+            if let Some(act) = sched.actual_hours {
+                *actual_sum += act;
+                *has_hours = true;
+            }
+            if let Some(ref due) = sched.due_date {
+                if !is_terminal_status(&status) && due.as_str() < today {
+                    summary.overdue_count += 1;
+                }
+            }
+        }
+
         if is_terminal_status(&status) {
             *done_count += 1;
             if *done_count > done_task_limit {
@@ -330,12 +410,19 @@ fn build_index_recursive(
             summary,
             done_count,
             done_task_limit,
+            estimate_sum,
+            actual_sum,
+            has_hours,
+            today,
         )?;
 
         tree.push(TaskIndex {
             id: data.id,
             title: data.title,
             status,
+            schedule: data.schedule,
+            dependencies: data.dependencies,
+            order: data.order,
             children,
         });
     }
@@ -343,6 +430,80 @@ fn build_index_recursive(
     Ok(())
 }
 
+pub fn validate_dependencies(tasks_dir: &Path, task_id: &str, new_deps: &[String]) -> Result<()> {
+    let dep_graph = build_dependency_graph(tasks_dir)?;
+
+    let mut graph = dep_graph;
+    graph.insert(task_id.to_string(), new_deps.to_vec());
+
+    let mut visited = HashSet::new();
+    let mut stack = HashSet::new();
+
+    if has_cycle(&graph, task_id, &mut visited, &mut stack) {
+        anyhow::bail!(
+            "Circular dependency detected: setting dependencies {:?} on task {task_id} would create a cycle",
+            new_deps
+        );
+    }
+
+    Ok(())
+}
+
+fn build_dependency_graph(tasks_dir: &Path) -> Result<HashMap<String, Vec<String>>> {
+    let mut graph = HashMap::new();
+    build_dep_graph_recursive(tasks_dir, &mut graph)?;
+    Ok(graph)
+}
+
+fn build_dep_graph_recursive(dir: &Path, graph: &mut HashMap<String, Vec<String>>) -> Result<()> {
+    if !dir.exists() {
+        return Ok(());
+    }
+    for entry in std::fs::read_dir(dir)? {
+        let entry = entry?;
+        if !entry.file_type()?.is_dir() {
+            continue;
+        }
+        let name = entry.file_name().to_string_lossy().to_string();
+        if name.starts_with('.') || name.starts_with('_') {
+            continue;
+        }
+        let task_dir = entry.path();
+        if let Some((data, _)) = read_task(&task_dir)? {
+            graph.insert(data.id.clone(), data.dependencies.clone());
+            build_dep_graph_recursive(&task_dir, graph)?;
+        }
+    }
+    Ok(())
+}
+
+fn has_cycle(
+    graph: &HashMap<String, Vec<String>>,
+    node: &str,
+    visited: &mut HashSet<String>,
+    stack: &mut HashSet<String>,
+) -> bool {
+    if stack.contains(node) {
+        return true;
+    }
+    if visited.contains(node) {
+        return false;
+    }
+    visited.insert(node.to_string());
+    stack.insert(node.to_string());
+
+    if let Some(deps) = graph.get(node) {
+        for dep in deps {
+            if has_cycle(graph, dep, visited, stack) {
+                return true;
+            }
+        }
+    }
+
+    stack.remove(node);
+    false
+}
+
 pub fn validate_done_transition(task_dir: &Path, data: &TaskData) -> Result<()> {
     for criterion in &data.done_criteria {
         if !criterion.checked {

package/tests/storage_sessions.rs

@@ -9,6 +9,7 @@ fn setup() -> TempDir {
 fn make_session(summary: &str, ended_at: &str) -> SessionData {
     SessionData {
         version: 2,
+        id: None,
         ended_at: Some(ended_at.to_string()),
         summary: summary.to_string(),
         branch: Some("main".to_string()),
@@ -25,17 +26,17 @@ fn make_session(summary: &str, ended_at: &str) -> SessionData {
 }
 
 #[test]
-fn write_active_session_creates_file() {
+fn write_open_session_creates_file() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let data = make_session("test session", "2026-06-13T14:30:00Z");
-    let path = write_active_session(&sessions_dir, &data).unwrap();
+    let path = write_open_session(&sessions_dir, &data).unwrap();
 
     assert!(path.exists());
     assert!(
-        path.to_string_lossy().ends_with(".active.json"),
+        path.to_string_lossy().ends_with(".open.json"),
         "filename: {}",
         path.display()
     );
@@ -47,26 +48,26 @@ fn write_active_session_creates_file() {
 }
 
 #[test]
-fn read_active_sessions_empty() {
+fn read_open_sessions_empty() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert!(sessions.is_empty());
 }
 
 #[test]
-fn read_active_sessions_returns_active_only() {
+fn read_open_sessions_returns_open_only() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
-    let s1 = make_session("active one", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s1).unwrap();
+    let s1 = make_session("open one", "2026-06-13T10:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
 
-    let s2 = make_session("active two", "2026-06-13T11:00:00Z");
-    write_active_session(&sessions_dir, &s2).unwrap();
+    let s2 = make_session("open two", "2026-06-13T11:00:00Z");
+    write_open_session(&sessions_dir, &s2).unwrap();
 
     fs::write(
         sessions_dir.join("20260612-090000-old.closed.json"),
@@ -74,10 +75,26 @@ fn read_active_sessions_returns_active_only() {
     )
     .unwrap();
 
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert_eq!(sessions.len(), 2);
 }
 
+#[test]
+fn activate_open_sessions_renames_to_active() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-13T10:00:00Z");
+    let open_path = write_open_session(&sessions_dir, &s1).unwrap();
+
+    let activated = activate_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(activated.len(), 1);
+    assert!(!open_path.exists());
+    assert!(activated[0].exists());
+    assert!(activated[0].to_string_lossy().contains(".active.json"));
+}
+
 #[test]
 fn close_active_sessions_renames_to_closed() {
     let dir = setup();
@@ -85,7 +102,9 @@ fn close_active_sessions_renames_to_closed() {
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let s1 = make_session("session one", "2026-06-13T10:00:00Z");
-    let active_path = write_active_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s1).unwrap();
+    let activated = activate_open_sessions(&sessions_dir).unwrap();
+    let active_path = &activated[0];
 
     let closed = close_active_sessions(&sessions_dir).unwrap();
     assert_eq!(closed.len(), 1);
@@ -95,22 +114,51 @@ fn close_active_sessions_renames_to_closed() {
 }
 
 #[test]
-fn close_active_then_create_new() {
+fn close_open_sessions_renames_to_closed() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-13T10:00:00Z");
+    let open_path = write_open_session(&sessions_dir, &s1).unwrap();
+
+    let closed = close_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(closed.len(), 1);
+    assert!(!open_path.exists());
+    assert!(closed[0].exists());
+    assert!(closed[0].to_string_lossy().contains(".closed.json"));
+}
+
+#[test]
+fn full_session_lifecycle_open_active_closed() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let s1 = make_session("first session", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s1).unwrap();
 
-    close_active_sessions(&sessions_dir).unwrap();
+    let open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open.len(), 1);
+    assert_eq!(open[0].summary, "first session");
 
-    let s2 = make_session("second session", "2026-06-13T14:00:00Z");
-    write_active_session(&sessions_dir, &s2).unwrap();
+    activate_open_sessions(&sessions_dir).unwrap();
 
+    assert!(read_open_sessions(&sessions_dir).unwrap().is_empty());
     let active = read_active_sessions(&sessions_dir).unwrap();
     assert_eq!(active.len(), 1);
-    assert_eq!(active[0].summary, "second session");
+    assert_eq!(active[0].summary, "first session");
+
+    close_active_sessions(&sessions_dir).unwrap();
+
+    assert!(read_active_sessions(&sessions_dir).unwrap().is_empty());
+
+    let s2 = make_session("second session", "2026-06-13T14:00:00Z");
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let open2 = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open2.len(), 1);
+    assert_eq!(open2[0].summary, "second session");
 }
 
 #[test]
@@ -140,7 +188,7 @@ fn enforce_history_limit_removes_oldest() {
 }
 
 #[test]
-fn enforce_history_limit_ignores_active() {
+fn enforce_history_limit_ignores_open_and_active() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
@@ -154,13 +202,13 @@ fn enforce_history_limit_ignores_active() {
         .unwrap();
     }
 
-    let s = make_session("active", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s).unwrap();
+    let s = make_session("open session", "2026-06-13T10:00:00Z");
+    write_open_session(&sessions_dir, &s).unwrap();
 
     enforce_history_limit(&sessions_dir, 2).unwrap();
 
-    let active = read_active_sessions(&sessions_dir).unwrap();
-    assert_eq!(active.len(), 1);
+    let open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open.len(), 1);
 }
 
 #[test]
@@ -187,9 +235,125 @@ fn generate_session_filename_format() {
 }
 
 #[test]
-fn read_active_sessions_nonexistent_dir() {
+fn read_open_sessions_nonexistent_dir() {
     let dir = setup();
     let sessions_dir = dir.path().join("nonexistent");
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert!(sessions.is_empty());
 }
+
+#[test]
+fn generate_session_id_format() {
+    let id = generate_session_id();
+    assert!(id.starts_with("s-"), "should start with s-: {id}");
+    assert!(id.len() > 20, "should be long enough: {id}");
+    let parts: Vec<&str> = id.splitn(2, '-').collect();
+    assert_eq!(parts[0], "s");
+}
+
+#[test]
+fn write_open_session_assigns_id() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s = make_session("test", "2026-06-15T10:00:00Z");
+    assert!(s.id.is_none());
+
+    write_open_session(&sessions_dir, &s).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 1);
+    assert!(
+        sessions[0].id.is_some(),
+        "written session should have an id"
+    );
+    assert!(sessions[0].id.as_ref().unwrap().starts_with("s-"));
+}
+
+#[test]
+fn read_old_session_without_id_gets_synthesized_id() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    // Write a session file without id field (simulating pre-upgrade file)
+    fs::write(
+        sessions_dir.join("20260613-143000-old-session.open.json"),
+        r#"{"version":2,"summary":"old session"}"#,
+    )
+    .unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 1);
+    assert!(
+        sessions[0].id.is_some(),
+        "old session should get a synthesized id"
+    );
+    let id = sessions[0].id.as_ref().unwrap();
+    assert!(id.starts_with("s-"), "synthesized id format: {id}");
+    assert!(
+        id.contains("20260613-143000"),
+        "synthesized id should contain original timestamp: {id}"
+    );
+}
+
+#[test]
+fn close_session_by_id_closes_only_targeted() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-15T10:00:00Z");
+    let s2 = make_session("session two", "2026-06-15T11:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 2);
+
+    let target_id = sessions[0].id.as_ref().unwrap().clone();
+    let other_id = sessions[1].id.as_ref().unwrap().clone();
+
+    let result = close_session_by_id(&sessions_dir, &target_id).unwrap();
+    assert!(result.is_some(), "should close the targeted session");
+
+    let remaining_open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(remaining_open.len(), 1);
+    assert_eq!(remaining_open[0].id.as_deref().unwrap(), other_id);
+}
+
+#[test]
+fn activate_session_by_id_activates_only_targeted() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-15T10:00:00Z");
+    let s2 = make_session("session two", "2026-06-15T11:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    let target_id = sessions[0].id.as_ref().unwrap().clone();
+
+    let result = activate_session_by_id(&sessions_dir, &target_id).unwrap();
+    assert!(result.is_some(), "should activate the targeted session");
+
+    let remaining_open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(remaining_open.len(), 1, "one session should remain open");
+
+    let active = read_active_sessions(&sessions_dir).unwrap();
+    assert_eq!(active.len(), 1, "one session should be active");
+    assert_eq!(active[0].id.as_deref().unwrap(), target_id);
+}
+
+#[test]
+fn close_session_by_id_nonexistent_returns_none() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let result = close_session_by_id(&sessions_dir, "s-nonexistent").unwrap();
+    assert!(result.is_none());
+}

package/tests/storage_tasks.rs

@@ -24,6 +24,9 @@ fn make_task(id: &str, title: &str) -> TaskData {
         labels: Vec::new(),
         links: Vec::new(),
         done_criteria: Vec::new(),
+        schedule: None,
+        dependencies: Vec::new(),
+        order: None,
     }
 }
 

package/tests/tool_import_context.rs

@@ -360,7 +360,7 @@ fn import_source_recorded_in_environment() {
     let entries: Vec<_> = std::fs::read_dir(&sessions_dir)
         .unwrap()
         .filter_map(|e| e.ok())
-        .filter(|e| e.file_name().to_string_lossy().ends_with(".active.json"))
+        .filter(|e| e.file_name().to_string_lossy().ends_with(".open.json"))
         .collect();
     assert_eq!(entries.len(), 1);