handoff-mcp-server 0.1.0

package/src/mcp/handlers/list_tasks.rs

@@ -0,0 +1,61 @@
+use anyhow::{Context, Result};
+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::build_task_index;
+
+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 config_path = handoff.join("config.toml");
+
+    let done_task_limit = if config_path.exists() {
+        read_config(&config_path)
+            .map(|c| c.settings.done_task_limit)
+            .unwrap_or(10)
+    } else {
+        10
+    };
+
+    let (tree, summary) = build_task_index(&tasks_dir, done_task_limit)?;
+
+    let status_filter = arguments.get("status_filter").and_then(|v| v.as_str());
+
+    let filtered_tree = if let Some(filter) = status_filter {
+        filter_tree(&tree, filter)
+    } else {
+        tree
+    };
+
+    let result = serde_json::json!({
+        "task_tree": filtered_tree,
+        "task_summary": summary,
+    });
+
+    serde_json::to_string_pretty(&result).context("Failed to serialize task list")
+}
+
+fn filter_tree(
+    tree: &[crate::storage::tasks::TaskIndex],
+    status: &str,
+) -> Vec<crate::storage::tasks::TaskIndex> {
+    tree.iter()
+        .filter_map(|node| {
+            let children = filter_tree(&node.children, status);
+            if node.status == status || !children.is_empty() {
+                Some(crate::storage::tasks::TaskIndex {
+                    id: node.id.clone(),
+                    title: node.title.clone(),
+                    status: node.status.clone(),
+                    children,
+                })
+            } else {
+                None
+            }
+        })
+        .collect()
+}

package/src/mcp/handlers/load_context.rs

@@ -0,0 +1,94 @@
+use anyhow::{Context, Result};
+use serde_json::Value;
+
+use super::resolve_project_dir;
+use crate::storage::config::read_config;
+use crate::storage::sessions::read_active_sessions;
+use crate::storage::tasks::build_task_index;
+use crate::storage::{ensure_handoff_exists, handoff_dir};
+
+pub fn handle(arguments: &Value) -> Result<String> {
+    let project_dir = resolve_project_dir(arguments)?;
+
+    let hdir = handoff_dir(&project_dir);
+    if !hdir.exists() {
+        let result = serde_json::json!({
+            "status": "not_initialized",
+            "message": format!(
+                "No .handoff/ directory found in {}. Run handoff_init to set up handoff tracking.",
+                project_dir.display()
+            )
+        });
+        return serde_json::to_string_pretty(&result).context("serialize");
+    }
+
+    let handoff = ensure_handoff_exists(&project_dir)?;
+    let sessions_dir = handoff.join("sessions");
+    let tasks_dir = handoff.join("tasks");
+    let config_path = handoff.join("config.toml");
+
+    let config = if config_path.exists() {
+        read_config(&config_path)?
+    } else {
+        anyhow::bail!("config.toml not found");
+    };
+
+    let sessions = read_active_sessions(&sessions_dir)?;
+
+    let (task_tree, task_summary) = build_task_index(&tasks_dir, config.settings.done_task_limit)?;
+
+    let last_session = sessions.last().map(|s| {
+        serde_json::json!({
+            "ended_at": s.ended_at,
+            "summary": s.summary,
+            "branch": s.branch,
+            "commit": s.commit,
+        })
+    });
+
+    let active_sessions: Vec<Value> = sessions
+        .iter()
+        .map(|s| serde_json::to_value(s).unwrap_or_default())
+        .collect();
+
+    let mut result = serde_json::json!({
+        "project": config.project.name,
+        "task_tree": task_tree,
+        "task_summary": task_summary,
+    });
+
+    if let Some(ls) = last_session {
+        result["last_session"] = ls;
+    }
+
+    if !active_sessions.is_empty() {
+        let latest = &active_sessions[active_sessions.len() - 1];
+
+        for key in [
+            "decisions",
+            "blockers",
+            "checklist",
+            "handoff_notes",
+            "references",
+            "context_pointers",
+        ] {
+            if let Some(val) = latest.get(key) {
+                if val.as_array().is_some_and(|a| !a.is_empty()) {
+                    result[key] = val.clone();
+                }
+            }
+        }
+
+        if let Some(env) = latest.get("environment") {
+            if !env.is_null() {
+                result["environment"] = env.clone();
+            }
+        }
+    }
+
+    if !config.settings.context_files.is_empty() {
+        result["suggested_reads"] = serde_json::to_value(&config.settings.context_files)?;
+    }
+
+    serde_json::to_string_pretty(&result).context("Failed to serialize context")
+}

