handoff-mcp-server 0.3.0 → 0.4.0

package/Cargo.lock

@@ -144,7 +144,7 @@ dependencies = [
 
 [[package]]
 name = "handoff-mcp"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "handoff-mcp"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 description = "MCP server that gives AI coding agents persistent memory across sessions"
 license = "MIT"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "handoff-mcp-server",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "MCP server that gives AI coding agents persistent memory across sessions",
   "license": "MIT",
   "author": "AlphaElements <66808803+alphaelements@users.noreply.github.com>",

package/src/mcp/handlers/get_task.rs

@@ -34,6 +34,9 @@ pub fn handle(arguments: &Value) -> Result<String> {
         "labels": data.labels,
         "links": data.links,
         "done_criteria": data.done_criteria,
+        "schedule": data.schedule,
+        "dependencies": data.dependencies,
+        "order": data.order,
     });
 
     serde_json::to_string_pretty(&result).map_err(Into::into)

package/src/mcp/handlers/import_context.rs

@@ -235,6 +235,12 @@ fn create_task_recursive(
         labels: extract_string_array_from(task_val, "labels"),
         links: extract_string_array_from(task_val, "links"),
         done_criteria: extract_done_criteria(task_val),
+        schedule: extract_schedule(task_val),
+        dependencies: extract_string_array_from(task_val, "dependencies"),
+        order: task_val
+            .get("order")
+            .and_then(|v| v.as_u64())
+            .map(|v| v as u32),
     };
 
     write_task(&task_dir, status, &data)?;
@@ -308,3 +314,26 @@ fn extract_done_criteria(val: &Value) -> Vec<DoneCriterion> {
         })
         .unwrap_or_default()
 }
+
+fn extract_schedule(val: &Value) -> Option<Schedule> {
+    let sched = val.get("schedule")?;
+    if sched.is_null() {
+        return None;
+    }
+    Some(Schedule {
+        start_date: sched
+            .get("start_date")
+            .and_then(|v| v.as_str())
+            .map(String::from),
+        due_date: sched
+            .get("due_date")
+            .and_then(|v| v.as_str())
+            .map(String::from),
+        estimate_hours: sched.get("estimate_hours").and_then(|v| v.as_f64()),
+        actual_hours: sched.get("actual_hours").and_then(|v| v.as_f64()),
+        milestone: sched
+            .get("milestone")
+            .and_then(|v| v.as_str())
+            .map(String::from),
+    })
+}

package/src/mcp/handlers/list_tasks.rs

@@ -51,6 +51,9 @@ fn filter_tree(
                     id: node.id.clone(),
                     title: node.title.clone(),
                     status: node.status.clone(),
+                    schedule: node.schedule.clone(),
+                    dependencies: node.dependencies.clone(),
+                    order: node.order,
                     children,
                 })
             } else {

package/src/mcp/handlers/update_task.rs

@@ -74,6 +74,11 @@ fn handle_create(
     let priority = task_val.get("priority").and_then(|v| v.as_str());
     validate_priority(priority)?;
 
+    let dependencies = extract_string_array(task_val, "dependencies");
+    if !dependencies.is_empty() {
+        validate_dependencies(tasks_dir, &new_id, &dependencies)?;
+    }
+
     let data = TaskData {
         id: new_id.clone(),
         title: title.to_string(),
@@ -88,6 +93,12 @@ fn handle_create(
         labels: extract_string_array(task_val, "labels"),
         links: extract_string_array(task_val, "links"),
         done_criteria: extract_done_criteria(task_val),
+        schedule: extract_schedule(task_val),
+        dependencies,
+        order: task_val
+            .get("order")
+            .and_then(|v| v.as_u64())
+            .map(|v| v as u32),
     };
 
     write_task(&task_dir, status, &data)?;
@@ -121,6 +132,19 @@ fn handle_update(tasks_dir: &std::path::Path, task_id: &str, task_val: &Value) -
     if task_val.get("done_criteria").is_some() {
         data.done_criteria = extract_done_criteria(task_val);
     }
+    if task_val.get("schedule").is_some() {
+        data.schedule = extract_schedule(task_val);
+    }
+    if task_val.get("dependencies").is_some() {
+        let new_deps = extract_string_array(task_val, "dependencies");
+        if !new_deps.is_empty() {
+            validate_dependencies(tasks_dir, task_id, &new_deps)?;
+        }
+        data.dependencies = new_deps;
+    }
+    if let Some(order) = task_val.get("order").and_then(|v| v.as_u64()) {
+        data.order = Some(order as u32);
+    }
 
     let new_status = task_val
         .get("status")
@@ -206,3 +230,26 @@ fn extract_done_criteria(val: &Value) -> Vec<DoneCriterion> {
         })
         .unwrap_or_default()
 }
+
+fn extract_schedule(val: &Value) -> Option<Schedule> {
+    let sched = val.get("schedule")?;
+    if sched.is_null() {
+        return None;
+    }
+    Some(Schedule {
+        start_date: sched
+            .get("start_date")
+            .and_then(|v| v.as_str())
+            .map(String::from),
+        due_date: sched
+            .get("due_date")
+            .and_then(|v| v.as_str())
+            .map(String::from),
+        estimate_hours: sched.get("estimate_hours").and_then(|v| v.as_f64()),
+        actual_hours: sched.get("actual_hours").and_then(|v| v.as_f64()),
+        milestone: sched
+            .get("milestone")
+            .and_then(|v| v.as_str())
+            .map(String::from),
+    })
+}

package/src/mcp/tools.rs

@@ -242,6 +242,26 @@ pub fn all_tool_definitions() -> Vec<ToolDefinition> {
                                     },
                                     "required": ["item"]
                                 }
+                            },
+                            "schedule": {
+                                "type": "object",
+                                "description": "Schedule and effort tracking.",
+                                "properties": {
+                                    "start_date": { "type": "string", "description": "YYYY-MM-DD" },
+                                    "due_date": { "type": "string", "description": "YYYY-MM-DD" },
+                                    "estimate_hours": { "type": "number" },
+                                    "actual_hours": { "type": "number" },
+                                    "milestone": { "type": "string" }
+                                }
+                            },
+                            "dependencies": {
+                                "type": "array",
+                                "description": "Task IDs this task depends on. Circular dependencies are rejected.",
+                                "items": { "type": "string" }
+                            },
+                            "order": {
+                                "type": "integer",
+                                "description": "Display order among siblings. 0-based, lower = higher priority."
                             }
                         },
                     },

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_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,
     }
 }