handoff-mcp-server 0.26.0 → 0.27.0

package/src/mcp/handlers/merge_sessions.rs

@@ -1,103 +0,0 @@
-use anyhow::Result;
-use serde_json::{json, Value};
-
-use super::resolve_project_dir;
-use crate::storage::ensure_handoff_exists;
-use crate::storage::sessions::merge_sessions;
-
-pub fn handle(arguments: &Value) -> Result<String> {
-    let project_dir = resolve_project_dir(arguments)?;
-    let handoff = ensure_handoff_exists(&project_dir)?;
-    let sessions_dir = handoff.join("sessions");
-
-    let source_session_ids: Vec<&str> = arguments
-        .get("source_session_ids")
-        .and_then(|v| v.as_array())
-        .ok_or_else(|| anyhow::anyhow!("'source_session_ids' parameter is required"))?
-        .iter()
-        .filter_map(|v| v.as_str())
-        .collect();
-
-    if source_session_ids.len() < 2 {
-        anyhow::bail!("'source_session_ids' must contain at least 2 session IDs");
-    }
-
-    let target_session_id = arguments
-        .get("target_session_id")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| anyhow::anyhow!("'target_session_id' parameter is required"))?;
-
-    if !source_session_ids.contains(&target_session_id) {
-        anyhow::bail!(
-            "target_session_id '{}' must be one of the source_session_ids",
-            target_session_id
-        );
-    }
-
-    let close_sources = arguments
-        .get("close_sources")
-        .and_then(|v| v.as_bool())
-        .unwrap_or(true);
-
-    let result = merge_sessions(
-        &sessions_dir,
-        &source_session_ids,
-        target_session_id,
-        close_sources,
-    )?;
-
-    let conflicts_json: Vec<Value> = result
-        .conflicts
-        .iter()
-        .map(|c| {
-            json!({
-                "type": c.conflict_type,
-                "description": c.description,
-                "session_a": c.session_a,
-                "session_b": c.session_b,
-            })
-        })
-        .collect();
-
-    let output_json = json!({
-        "merged_session_id": result.merged_session_id,
-        "merged_decisions": result.merged_decisions,
-        "merged_notes": result.merged_notes,
-        "merged_references": result.merged_references,
-        "merged_context_pointers": result.merged_context_pointers,
-        "conflicts": conflicts_json,
-        "closed_sessions": result.closed_sessions,
-    });
-
-    let mut output = format!(
-        "Merged {} sessions into {}\n\
-         Merged: {} decisions, {} notes, {} references, {} context_pointers",
-        source_session_ids.len(),
-        result.merged_session_id,
-        result.merged_decisions,
-        result.merged_notes,
-        result.merged_references,
-        result.merged_context_pointers,
-    );
-
-    if !result.conflicts.is_empty() {
-        output.push_str(&format!("\nConflicts: {}", result.conflicts.len()));
-        for c in &result.conflicts {
-            output.push_str(&format!("\n  - {}: {}", c.conflict_type, c.description));
-        }
-    }
-
-    if !result.closed_sessions.is_empty() {
-        output.push_str(&format!(
-            "\nClosed source sessions: {}",
-            result.closed_sessions.join(", ")
-        ));
-    }
-
-    output.push_str(&format!(
-        "\n\n{}",
-        serde_json::to_string_pretty(&output_json)?
-    ));
-
-    Ok(output)
-}

package/src/mcp/handlers/metrics.rs

