task-graph-mcp 0.5.0

MCP server for agent task workflows with phases, prompts, gates, and multi-agent coordination
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Stats and plan resource handlers.

use crate::config::StatesConfig;
use crate::db::Database;
use anyhow::Result;
use serde_json::{Value, json};

pub fn get_stats_summary(db: &Database, states_config: &StatesConfig) -> Result<Value> {
    let stats = db.get_stats(None, None, states_config)?;

    Ok(json!({
        "total_tasks": stats.total_tasks,
        "by_status": stats.tasks_by_status,
        "points": {
            "total": stats.total_points,
            "completed": stats.completed_points,
            "remaining": stats.total_points - stats.completed_points
        },
        "time": {
            "estimated_ms": stats.total_time_estimate_ms,
            "actual_ms": stats.total_time_actual_ms
        },
        "cost_usd": stats.total_cost_usd,
        "metrics": stats.total_metrics
    }))
}

/// Export tasks in ACP (Agent Coordination Protocol) compatible format.
pub fn get_acp_plan(db: &Database) -> Result<Value> {
    let tasks = db.get_all_tasks()?;
    let deps = db.get_all_dependencies()?;

    // Build dependency map
    let mut blockers_map: std::collections::HashMap<String, Vec<String>> =
        std::collections::HashMap::new();
    for dep in &deps {
        blockers_map
            .entry(dep.to_task_id.to_string())
            .or_default()
            .push(dep.from_task_id.to_string());
    }

    // Convert tasks to ACP format
    let acp_tasks: Vec<Value> = tasks
        .iter()
        .map(|t| {
            let blockers = blockers_map
                .get(&t.id.to_string())
                .cloned()
                .unwrap_or_default();

            // Map status to ACP format
            let status = match t.status.as_str() {
                "pending" => "todo",
                "working" => "working",
                "completed" => "done",
                _ => &t.status, // Pass through other states
            };

            json!({
                "id": t.id.to_string(),
                "title": t.title,
                "description": t.description,
                "status": status,
                "priority": t.priority,
                "blockedBy": blockers,
                "assignee": &t.worker_id,
                "metadata": {
                    "points": t.points,
                    "timeEstimateMs": t.time_estimate_ms,
                    "timeActualMs": t.time_actual_ms,
                    "cost": {
                        "metrics": t.metrics,
                        "usd": t.cost_usd
                    }
                }
            })
        })
        .collect();

    Ok(json!({
        "version": "1.0",
        "tasks": acp_tasks
    }))
}