handoff-mcp-server 0.26.0 → 0.28.0

package/src/mcp/handlers/update_session.rs

@@ -1,197 +0,0 @@
-use anyhow::{Context, Result};
-use serde_json::Value;
-
-use super::resolve_project_dir;
-use crate::storage::ensure_handoff_exists;
-use crate::storage::sessions::{read_active_sessions, SessionData};
-
-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 target_session_id = arguments.get("session_id").and_then(|v| v.as_str());
-
-    let active = read_active_sessions(&sessions_dir)?;
-    if active.is_empty() {
-        anyhow::bail!(
-            "No active session. Call save_context with session_status='active' to create one first."
-        );
-    }
-
-    let session = if let Some(tid) = target_session_id {
-        active
-            .iter()
-            .find(|s| {
-                s.id.as_deref()
-                    .is_some_and(|id| id == tid || id.starts_with(tid) || tid.starts_with(id))
-            })
-            .ok_or_else(|| anyhow::anyhow!("session_id '{tid}' not found among active sessions"))?
-    } else if active.len() == 1 {
-        &active[0]
-    } else {
-        active.last().unwrap()
-    };
-    let sid = session.id.as_deref().unwrap_or("");
-
-    let checklist_index = arguments
-        .get("checklist_index")
-        .and_then(|v| v.as_u64())
-        .map(|v| v as usize);
-    let checklist_checked = arguments.get("checklist_checked").and_then(|v| v.as_bool());
-    let add_checklist_item = arguments.get("add_checklist_item").and_then(|v| v.as_str());
-    let add_decision = arguments.get("add_decision");
-    let add_handoff_note = arguments.get("add_handoff_note");
-    let add_context_pointer = arguments.get("add_context_pointer");
-
-    let mut data = session.clone();
-    let mut changes = Vec::new();
-
-    if let Some(idx) = checklist_index {
-        let checked = checklist_checked.unwrap_or(true);
-        if idx >= data.checklist.len() {
-            anyhow::bail!(
-                "checklist_index {idx} out of range (session has {} items)",
-                data.checklist.len()
-            );
-        }
-        if let Some(item) = data.checklist.get_mut(idx) {
-            item["checked"] = serde_json::json!(checked);
-            let item_text = item
-                .get("item")
-                .and_then(|v| v.as_str())
-                .unwrap_or("(unknown)");
-            changes.push(format!(
-                "checklist[{idx}] '{}' → {}",
-                item_text,
-                if checked { "checked" } else { "unchecked" }
-            ));
-        }
-    }
-
-    if let Some(item_text) = add_checklist_item {
-        let owner = arguments
-            .get("checklist_owner")
-            .and_then(|v| v.as_str())
-            .unwrap_or("ai");
-        data.checklist.push(serde_json::json!({
-            "item": item_text,
-            "checked": false,
-            "owner": owner
-        }));
-        changes.push(format!("added checklist item: '{item_text}'"));
-    }
-
-    if let Some(decision) = add_decision {
-        if decision.is_object() {
-            data.decisions.push(decision.clone());
-            let desc = decision
-                .get("decision")
-                .and_then(|v| v.as_str())
-                .unwrap_or("(decision)");
-            changes.push(format!("added decision: '{desc}'"));
-        } else {
-            anyhow::bail!("add_decision must be an object with at least a 'decision' field");
-        }
-    }
-
-    if let Some(note) = add_handoff_note {
-        if note.is_object() {
-            data.handoff_notes.push(note.clone());
-            let text = note
-                .get("note")
-                .and_then(|v| v.as_str())
-                .unwrap_or("(note)");
-            changes.push(format!("added handoff_note: '{}'", truncate(text, 60)));
-        } else {
-            anyhow::bail!("add_handoff_note must be an object with at least a 'note' field");
-        }
-    }
-
-    if let Some(pointer) = add_context_pointer {
-        if pointer.is_object() {
-            data.context_pointers.push(pointer.clone());
-            let path = pointer
-                .get("path")
-                .and_then(|v| v.as_str())
-                .unwrap_or("(path)");
-            changes.push(format!("added context_pointer: '{path}'"));
-        } else {
-            anyhow::bail!("add_context_pointer must be an object with at least a 'path' field");
-        }
-    }
-
-    if changes.is_empty() {
-        anyhow::bail!(
-            "No updates specified. Use checklist_index, add_checklist_item, \
-             add_decision, add_handoff_note, or add_context_pointer."
-        );
-    }
-
-    write_active_session_data(&sessions_dir, sid, &data)?;
-
-    let mut msg = format!("Session {} updated:", sid);
-    for c in &changes {
-        msg.push_str(&format!("\n  - {c}"));
-    }
-
-    let checked_count = data
-        .checklist
-        .iter()
-        .filter(|item| {
-            item.get("checked")
-                .and_then(|v| v.as_bool())
-                .unwrap_or(false)
-        })
-        .count();
-    msg.push_str(&format!(
-        "\nChecklist: {}/{} checked",
-        checked_count,
-        data.checklist.len()
-    ));
-
-    Ok(msg)
-}
-
-fn truncate(s: &str, max_chars: usize) -> String {
-    let mut chars = s.chars();
-    let truncated: String = chars.by_ref().take(max_chars).collect();
-    if chars.next().is_some() {
-        format!("{truncated}...")
-    } else {
-        truncated
-    }
-}
-
-fn write_active_session_data(
-    sessions_dir: &std::path::Path,
-    session_id: &str,
-    data: &SessionData,
-) -> Result<()> {
-    let suffix = ".active.json";
-
-    for entry in std::fs::read_dir(sessions_dir)? {
-        let entry = entry?;
-        let name = entry.file_name().to_string_lossy().to_string();
-        if !name.ends_with(suffix) {
-            continue;
-        }
-
-        let content = std::fs::read_to_string(entry.path())
-            .with_context(|| format!("Failed to read session: {}", entry.path().display()))?;
-        let existing: SessionData = serde_json::from_str(&content)
-            .with_context(|| format!("Failed to parse session: {}", entry.path().display()))?;
-
-        let file_id = existing.id.as_deref().unwrap_or("");
-        if file_id != session_id {
-            continue;
-        }
-
-        let updated = serde_json::to_string_pretty(data).context("Failed to serialize session")?;
-        crate::storage::atomic_write(entry.path(), updated.as_bytes())
-            .with_context(|| format!("Failed to write session: {}", entry.path().display()))?;
-        return Ok(());
-    }
-
-    anyhow::bail!("Active session '{session_id}' not found on disk")
-}