@@ -1,196 +0,0 @@
-use std::collections::HashMap;
-
-use anyhow::Result;
-use chrono::Utc;
-use serde_json::{json, Value};
-
-use super::resolve_project_dir;
-use crate::storage::config::read_config;
-use crate::storage::ensure_handoff_exists;
-use crate::storage::tasks::{build_task_index, is_terminal_status, TaskIndex};
-
-pub fn handle(arguments: &Value) -> Result<String> {
-    let project_dir = resolve_project_dir(arguments)?;
-    let handoff = ensure_handoff_exists(&project_dir)?;
-    let tasks_dir = handoff.join("tasks");
-
-    let assignee_filter = arguments.get("assignee").and_then(|v| v.as_str());
-
-    let (tree, _) = build_task_index(&tasks_dir, u32::MAX)?;
-
-    let today = Utc::now().format("%Y-%m-%d").to_string();
-
-    let mut total: u32 = 0;
-    let mut by_status: HashMap<String, u32> = HashMap::new();
-    let mut estimate_sum: f64 = 0.0;
-    let mut actual_sum: f64 = 0.0;
-    let mut remaining_sum: f64 = 0.0;
-    let mut overdue_tasks: Vec<Value> = Vec::new();
-    let mut milestones: HashMap<String, (u32, u32, f64, f64)> = HashMap::new();
-
-    collect_metrics(
-        &tree,
-        assignee_filter,
-        &today,
-        &mut total,
-        &mut by_status,
-        &mut estimate_sum,
-        &mut actual_sum,
-        &mut remaining_sum,
-        &mut overdue_tasks,
-        &mut milestones,
-    );
-
-    let done_count = *by_status.get("done").unwrap_or(&0);
-    let skipped_count = *by_status.get("skipped").unwrap_or(&0);
-    let completion_percent = if total > 0 {
-        ((done_count + skipped_count) as f64 / total as f64) * 100.0
-    } else {
-        0.0
-    };
-
-    let budget = read_budget(&handoff);
-
-    // AI-effort multiplier: the raw estimate is the human-effort estimate;
-    // multiplying by ai_estimate_multiplier yields the expected AI-effort hours.
-    // Raw estimates are preserved; only the adjusted view is derived here.
-    let multiplier = read_config(&handoff.join("config.toml"))
-        .map(|c| c.settings.ai_estimate_multiplier)
-        .unwrap_or(0.2);
-
-    let milestone_list: Vec<Value> = milestones
-        .into_iter()
-        .map(|(name, (done, ms_total, est, act))| {
-            json!({
-                "name": name,
-                "done": done,
-                "total": ms_total,
-                "estimate_hours": est,
-                "adjusted_estimate_hours": est * multiplier,
-                "actual_hours": act,
-            })
-        })
-        .collect();
-
-    let result = json!({
-        "total": total,
-        "by_status": by_status,
-        "completion_percent": (completion_percent * 10.0).round() / 10.0,
-        "total_estimate_hours": estimate_sum,
-        "ai_estimate_multiplier": multiplier,
-        "total_adjusted_estimate_hours": estimate_sum * multiplier,
-        "total_actual_hours": actual_sum,
-        "total_remaining_hours": remaining_sum,
-        "overdue_count": overdue_tasks.len(),
-        "overdue_tasks": overdue_tasks,
-        "budget": budget,
-        "milestones": milestone_list,
-    });
-
-    serde_json::to_string_pretty(&result).map_err(Into::into)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn collect_metrics(
-    tree: &[TaskIndex],
-    assignee_filter: Option<&str>,
-    today: &str,
-    total: &mut u32,
-    by_status: &mut HashMap<String, u32>,
-    estimate_sum: &mut f64,
-    actual_sum: &mut f64,
-    remaining_sum: &mut f64,
-    overdue_tasks: &mut Vec<Value>,
-    milestones: &mut HashMap<String, (u32, u32, f64, f64)>,
-) {
-    for node in tree {
-        let task_assignee = node.assignee.as_deref();
-        let include = match assignee_filter {
-            Some(f) => task_assignee == Some(f),
-            None => true,
-        };
-
-        if include {
-            *total += 1;
-            *by_status.entry(node.status.clone()).or_insert(0) += 1;
-
-            if let Some(ref sched) = node.schedule {
-                if let Some(est) = sched.estimate_hours {
-                    *estimate_sum += est;
-                }
-                if let Some(act) = sched.actual_hours {
-                    *actual_sum += act;
-                }
-                if let Some(rem) = sched.remaining_hours {
-                    *remaining_sum += rem;
-                }
-
-                if let Some(ref due) = sched.due_date {
-                    if !is_terminal_status(&node.status) && due.as_str() < today {
-                        let days_overdue = days_between(due, today).unwrap_or(0);
-                        overdue_tasks.push(json!({
-                            "id": node.id,
-                            "title": node.title,
-                            "due_date": due,
-                            "days_overdue": days_overdue,
-                        }));
-                    }
-                }
-
-                if let Some(ref ms) = sched.milestone {
-                    let entry = milestones.entry(ms.clone()).or_insert((0, 0, 0.0, 0.0));
-                    entry.1 += 1;
-                    if is_terminal_status(&node.status) {
-                        entry.0 += 1;
-                    }
-                    if let Some(est) = sched.estimate_hours {
-                        entry.2 += est;
-                    }
-                    if let Some(act) = sched.actual_hours {
-                        entry.3 += act;
-                    }
-                }
-            }
-        }
-
-        collect_metrics(
-            &node.children,
-            assignee_filter,
-            today,
-            total,
-            by_status,
-            estimate_sum,
-            actual_sum,
-            remaining_sum,
-            overdue_tasks,
-            milestones,
-        );
-    }
-}
-
-fn days_between(from: &str, to: &str) -> Option<i64> {
-    let from_date = chrono::NaiveDate::parse_from_str(from, "%Y-%m-%d").ok()?;
-    let to_date = chrono::NaiveDate::parse_from_str(to, "%Y-%m-%d").ok()?;
-    Some((to_date - from_date).num_days())
-}
-
-fn read_budget(handoff: &std::path::Path) -> Value {
-    let config_path = handoff.join("config.toml");
-    let content = match std::fs::read_to_string(&config_path) {
-        Ok(c) => c,
-        Err(_) => return Value::Null,
-    };
-
-    for line in content.lines() {
-        let trimmed = line.trim();
-        if trimmed.starts_with("total_hours") {
-            if let Some(val_str) = trimmed.split('=').nth(1) {
-                if let Ok(total) = val_str.trim().parse::<f64>() {
-                    return json!({ "total_hours": total });
-                }
-            }
-        }
-    }
-
-    Value::Null
-}

package/src/mcp/handlers/milestones.rs

@@ -1,102 +0,0 @@
-//! Milestone CRUD over the `[milestones.<name>]` config.toml section.
-//! Mirrors the VSCode extension's addMilestone/updateMilestone/removeMilestone.
-
-use anyhow::Result;
-use serde_json::{json, Value};
-use toml_edit::{Item, Table};
-
-use super::config_crud::{
-    config_path, ensure_subtable, ensure_table, load_doc, require_str, save_doc, set_opt_str,
-};
-
-/// handoff_list_milestones — return every `[milestones.*]` entry.
-pub fn handle_list(arguments: &Value) -> Result<String> {
-    let path = config_path(arguments)?;
-    let doc = load_doc(&path)?;
-
-    let mut out = serde_json::Map::new();
-    if let Some(table) = doc.get("milestones").and_then(|v| v.as_table()) {
-        for (name, item) in table.iter() {
-            let sub = match item.as_table() {
-                Some(t) => t,
-                None => continue,
-            };
-            out.insert(
-                name.to_string(),
-                json!({
-                    "date": sub.get("date").and_then(|v| v.as_str()),
-                    "color": sub.get("color").and_then(|v| v.as_str()),
-                    "description": sub.get("description").and_then(|v| v.as_str()),
-                }),
-            );
-        }
-    }
-    serde_json::to_string_pretty(&json!({ "milestones": out })).map_err(Into::into)
-}
-
-/// handoff_add_milestone — create a `[milestones.<name>]` entry. Fails if it exists.
-pub fn handle_add(arguments: &Value) -> Result<String> {
-    let path = config_path(arguments)?;
-    let name = require_str(arguments, "name")?;
-    let mut doc = load_doc(&path)?;
-
-    let table = ensure_table(&mut doc, "milestones")?;
-    table.set_implicit(true);
-    if table.contains_key(name) {
-        anyhow::bail!(
-            "Milestone '{name}' already exists. Use handoff_update_milestone to modify it."
-        );
-    }
-    let mut sub = Table::new();
-    apply_fields(&mut sub, arguments);
-    doc["milestones"][name] = Item::Table(sub);
-
-    save_doc(&path, &doc)?;
-    Ok(format!("Added milestone '{name}'"))
-}
-
-/// handoff_update_milestone — patch an existing `[milestones.<name>]` entry.
-pub fn handle_update(arguments: &Value) -> Result<String> {
-    let path = config_path(arguments)?;
-    let name = require_str(arguments, "name")?;
-    let mut doc = load_doc(&path)?;
-
-    let exists = doc
-        .get("milestones")
-        .and_then(|v| v.as_table())
-        .map(|t| t.contains_key(name))
-        .unwrap_or(false);
-    if !exists {
-        anyhow::bail!("Milestone '{name}' not found. Use handoff_add_milestone to create it.");
-    }
-    let sub = ensure_subtable(&mut doc, "milestones", name)?;
-    apply_fields(sub, arguments);
-
-    save_doc(&path, &doc)?;
-    Ok(format!("Updated milestone '{name}'"))
-}
-
-/// handoff_remove_milestone — delete a `[milestones.<name>]` entry.
-pub fn handle_remove(arguments: &Value) -> Result<String> {
-    let path = config_path(arguments)?;
-    let name = require_str(arguments, "name")?;
-    let mut doc = load_doc(&path)?;
-
-    let removed = doc
-        .get_mut("milestones")
-        .and_then(|v| v.as_table_mut())
-        .map(|t| t.remove(name).is_some())
-        .unwrap_or(false);
-    if !removed {
-        anyhow::bail!("Milestone '{name}' not found.");
-    }
-    save_doc(&path, &doc)?;
-    Ok(format!("Removed milestone '{name}'"))
-}
-
-fn apply_fields(table: &mut Table, arguments: &Value) {
-    table.set_implicit(false);
-    set_opt_str(table, "date", arguments.get("date"));
-    set_opt_str(table, "color", arguments.get("color"));
-    set_opt_str(table, "description", arguments.get("description"));
-}

package/src/mcp/handlers/mod.rs

@@ -1,140 +0,0 @@
-pub mod assignees;
-pub mod auto_schedule;
-pub mod bulk_update;
-pub mod calendar;
-pub mod capacity;
-pub mod check_criterion;
-pub mod config;
-pub mod config_crud;
-pub mod dashboard;
-pub mod docs;
-pub mod docs_query;
-pub mod fork_session;
-pub mod get_session;
-pub mod get_task;
-pub mod import_context;
-pub mod init;
-pub mod list_sessions;
-pub mod list_tasks;
-pub mod load_context;
-pub mod log_time;
-pub mod memory;
-pub mod merge_sessions;
-pub mod metrics;
-pub mod milestones;
-pub mod refer;
-pub mod referrals;
-pub mod save_context;
-pub mod task_checklist;
-pub mod timer;
-pub mod update_session;
-pub mod update_task;
-
-use std::path::PathBuf;
-
-use anyhow::{Context, Result};
-use serde_json::Value;
-
-use crate::mcp::types::JsonRpcResponse;
-
-pub fn resolve_project_dir(arguments: &Value) -> Result<PathBuf> {
-    let raw = match arguments
-        .get("project_dir")
-        .and_then(|v| v.as_str())
-        .filter(|s| !s.is_empty() && !s.starts_with("${"))
-    {
-        Some(dir) => PathBuf::from(dir),
-        None => match std::env::var("CLAUDE_PROJECT_DIR") {
-            Ok(dir) if !dir.is_empty() => PathBuf::from(dir),
-            _ => std::env::current_dir().context("Failed to get current directory")?,
-        },
-    };
-    std::fs::canonicalize(&raw)
-        .with_context(|| format!("Invalid project path: {raw}", raw = raw.display()))
-}
-
-pub fn handle_tool_call(name: &str, arguments: &Value) -> JsonRpcResponse {
-    let result = match name {
-        "handoff_init" => init::handle(arguments),
-        "handoff_update_task" => update_task::handle(arguments),
-        "handoff_list_tasks" => list_tasks::handle(arguments),
-        "handoff_save_context" => save_context::handle(arguments),
-        "handoff_load_context" => load_context::handle(arguments),
-        "handoff_dashboard" => dashboard::handle(arguments),
-        "handoff_get_config" => config::handle_get(arguments),
-        "handoff_update_config" => config::handle_update(arguments),
-        "handoff_get_task" => get_task::handle(arguments),
-        "handoff_check_criterion" => check_criterion::handle(arguments),
-        "handoff_import_context" => import_context::handle(arguments),
-        "handoff_refer" => refer::handle(arguments),
-        "handoff_list_referrals" => referrals::handle_list(arguments),
-        "handoff_get_referral" => referrals::handle_get(arguments),
-        "handoff_update_referral" => referrals::handle_update(arguments),
-        "handoff_update_session" => update_session::handle(arguments),
-        "handoff_log_time" => log_time::handle(arguments),
-        "handoff_get_metrics" => metrics::handle(arguments),
-        "handoff_list_sessions" => list_sessions::handle(arguments),
-        "handoff_list_assignees" => assignees::handle(arguments),
-        "handoff_bulk_update_tasks" => bulk_update::handle(arguments),
-        "handoff_get_session" => get_session::handle(arguments),
-        "handoff_get_capacity" => capacity::handle(arguments),
-        "handoff_auto_schedule" => auto_schedule::handle(arguments),
-        "handoff_add_assignee" => assignees::handle_add(arguments),
-        "handoff_update_assignee" => assignees::handle_update(arguments),
-        "handoff_remove_assignee" => assignees::handle_remove(arguments),
-        "handoff_list_milestones" => milestones::handle_list(arguments),
-        "handoff_add_milestone" => milestones::handle_add(arguments),
-        "handoff_update_milestone" => milestones::handle_update(arguments),
-        "handoff_remove_milestone" => milestones::handle_remove(arguments),
-        "handoff_update_calendar" => calendar::handle_update_calendar(arguments),
-        "handoff_update_labels" => calendar::handle_update_labels(arguments),
-        "handoff_start_project" => calendar::handle_start_project(arguments),
-        "handoff_memory_save" => memory::handle_save(arguments),
-        "handoff_memory_query" => memory::handle_query(arguments),
-        "handoff_memory_delete" => memory::handle_delete(arguments),
-        "handoff_memory_cleanup" => memory::handle_cleanup(arguments),
-        "handoff_fork_session" => fork_session::handle(arguments),
-        "handoff_merge_sessions" => merge_sessions::handle(arguments),
-        "handoff_timer_start" => timer::handle_start(arguments),
-        "handoff_timer_stop" => timer::handle_stop(arguments),
-        "handoff_timer_get_time" => timer::handle_get_time(arguments),
-        "handoff_doc_save" => docs::handle_doc_save(arguments),
-        "handoff_doc_update_section" => docs::handle_doc_update_section(arguments),
-        "handoff_doc_get" => docs::handle_doc_get(arguments),
-        "handoff_doc_list" => docs::handle_doc_list(arguments),
-        "handoff_doc_delete" => docs::handle_doc_delete(arguments),
-        "handoff_doc_reassemble" => docs::handle_doc_reassemble(arguments),
-        "handoff_doc_tree" => docs::handle_doc_tree(arguments),
-        "handoff_doc_graph" => docs::handle_doc_graph(arguments),
-        "handoff_doc_trace" => docs::handle_doc_trace(arguments),
-        "handoff_doc_verify" => docs::handle_doc_verify(arguments),
-        "handoff_doc_verify_status" => docs::handle_doc_verify_status(arguments),
-        "handoff_doc_query" => docs_query::handle_doc_query(arguments),
-        "handoff_doc_analyze" => docs_query::handle_doc_analyze(arguments),
-        "handoff_doc_import" => docs_query::handle_doc_import(arguments),
-        "handoff_task_checklist" => task_checklist::handle(arguments),
-        _ => Err(anyhow::anyhow!("Tool not implemented: {name}")),
-    };
-
-    match result {
-        Ok(content) => {
-            let tool_result = serde_json::json!({
-                "content": [{
-                    "type": "text",
-                    "text": content
-                }]
-            });
-            JsonRpcResponse::success(None, tool_result)
-        }
-        Err(e) => {
-            let tool_result = serde_json::json!({
-                "isError": true,
-                "content": [{
-                    "type": "text",
-                    "text": format!("Error: {e}")
-                }]
-            });
-            JsonRpcResponse::success(None, tool_result)
-        }
-    }
-}