package/src/mcp/handlers/mod.rs

@@ -0,0 +1,58 @@
+pub mod config;
+pub mod dashboard;
+pub mod init;
+pub mod list_tasks;
+pub mod load_context;
+pub mod save_context;
+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()) {
+        Some(dir) => PathBuf::from(dir),
+        None => std::env::current_dir().context("Failed to get current directory")?,
+    };
+    std::fs::canonicalize(&raw).with_context(|| format!("Invalid project path: {}", 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),
+        _ => 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)
+        }
+    }
+}

package/src/mcp/handlers/save_context.rs

@@ -0,0 +1,96 @@
+use anyhow::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::git::capture_git_state;
+use crate::storage::sessions::{
+    close_active_sessions, enforce_history_limit, write_active_session, 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 config_path = handoff.join("config.toml");
+
+    let summary = arguments
+        .get("summary")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| anyhow::anyhow!("'summary' is required"))?;
+
+    let closed = close_active_sessions(&sessions_dir)?;
+
+    let git_state = capture_git_state(&project_dir)?;
+    let now = Utc::now().to_rfc3339();
+
+    let data = SessionData {
+        version: 2,
+        ended_at: Some(now),
+        summary: summary.to_string(),
+        branch: Some(git_state.branch),
+        commit: Some(git_state.commit),
+        dirty_files: git_state.dirty_files,
+        decisions: extract_array(arguments, "decisions"),
+        blockers: extract_string_array(arguments, "blockers"),
+        checklist: extract_array(arguments, "checklist"),
+        handoff_notes: extract_array(arguments, "handoff_notes"),
+        references: extract_array(arguments, "references"),
+        context_pointers: extract_array(arguments, "context_pointers"),
+        environment: arguments.get("environment").cloned(),
+    };
+
+    let path = write_active_session(&sessions_dir, &data)?;
+
+    let history_limit = if config_path.exists() {
+        read_config(&config_path)
+            .map(|c| c.settings.history_limit)
+            .unwrap_or(20)
+    } else {
+        20
+    };
+    let removed = enforce_history_limit(&sessions_dir, history_limit)?;
+
+    let mut msg = format!(
+        "Session saved: {}\nFile: {}",
+        summary,
+        path.file_name()
+            .map(|n| n.to_string_lossy().to_string())
+            .unwrap_or_default()
+    );
+
+    if !closed.is_empty() {
+        msg.push_str(&format!(
+            "\nClosed {} previous active session(s)",
+            closed.len()
+        ));
+    }
+    if removed > 0 {
+        msg.push_str(&format!(
+            "\nRemoved {removed} old session(s) (history_limit: {history_limit})"
+        ));
+    }
+
+    Ok(msg)
+}
+
+fn extract_array(val: &Value, key: &str) -> Vec<Value> {
+    val.get(key)
+        .and_then(|v| v.as_array())
+        .cloned()
+        .unwrap_or_default()
+}
+
+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()
+}

package/src/mcp/handlers/update_task.rs

