handoff-mcp-server 0.26.0 → 0.28.0

package/src/mcp/handlers/calendar.rs

@@ -1,196 +0,0 @@
-//! Project-level calendar, label, and project-start tools.
-//! - handoff_update_calendar: patch the `[calendar]` section.
-//! - handoff_update_labels:   set the top-level `labels` array.
-//! - handoff_start_project:   set `started_at` and (optionally) shift all task
-//!   dates so the earliest start aligns to the project start date.
-
-use std::path::Path;
-
-use anyhow::Result;
-use chrono::{Duration, NaiveDate, Utc};
-use serde_json::Value;
-
-use super::config_crud::{
-    config_path, ensure_table, load_doc, save_doc, set_f64_map, set_mixed_array, set_opt_f64,
-    set_opt_str, set_string_array,
-};
-
-/// handoff_update_calendar — patch the `[calendar]` section. Only provided
-/// fields are changed; passing JSON null clears a field.
-pub fn handle_update_calendar(arguments: &Value) -> Result<String> {
-    let path = config_path(arguments)?;
-    let mut doc = load_doc(&path)?;
-
-    let cal = ensure_table(&mut doc, "calendar")?;
-    cal.set_implicit(false);
-    set_opt_f64(
-        cal,
-        "work_hours_per_day",
-        arguments.get("work_hours_per_day"),
-    );
-    set_mixed_array(cal, "closed_weekdays", arguments.get("closed_weekdays"));
-    set_string_array(cal, "closed_dates", arguments.get("closed_dates"));
-    set_string_array(cal, "open_dates", arguments.get("open_dates"));
-    set_f64_map(cal, "day_hours", arguments.get("day_hours"));
-    set_opt_str(cal, "schedule_mode", arguments.get("schedule_mode"));
-    set_opt_f64(
-        cal,
-        "overwork_limit_percent",
-        arguments.get("overwork_limit_percent"),
-    );
-    set_opt_f64(cal, "max_utilization", arguments.get("max_utilization"));
-
-    // schedule_mode is also accepted at the top level for parity with VSCode.
-    if let Some(mode) = arguments.get("schedule_mode").and_then(|v| v.as_str()) {
-        doc["schedule_mode"] = toml_edit::Item::Value(toml_edit::Value::from(mode));
-    }
-
-    save_doc(&path, &doc)?;
-    Ok("Updated calendar configuration".to_string())
-}
-
-/// handoff_update_labels — replace the top-level `labels` array.
-pub fn handle_update_labels(arguments: &Value) -> Result<String> {
-    let path = config_path(arguments)?;
-    let labels = arguments
-        .get("labels")
-        .and_then(|v| v.as_array())
-        .ok_or_else(|| anyhow::anyhow!("'labels' (array of strings) is required"))?;
-
-    let mut doc = load_doc(&path)?;
-    let mut arr = toml_edit::Array::new();
-    for it in labels {
-        if let Some(s) = it.as_str() {
-            arr.push(s);
-        }
-    }
-    let count = arr.len();
-    doc["labels"] = toml_edit::Item::Value(toml_edit::Value::Array(arr));
-
-    save_doc(&path, &doc)?;
-    Ok(format!("Set {count} project label(s)"))
-}
-
-/// handoff_start_project — record the project start timestamp and, when
-/// `shift_dates` is true, move every task's start/due dates so the earliest
-/// start lands on `start_date`. Mirrors the VSCode startProject command.
-pub fn handle_start_project(arguments: &Value) -> Result<String> {
-    let path = config_path(arguments)?;
-
-    // start_date defaults to today (UTC).
-    let start_date_str = match arguments.get("start_date").and_then(|v| v.as_str()) {
-        Some(s) => s.to_string(),
-        None => Utc::now().format("%Y-%m-%d").to_string(),
-    };
-    let start_date = NaiveDate::parse_from_str(&start_date_str, "%Y-%m-%d").map_err(|_| {
-        anyhow::anyhow!("Invalid start_date '{start_date_str}' (expected YYYY-MM-DD)")
-    })?;
-
-    let mut doc = load_doc(&path)?;
-    doc["started_at"] = toml_edit::Item::Value(toml_edit::Value::from(start_date_str.as_str()));
-    save_doc(&path, &doc)?;
-
-    let shift = arguments
-        .get("shift_dates")
-        .and_then(|v| v.as_bool())
-        .unwrap_or(false);
-
-    if !shift {
-        return Ok(format!("Set project start to {start_date_str}"));
-    }
-
-    let tasks_dir = path
-        .parent()
-        .map(|p| p.join("tasks"))
-        .ok_or_else(|| anyhow::anyhow!("Cannot locate tasks dir"))?;
-    let shifted = shift_all_dates(&tasks_dir, start_date)?;
-
-    Ok(format!(
-        "Set project start to {start_date_str} and shifted dates on {shifted} task(s)"
-    ))
-}
-
-/// Find the earliest task start date and shift all task start/due dates so that
-/// earliest start aligns to `target`. Returns the number of tasks changed.
-fn shift_all_dates(tasks_dir: &Path, target: NaiveDate) -> Result<usize> {
-    use crate::storage::tasks::{read_task, write_task};
-
-    let dirs = collect_task_dirs(tasks_dir)?;
-
-    // Pass 1: find earliest start date.
-    let mut earliest: Option<NaiveDate> = None;
-    for dir in &dirs {
-        if let Some((data, _)) = read_task(dir)? {
-            if let Some(sd) = data.schedule.as_ref().and_then(|s| s.start_date.as_deref()) {
-                if let Ok(d) = NaiveDate::parse_from_str(sd, "%Y-%m-%d") {
-                    earliest = Some(earliest.map_or(d, |e| e.min(d)));
-                }
-            }
-        }
-    }
-    let earliest = match earliest {
-        Some(d) => d,
-        None => return Ok(0), // no dated tasks → nothing to shift
-    };
-    let delta = (target - earliest).num_days();
-    if delta == 0 {
-        return Ok(0);
-    }
-
-    // Pass 2: apply the shift.
-    let mut count = 0;
-    for dir in &dirs {
-        if let Some((mut data, status)) = read_task(dir)? {
-            let mut changed = false;
-            if let Some(sched) = data.schedule.as_mut() {
-                if let Some(sd) = sched.start_date.as_deref() {
-                    if let Ok(d) = NaiveDate::parse_from_str(sd, "%Y-%m-%d") {
-                        sched.start_date = Some(shift(d, delta));
-                        changed = true;
-                    }
-                }
-                if let Some(dd) = sched.due_date.as_deref() {
-                    if let Ok(d) = NaiveDate::parse_from_str(dd, "%Y-%m-%d") {
-                        sched.due_date = Some(shift(d, delta));
-                        changed = true;
-                    }
-                }
-            }
-            if changed {
-                data.updated_at = Some(Utc::now().to_rfc3339());
-                write_task(dir, &status, &data)?;
-                count += 1;
-            }
-        }
-    }
-    Ok(count)
-}
-
-fn shift(date: NaiveDate, delta_days: i64) -> String {
-    (date + Duration::days(delta_days))
-        .format("%Y-%m-%d")
-        .to_string()
-}
-
-fn collect_task_dirs(dir: &Path) -> Result<Vec<std::path::PathBuf>> {
-    let mut out = Vec::new();
-    collect_into(dir, &mut out)?;
-    Ok(out)
-}
-
-fn collect_into(dir: &Path, out: &mut Vec<std::path::PathBuf>) -> Result<()> {
-    if !dir.exists() {
-        return Ok(());
-    }
-    for entry in std::fs::read_dir(dir)? {
-        let entry = entry?;
-        let path = entry.path();
-        if path.is_dir() {
-            if crate::storage::tasks::find_task_file(&path)?.is_some() {
-                out.push(path.clone());
-            }
-            collect_into(&path, out)?;
-        }
-    }
-    Ok(())
-}