package/src/mcp/handlers/update_task.rs

@@ -1,452 +0,0 @@
-use std::collections::HashMap;
-
-use anyhow::{Context, Result};
-use chrono::Utc;
-use serde_json::Value;
-
-use super::resolve_project_dir;
-use crate::storage::config::read_config;
-use crate::storage::ensure_handoff_exists;
-use crate::storage::tasks::*;
-
-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 require_estimate_hours = read_config(&handoff.join("config.toml"))
-        .map(|c| c.settings.require_estimate_hours)
-        .unwrap_or(true);
-
-    let task_val = arguments
-        .get("task")
-        .ok_or_else(|| anyhow::anyhow!("'task' parameter is required"))?;
-
-    let task_id = task_val.get("id").and_then(|v| v.as_str());
-    let move_to = arguments.get("move_to").and_then(|v| v.as_str());
-
-    if let Some(existing_id) = task_id {
-        if let Some(new_parent_id) = move_to {
-            return handle_move(&tasks_dir, existing_id, new_parent_id);
-        }
-        let task_exists = find_task_dir_by_id(&tasks_dir, existing_id)?.is_some();
-        if task_exists {
-            return handle_update(&tasks_dir, existing_id, task_val, require_estimate_hours);
-        }
-        return handle_upsert_create(
-            &tasks_dir,
-            existing_id,
-            task_val,
-            arguments,
-            require_estimate_hours,
-        );
-    }
-
-    let title = task_val
-        .get("title")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| anyhow::anyhow!("'task.title' is required for new tasks"))?;
-
-    handle_create(
-        &tasks_dir,
-        title,
-        task_val,
-        arguments,
-        require_estimate_hours,
-    )
-}
-
-fn handle_create(
-    tasks_dir: &std::path::Path,
-    title: &str,
-    task_val: &Value,
-    arguments: &Value,
-    require_estimate_hours: bool,
-) -> Result<String> {
-    let parent_id = arguments.get("parent_id").and_then(|v| v.as_str());
-
-    let (new_id, parent_dir) = match parent_id {
-        Some(pid) => {
-            let parent_dir = find_task_dir_by_id(tasks_dir, pid)?
-                .ok_or_else(|| anyhow::anyhow!("{}", suggest_task_id(tasks_dir, pid)))?;
-            let id = next_child_id(&parent_dir, pid)?;
-            (id, parent_dir)
-        }
-        None => {
-            let id = next_top_level_id(tasks_dir)?;
-            (id, tasks_dir.to_path_buf())
-        }
-    };
-
-    let slug = title_to_slug(title);
-    let dir_name = format!("{new_id}-{slug}");
-    let task_dir = parent_dir.join(&dir_name);
-
-    let now = Utc::now().to_rfc3339();
-    let status = task_val
-        .get("status")
-        .and_then(|v| v.as_str())
-        .unwrap_or("todo");
-
-    if !is_valid_status(status) {
-        anyhow::bail!("Invalid status: {status}");
-    }
-
-    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(),
-        notes: task_val
-            .get("notes")
-            .and_then(|v| v.as_str())
-            .map(String::from),
-        priority: priority.map(String::from),
-        created_at: Some(now.clone()),
-        updated_at: Some(now),
-        completed_at: None,
-        labels: extract_string_array(task_val, "labels"),
-        links: extract_string_array(task_val, "links"),
-        task_links: Vec::new(),
-        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),
-        assignee: task_val
-            .get("assignee")
-            .and_then(|v| v.as_str())
-            .map(String::from),
-        extra: HashMap::new(),
-    };
-
-    // A newly created task is always a leaf (no children yet).
-    validate_estimate_required(
-        require_estimate_hours,
-        &new_id,
-        title,
-        status,
-        false,
-        true,
-        data.schedule.as_ref(),
-    )?;
-
-    // Create the directory only once every validation has passed. A rejected
-    // create must leave nothing behind: an orphan dir would burn the task ID,
-    // because `next_top_level_id` counts directories, not task files.
-    std::fs::create_dir_all(&task_dir)
-        .with_context(|| format!("Failed to create task dir: {}", task_dir.display()))?;
-
-    write_task(&task_dir, status, &data)?;
-
-    Ok(format!("Created task {new_id}: {title} [{status}]"))
-}
-
-fn handle_upsert_create(
-    tasks_dir: &std::path::Path,
-    task_id: &str,
-    task_val: &Value,
-    arguments: &Value,
-    require_estimate_hours: bool,
-) -> Result<String> {
-    let title = task_val
-        .get("title")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| {
-            let hint = suggest_task_id(tasks_dir, task_id);
-            anyhow::anyhow!("{hint}\nProvide 'title' to create a new task with this ID.")
-        })?;
-
-    let parent_id = arguments.get("parent_id").and_then(|v| v.as_str());
-
-    let parent_dir = match parent_id {
-        Some(pid) => find_task_dir_by_id(tasks_dir, pid)?
-            .ok_or_else(|| anyhow::anyhow!("{}", suggest_task_id(tasks_dir, pid)))?,
-        None => tasks_dir.to_path_buf(),
-    };
-
-    let slug = title_to_slug(title);
-    let dir_name = format!("{task_id}-{slug}");
-    let task_dir = parent_dir.join(&dir_name);
-
-    let now = Utc::now().to_rfc3339();
-    let status = task_val
-        .get("status")
-        .and_then(|v| v.as_str())
-        .unwrap_or("todo");
-
-    if !is_valid_status(status) {
-        anyhow::bail!("Invalid status: {status}");
-    }
-
-    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, task_id, &dependencies)?;
-    }
-
-    let data = TaskData {
-        id: task_id.to_string(),
-        title: title.to_string(),
-        notes: task_val
-            .get("notes")
-            .and_then(|v| v.as_str())
-            .map(String::from),
-        priority: priority.map(String::from),
-        created_at: Some(now.clone()),
-        updated_at: Some(now),
-        completed_at: None,
-        labels: extract_string_array(task_val, "labels"),
-        links: extract_string_array(task_val, "links"),
-        task_links: Vec::new(),
-        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),
-        assignee: task_val
-            .get("assignee")
-            .and_then(|v| v.as_str())
-            .map(String::from),
-        extra: HashMap::new(),
-    };
-
-    // Upsert-create: a brand-new task is a leaf.
-    validate_estimate_required(
-        require_estimate_hours,
-        task_id,
-        title,
-        status,
-        false,
-        true,
-        data.schedule.as_ref(),
-    )?;
-
-    // Create the directory only once every validation has passed, so a rejected
-    // upsert-create leaves no orphan dir shadowing the requested ID.
-    std::fs::create_dir_all(&task_dir)
-        .with_context(|| format!("Failed to create task dir: {}", task_dir.display()))?;
-
-    write_task(&task_dir, status, &data)?;
-
-    Ok(format!("Created task {task_id}: {title} [{status}]"))
-}
-
-fn handle_update(
-    tasks_dir: &std::path::Path,
-    task_id: &str,
-    task_val: &Value,
-    require_estimate_hours: bool,
-) -> Result<String> {
-    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, current_status) = read_task(&task_dir)?
-        .ok_or_else(|| anyhow::anyhow!("Task file not found in {}", task_dir.display()))?;
-
-    if let Some(title) = task_val.get("title").and_then(|v| v.as_str()) {
-        data.title = title.to_string();
-    }
-    if let Some(notes) = task_val.get("notes").and_then(|v| v.as_str()) {
-        data.notes = Some(notes.to_string());
-    } else if let Some(append) = task_val.get("notes_append").and_then(|v| v.as_str()) {
-        let timestamp = Utc::now().format("%Y-%m-%dT%H:%M:%S");
-        let block = format!("--- {timestamp}\n{append}");
-        match &mut data.notes {
-            Some(existing) if !existing.is_empty() => {
-                existing.push_str(&format!("\n\n{block}"));
-            }
-            _ => data.notes = Some(block),
-        }
-    }
-    if let Some(priority) = task_val.get("priority").and_then(|v| v.as_str()) {
-        validate_priority(Some(priority))?;
-        data.priority = Some(priority.to_string());
-    }
-    if task_val.get("labels").is_some() {
-        data.labels = extract_string_array(task_val, "labels");
-    }
-    if task_val.get("links").is_some() {
-        data.links = extract_string_array(task_val, "links");
-    }
-    if task_val.get("done_criteria").is_some() {
-        data.done_criteria = extract_done_criteria(task_val);
-    }
-    if let Some(sched_val) = task_val.get("schedule") {
-        // Field-level merge (not full replacement) so that fields not present in
-        // the patch — e.g. actual_hours/remaining_hours accrued by the VSCode timer —
-        // are preserved. Mirrors bulk_update_tasks. (referral ref-20260623-232823)
-        let schedule = data.schedule.get_or_insert_with(Default::default);
-        if let Some(sd) = sched_val.get("start_date").and_then(|v| v.as_str()) {
-            schedule.start_date = Some(sd.to_string());
-        }
-        if let Some(dd) = sched_val.get("due_date").and_then(|v| v.as_str()) {
-            schedule.due_date = Some(dd.to_string());
-        }
-        if let Some(eh) = sched_val.get("estimate_hours").and_then(|v| v.as_f64()) {
-            schedule.estimate_hours = Some(eh);
-        }
-        if let Some(ah) = sched_val.get("actual_hours").and_then(|v| v.as_f64()) {
-            schedule.actual_hours = Some(ah);
-        }
-        if let Some(rh) = sched_val.get("remaining_hours").and_then(|v| v.as_f64()) {
-            schedule.remaining_hours = Some(rh);
-        }
-        if let Some(ms) = sched_val.get("milestone").and_then(|v| v.as_str()) {
-            schedule.milestone = Some(ms.to_string());
-        }
-        if let Some(p) = sched_val.get("pinned").and_then(|v| v.as_bool()) {
-            schedule.pinned = Some(p);
-        }
-    }
-    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);
-    }
-    if task_val.get("assignee").is_some() {
-        data.assignee = task_val
-            .get("assignee")
-            .and_then(|v| v.as_str())
-            .map(String::from);
-    }
-
-    let new_status = task_val
-        .get("status")
-        .and_then(|v| v.as_str())
-        .unwrap_or(&current_status);
-
-    if !is_valid_status(new_status) {
-        anyhow::bail!("Invalid status: {new_status}");
-    }
-
-    if new_status == "done" && current_status != "done" {
-        validate_done_transition(&task_dir, &data)?;
-        data.completed_at = Some(Utc::now().to_rfc3339());
-    }
-
-    if new_status == "skipped" && current_status != "skipped" {
-        validate_skipped_transition(&task_dir, &data)?;
-    }
-
-    // Parent tasks (with children) are exempt; only leaf tasks need an estimate.
-    let has_children = task_has_children(&task_dir)?;
-    validate_estimate_required(
-        require_estimate_hours,
-        task_id,
-        &data.title,
-        new_status,
-        has_children,
-        false,
-        data.schedule.as_ref(),
-    )?;
-
-    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, new_status, &data)?;
-
-    Ok(format!(
-        "Updated task {task_id}: {} [{new_status}]",
-        data.title
-    ))
-}
-
-fn handle_move(tasks_dir: &std::path::Path, task_id: &str, new_parent_id: &str) -> Result<String> {
-    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 new_parent_dir = find_task_dir_by_id(tasks_dir, new_parent_id)?
-        .ok_or_else(|| anyhow::anyhow!("{}", suggest_task_id(tasks_dir, new_parent_id)))?;
-
-    let dir_name = task_dir
-        .file_name()
-        .ok_or_else(|| anyhow::anyhow!("Invalid task dir"))?;
-
-    let dest = new_parent_dir.join(dir_name);
-
-    std::fs::rename(&task_dir, &dest).with_context(|| {
-        format!(
-            "Failed to move {} -> {}",
-            task_dir.display(),
-            dest.display()
-        )
-    })?;
-
-    Ok(format!("Moved task {task_id} under {new_parent_id}"))
-}
-
-fn extract_string_array(val: &Value, key: &str) -> Vec<String> {
-    val.get(key)
-        .and_then(|v| v.as_array())
-        .map(|arr| {
-            arr.iter()
-                .filter_map(|v| v.as_str().map(String::from))
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
-fn extract_done_criteria(val: &Value) -> Vec<DoneCriterion> {
-    val.get("done_criteria")
-        .and_then(|v| v.as_array())
-        .map(|arr| {
-            arr.iter()
-                .filter_map(|v| {
-                    let item = v.get("item")?.as_str()?;
-                    let checked = v.get("checked").and_then(|c| c.as_bool()).unwrap_or(false);
-                    Some(DoneCriterion {
-                        item: item.to_string(),
-                        checked,
-                    })
-                })
-                .collect()
-        })
-        .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()),
-        remaining_hours: sched.get("remaining_hours").and_then(|v| v.as_f64()),
-        milestone: sched
-            .get("milestone")
-            .and_then(|v| v.as_str())
-            .map(String::from),
-        pinned: sched.get("pinned").and_then(|v| v.as_bool()),
-    })
-}