@@ -0,0 +1,207 @@
+use anyhow::{Context, Result};
+use chrono::Utc;
+use serde_json::Value;
+
+use super::resolve_project_dir;
+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 task_val = arguments
+        .get("task")
+        .ok_or_else(|| anyhow::anyhow!("'task' parameter is required"))?;
+
+    let title = task_val
+        .get("title")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| anyhow::anyhow!("'task.title' 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);
+        }
+        return handle_update(&tasks_dir, existing_id, task_val);
+    }
+
+    handle_create(&tasks_dir, title, task_val, arguments)
+}
+
+fn handle_create(
+    tasks_dir: &std::path::Path,
+    title: &str,
+    task_val: &Value,
+    arguments: &Value,
+) -> 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!("Parent task not found: {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);
+    std::fs::create_dir_all(&task_dir)
+        .with_context(|| format!("Failed to create task dir: {}", task_dir.display()))?;
+
+    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 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: task_val
+            .get("priority")
+            .and_then(|v| v.as_str())
+            .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"),
+        done_criteria: extract_done_criteria(task_val),
+    };
+
+    write_task(&task_dir, status, &data)?;
+
+    Ok(format!("Created task {new_id}: {title} [{status}]"))
+}
+
+fn handle_update(tasks_dir: &std::path::Path, task_id: &str, task_val: &Value) -> Result<String> {
+    let task_dir = find_task_dir_by_id(tasks_dir, task_id)?
+        .ok_or_else(|| anyhow::anyhow!("Task not found: {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());
+    }
+    if let Some(priority) = task_val.get("priority").and_then(|v| v.as_str()) {
+        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);
+    }
+
+    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)?;
+    }
+
+    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!("Task not found: {task_id}"))?;
+
+    let new_parent_dir = find_task_dir_by_id(tasks_dir, new_parent_id)?
+        .ok_or_else(|| anyhow::anyhow!("New parent task not found: {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()
+}

package/src/mcp/mod.rs

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

package/src/mcp/protocol.rs

@@ -0,0 +1,41 @@
+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/")
+}

package/src/mcp/resources.rs

@@ -0,0 +1,55 @@
+use anyhow::{Context, Result};
+use serde_json::{json, Value};
+
+use crate::storage::config::read_config;
+use crate::storage::sessions::read_active_sessions;
+use crate::storage::{ensure_handoff_exists, handoff_dir};
+
+pub fn handle_resource_read(uri: &str) -> Result<Value> {
+    let project_dir = std::env::current_dir().context("Failed to get current directory")?;
+    let hdir = handoff_dir(&project_dir);
+
+    if !hdir.exists() {
+        anyhow::bail!("No .handoff/ directory found. Run handoff_init first.");
+    }
+
+    let handoff = ensure_handoff_exists(&project_dir)?;
+
+    match uri {
+        "handoff://sessions" => read_sessions_resource(&handoff),
+        "handoff://config" => read_config_resource(&handoff),
+        _ => anyhow::bail!("Unknown resource URI: {uri}"),
+    }
+}
+
+fn read_sessions_resource(handoff: &std::path::Path) -> Result<Value> {
+    let sessions_dir = handoff.join("sessions");
+    let sessions = read_active_sessions(&sessions_dir)?;
+
+    let contents: Vec<Value> = sessions
+        .iter()
+        .map(|s| serde_json::to_value(s).unwrap_or_default())
+        .collect();
+
+    Ok(json!({
+        "contents": [{
+            "uri": "handoff://sessions",
+            "mimeType": "application/json",
+            "text": serde_json::to_string_pretty(&contents)?
+        }]
+    }))
+}
+
+fn read_config_resource(handoff: &std::path::Path) -> Result<Value> {
+    let config_path = handoff.join("config.toml");
+    let config = read_config(&config_path)?;
+    let toml_str = toml::to_string_pretty(&config).context("Failed to serialize config")?;
+
+    Ok(json!({
+        "contents": [{
+            "uri": "handoff://config",
+            "mimeType": "application/toml",
+            "text": toml_str
+        }]
+    }))
+}