package/src/mcp/handlers/capacity.rs

@@ -1,318 +0,0 @@
-use anyhow::{Context, Result};
-use chrono::{Datelike, NaiveDate};
-use serde_json::{json, Value};
-use toml_edit::DocumentMut;
-
-use super::resolve_project_dir;
-use crate::storage::config::{read_config, weekday_to_num};
-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 config_path = handoff.join("config.toml");
-    let tasks_dir = handoff.join("tasks");
-
-    let start_date_str = arguments
-        .get("start_date")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| anyhow::anyhow!("'start_date' parameter is required (YYYY-MM-DD)"))?;
-    let end_date_str = arguments
-        .get("end_date")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| anyhow::anyhow!("'end_date' parameter is required (YYYY-MM-DD)"))?;
-    let assignee_filter = arguments.get("assignee").and_then(|v| v.as_str());
-
-    let start = NaiveDate::parse_from_str(start_date_str, "%Y-%m-%d")
-        .with_context(|| format!("Invalid start_date: {start_date_str}"))?;
-    let end = NaiveDate::parse_from_str(end_date_str, "%Y-%m-%d")
-        .with_context(|| format!("Invalid end_date: {end_date_str}"))?;
-
-    if end < start {
-        anyhow::bail!("end_date must be >= start_date");
-    }
-
-    let calendar = parse_calendar(&config_path, assignee_filter)?;
-
-    let mut days: Vec<Value> = Vec::new();
-    let mut total_hours: f64 = 0.0;
-    let mut work_days: u32 = 0;
-
-    let mut date = start;
-    while date <= end {
-        let hours = calendar.hours_for_date(&date);
-        if hours > 0.0 {
-            work_days += 1;
-            total_hours += hours;
-        }
-        days.push(json!({
-            "date": date.format("%Y-%m-%d").to_string(),
-            "capacity_hours": hours,
-            "allocated_hours": 0.0,
-        }));
-        date += chrono::Duration::days(1);
-    }
-
-    // Calculate allocated hours from tasks
-    let multiplier = read_config(&config_path)
-        .map(|c| c.settings.ai_estimate_multiplier)
-        .unwrap_or(0.2);
-    if tasks_dir.exists() {
-        let (tree, _) = build_task_index(&tasks_dir, u32::MAX)?;
-        allocate_task_hours(&tree, assignee_filter, &start, &end, &mut days, multiplier);
-    }
-
-    let allocated_hours: f64 = days
-        .iter()
-        .filter_map(|d| d.get("allocated_hours").and_then(|v| v.as_f64()))
-        .sum();
-
-    let result = json!({
-        "work_days": work_days,
-        "total_hours": total_hours,
-        "allocated_hours": allocated_hours,
-        "available_hours": (total_hours - allocated_hours).max(0.0),
-        "days": days,
-    });
-
-    serde_json::to_string_pretty(&result).map_err(Into::into)
-}
-
-struct CalendarConfig {
-    work_hours_per_day: f64,
-    closed_weekdays: Vec<u32>,
-    closed_dates: Vec<String>,
-    open_dates: Vec<String>,
-    day_hours: Vec<(String, f64)>,
-}
-
-impl CalendarConfig {
-    fn hours_for_date(&self, date: &NaiveDate) -> f64 {
-        let date_str = date.format("%Y-%m-%d").to_string();
-
-        // Check per-date hours first
-        for (d, h) in &self.day_hours {
-            if d == &date_str {
-                return *h;
-            }
-        }
-
-        // Check if explicitly open (overrides closed weekday)
-        let is_open_override = self.open_dates.iter().any(|d| d == &date_str);
-
-        // Check closed dates
-        if self.closed_dates.iter().any(|d| d == &date_str) {
-            return 0.0;
-        }
-
-        // Check closed weekdays (chrono: Mon=1 .. Sun=7, we use 0=Sun..6=Sat)
-        let weekday_num = match date.weekday() {
-            chrono::Weekday::Sun => 0,
-            chrono::Weekday::Mon => 1,
-            chrono::Weekday::Tue => 2,
-            chrono::Weekday::Wed => 3,
-            chrono::Weekday::Thu => 4,
-            chrono::Weekday::Fri => 5,
-            chrono::Weekday::Sat => 6,
-        };
-
-        if !is_open_override && self.closed_weekdays.contains(&weekday_num) {
-            return 0.0;
-        }
-
-        // Check per-weekday hours
-        let weekday_str = match weekday_num {
-            0 => "sun",
-            1 => "mon",
-            2 => "tue",
-            3 => "wed",
-            4 => "thu",
-            5 => "fri",
-            6 => "sat",
-            _ => "",
-        };
-        for (d, h) in &self.day_hours {
-            if d == weekday_str {
-                return *h;
-            }
-        }
-
-        self.work_hours_per_day
-    }
-}
-
-fn parse_calendar(config_path: &std::path::Path, assignee: Option<&str>) -> Result<CalendarConfig> {
-    let mut cal = CalendarConfig {
-        work_hours_per_day: 8.0,
-        closed_weekdays: Vec::new(),
-        closed_dates: Vec::new(),
-        open_dates: Vec::new(),
-        day_hours: Vec::new(),
-    };
-
-    if !config_path.exists() {
-        return Ok(cal);
-    }
-
-    let raw = std::fs::read_to_string(config_path).with_context(|| "Failed to read config.toml")?;
-    let doc: DocumentMut = raw.parse().with_context(|| "Failed to parse config.toml")?;
-
-    // Read project-level calendar
-    if let Some(calendar) = doc.get("calendar").and_then(|v| v.as_table()) {
-        if let Some(h) = calendar
-            .get("work_hours_per_day")
-            .and_then(|v| v.as_float().or_else(|| v.as_integer().map(|i| i as f64)))
-        {
-            cal.work_hours_per_day = h;
-        }
-        if let Some(arr) = calendar.get("closed_weekdays").and_then(|v| v.as_array()) {
-            cal.closed_weekdays = arr
-                .iter()
-                .filter_map(|v| {
-                    v.as_integer()
-                        .map(|i| i as u32)
-                        .or_else(|| v.as_str().and_then(weekday_to_num))
-                })
-                .collect();
-        }
-        if let Some(arr) = calendar.get("closed_dates").and_then(|v| v.as_array()) {
-            cal.closed_dates = arr
-                .iter()
-                .filter_map(|v| v.as_str().map(String::from))
-                .collect();
-        }
-        if let Some(arr) = calendar.get("open_dates").and_then(|v| v.as_array()) {
-            cal.open_dates = arr
-                .iter()
-                .filter_map(|v| v.as_str().map(String::from))
-                .collect();
-        }
-        if let Some(dh) = calendar.get("day_hours").and_then(|v| v.as_table()) {
-            for (k, v) in dh.iter() {
-                if let Some(h) = v.as_float().or_else(|| v.as_integer().map(|i| i as f64)) {
-                    cal.day_hours.push((k.to_string(), h));
-                }
-            }
-        }
-    }
-
-    // Override with assignee-specific calendar
-    if let Some(assignee_key) = assignee {
-        if let Some(assignees) = doc.get("assignees").and_then(|v| v.as_table()) {
-            if let Some(a) = assignees.get(assignee_key).and_then(|v| v.as_table()) {
-                if let Some(h) = a
-                    .get("work_hours_per_day")
-                    .and_then(|v| v.as_float().or_else(|| v.as_integer().map(|i| i as f64)))
-                {
-                    cal.work_hours_per_day = h;
-                }
-                if let Some(arr) = a.get("closed_weekdays").and_then(|v| v.as_array()) {
-                    cal.closed_weekdays = arr
-                        .iter()
-                        .filter_map(|v| {
-                            v.as_integer()
-                                .map(|i| i as u32)
-                                .or_else(|| v.as_str().and_then(weekday_to_num))
-                        })
-                        .collect();
-                }
-                if let Some(arr) = a.get("closed_dates").and_then(|v| v.as_array()) {
-                    for item in arr.iter() {
-                        if let Some(s) = item.as_str() {
-                            cal.closed_dates.push(s.to_string());
-                        }
-                    }
-                }
-                if let Some(arr) = a.get("open_dates").and_then(|v| v.as_array()) {
-                    for item in arr.iter() {
-                        if let Some(s) = item.as_str() {
-                            cal.open_dates.push(s.to_string());
-                        }
-                    }
-                }
-                if let Some(dh) = a.get("day_hours").and_then(|v| v.as_table()) {
-                    for (k, v) in dh.iter() {
-                        if let Some(h) = v.as_float().or_else(|| v.as_integer().map(|i| i as f64)) {
-                            cal.day_hours.push((k.to_string(), h));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(cal)
-}
-
-fn allocate_task_hours(
-    tree: &[TaskIndex],
-    assignee_filter: Option<&str>,
-    start: &NaiveDate,
-    end: &NaiveDate,
-    days: &mut [Value],
-    multiplier: f64,
-) {
-    for node in tree {
-        if is_terminal_status(&node.status) {
-            continue;
-        }
-
-        let matches_assignee = match assignee_filter {
-            Some(f) => node.assignee.as_deref() == Some(f),
-            None => true,
-        };
-
-        if matches_assignee {
-            if let Some(ref sched) = node.schedule {
-                if let (Some(ref sd), Some(ref dd)) = (&sched.start_date, &sched.due_date) {
-                    if let (Ok(task_start), Ok(task_end)) = (
-                        NaiveDate::parse_from_str(sd, "%Y-%m-%d"),
-                        NaiveDate::parse_from_str(dd, "%Y-%m-%d"),
-                    ) {
-                        // remaining_hours is already actual AI-effort progress, so it
-                        // is used as-is; the raw estimate is human-effort and gets the
-                        // AI multiplier applied to derive AI-effort allocation.
-                        let est = match sched.remaining_hours {
-                            Some(rem) => rem,
-                            None => sched.estimate_hours.unwrap_or(0.0) * multiplier,
-                        };
-                        let overlap_start = (*start).max(task_start);
-                        let overlap_end = (*end).min(task_end);
-                        if overlap_start <= overlap_end {
-                            let task_days = (task_end - task_start).num_days().max(1) as f64;
-                            let hours_per_day = est / task_days;
-
-                            let mut date = overlap_start;
-                            while date <= overlap_end {
-                                let idx = (date - *start).num_days() as usize;
-                                if idx < days.len() {
-                                    if let Some(obj) = days[idx].as_object_mut() {
-                                        let cur = obj
-                                            .get("allocated_hours")
-                                            .and_then(|v| v.as_f64())
-                                            .unwrap_or(0.0);
-                                        obj.insert(
-                                            "allocated_hours".to_string(),
-                                            json!(cur + hours_per_day),
-                                        );
-                                    }
-                                }
-                                date += chrono::Duration::days(1);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        allocate_task_hours(
-            &node.children,
-            assignee_filter,
-            start,
-            end,
-            days,
-            multiplier,
-        );
-    }
-}

package/src/mcp/handlers/check_criterion.rs

@@ -1,70 +0,0 @@
-use anyhow::Result;
-use chrono::Utc;
-use serde_json::Value;
-
-use super::resolve_project_dir;
-use crate::storage::ensure_handoff_exists;
-use crate::storage::tasks::{
-    find_task_dir_by_id, find_task_file, read_task, suggest_task_id, write_task,
-};
-
-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 task_id = arguments
-        .get("task_id")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| anyhow::anyhow!("'task_id' parameter is required"))?;
-
-    let criterion_index = arguments
-        .get("criterion_index")
-        .and_then(|v| v.as_u64())
-        .ok_or_else(|| anyhow::anyhow!("'criterion_index' parameter is required"))?
-        as usize;
-
-    let checked = arguments
-        .get("checked")
-        .and_then(|v| v.as_bool())
-        .ok_or_else(|| anyhow::anyhow!("'checked' parameter is required (boolean)"))?;
-
-    let task_dir = find_task_dir_by_id(&tasks_dir, task_id)?
-        .ok_or_else(|| anyhow::anyhow!("{}", suggest_task_id(&tasks_dir, task_id)))?;
-
-    let (mut data, status) = read_task(&task_dir)?
-        .ok_or_else(|| anyhow::anyhow!("Task file not found in {}", task_dir.display()))?;
-
-    if criterion_index >= data.done_criteria.len() {
-        anyhow::bail!(
-            "criterion_index {criterion_index} is out of range (task has {} criteria)",
-            data.done_criteria.len()
-        );
-    }
-
-    data.done_criteria[criterion_index].checked = checked;
-    data.updated_at = Some(Utc::now().to_rfc3339());
-
-    if let Some((old_path, _)) = find_task_file(&task_dir)? {
-        std::fs::remove_file(&old_path)?;
-    }
-
-    write_task(&task_dir, &status, &data)?;
-
-    let checked_count = data.done_criteria.iter().filter(|c| c.checked).count();
-    let total = data.done_criteria.len();
-
-    let result = serde_json::json!({
-        "task_id": data.id,
-        "criterion_index": criterion_index,
-        "item": data.done_criteria[criterion_index].item,
-        "checked": checked,
-        "done_criteria_summary": {
-            "total": total,
-            "checked": checked_count,
-        }
-    });
-
-    serde_json::to_string_pretty(&result).map_err(Into::into)
-}