package/src/mcp/mod.rs

@@ -1,6 +0,0 @@
-pub mod handlers;
-pub mod protocol;
-pub mod resources;
-pub mod router;
-pub mod tools;
-pub mod types;

package/src/mcp/protocol.rs

@@ -1,41 +0,0 @@
-use super::router::handle_request;
-use super::types::{JsonRpcRequest, JsonRpcResponse, INVALID_REQUEST, PARSE_ERROR};
-
-pub fn process_line(line: &str) -> Option<String> {
-    let trimmed = line.trim();
-    if trimmed.is_empty() {
-        return None;
-    }
-
-    let response = match serde_json::from_str::<JsonRpcRequest>(trimmed) {
-        Ok(req) => {
-            if req.jsonrpc != "2.0" {
-                JsonRpcResponse::error(req.id, INVALID_REQUEST, "Invalid JSON-RPC version")
-            } else {
-                let mut resp = handle_request(&req.method, req.params.as_ref());
-                if resp.id.is_none() && req.id.is_some() {
-                    resp.id = req.id;
-                }
-                if is_notification(&req.method) && resp.result.is_none() && resp.error.is_none() {
-                    return None;
-                }
-                resp
-            }
-        }
-        Err(e) => JsonRpcResponse::error(None, PARSE_ERROR, format!("Parse error: {e}")),
-    };
-
-    match serde_json::to_string(&response) {
-        Ok(s) => Some(s),
-        Err(e) => {
-            let fallback = format!(
-                r#"{{"jsonrpc":"2.0","id":null,"error":{{"code":-32603,"message":"Serialization error: {e}"}}}}"#
-            );
-            Some(fallback)
-        }
-    }
-}
-
-fn is_notification(method: &str) -> bool {
-    method.starts_with("notifications/")
-}