handoff-mcp-server 0.10.0 → 0.12.0

package/src/mcp/handlers/config.rs

@@ -1,5 +1,6 @@
 use anyhow::{Context, Result};
 use serde_json::Value;
+use toml_edit::{DocumentMut, Item, Value as TomlValue};
 
 use super::resolve_project_dir;
 use crate::storage::config::{read_config, write_config};
@@ -9,9 +10,19 @@ pub fn handle_get(arguments: &Value) -> Result<String> {
     let project_dir = resolve_project_dir(arguments)?;
 
     let handoff = ensure_handoff_exists(&project_dir)?;
-    let config = read_config(&handoff.join("config.toml"))?;
-    let result = serde_json::to_value(&config).context("Failed to serialize config")?;
-    serde_json::to_string_pretty(&result).context("Failed to format config")
+    let config_path = handoff.join("config.toml");
+
+    let raw = std::fs::read_to_string(&config_path)
+        .with_context(|| format!("Failed to read config: {}", config_path.display()))?;
+    let doc: DocumentMut = raw.parse().with_context(|| "Failed to parse config.toml")?;
+
+    let toml_str = doc.to_string();
+    let toml_value: toml::Value =
+        toml::from_str(&toml_str).with_context(|| "Failed to deserialize config")?;
+    let json_value =
+        serde_json::to_value(&toml_value).with_context(|| "Failed to convert to JSON")?;
+
+    serde_json::to_string_pretty(&json_value).context("Failed to format config")
 }
 
 pub fn handle_update(arguments: &Value) -> Result<String> {
@@ -19,7 +30,6 @@ pub fn handle_update(arguments: &Value) -> Result<String> {
 
     let handoff = ensure_handoff_exists(&project_dir)?;
     let config_path = handoff.join("config.toml");
-    let mut config = read_config(&config_path)?;
 
     let updates = arguments
         .get("updates")
@@ -29,83 +39,153 @@ pub fn handle_update(arguments: &Value) -> Result<String> {
         .as_object()
         .ok_or_else(|| anyhow::anyhow!("'updates' must be an object"))?;
 
+    // Separate typed keys (settings/dashboard/project) from raw TOML keys
+    let typed_keys = [
+        "settings.history_limit",
+        "settings.done_task_limit",
+        "settings.auto_git_summary",
+        "settings.require_estimate_hours",
+        "settings.ai_estimate_multiplier",
+        "settings.context_files",
+        "dashboard.scan_dirs",
+        "dashboard.exclude_patterns",
+        "project.name",
+        "project.description",
+    ];
+
+    let mut has_typed = false;
+    let mut has_raw = false;
+
+    for key in updates.keys() {
+        if typed_keys.contains(&key.as_str()) {
+            has_typed = true;
+        } else {
+            has_raw = true;
+        }
+    }
+
     let mut applied = Vec::new();
 
-    for (key, value) in updates {
-        match key.as_str() {
-            "settings.history_limit" => {
-                if let Some(n) = value.as_u64() {
-                    config.settings.history_limit = n as u32;
-                    applied.push(format!("settings.history_limit = {n}"));
+    // Handle typed keys via existing Config struct
+    if has_typed {
+        let mut config = read_config(&config_path)?;
+        for (key, value) in updates {
+            match key.as_str() {
+                "settings.history_limit" => {
+                    if let Some(n) = value.as_u64() {
+                        config.settings.history_limit = n as u32;
+                        applied.push(format!("settings.history_limit = {n}"));
+                    }
                 }
-            }
-            "settings.done_task_limit" => {
-                if let Some(n) = value.as_u64() {
-                    config.settings.done_task_limit = n as u32;
-                    applied.push(format!("settings.done_task_limit = {n}"));
+                "settings.done_task_limit" => {
+                    if let Some(n) = value.as_u64() {
+                        config.settings.done_task_limit = n as u32;
+                        applied.push(format!("settings.done_task_limit = {n}"));
+                    }
                 }
-            }
-            "settings.auto_git_summary" => {
-                if let Some(b) = value.as_bool() {
-                    config.settings.auto_git_summary = b;
-                    applied.push(format!("settings.auto_git_summary = {b}"));
+                "settings.auto_git_summary" => {
+                    if let Some(b) = value.as_bool() {
+                        config.settings.auto_git_summary = b;
+                        applied.push(format!("settings.auto_git_summary = {b}"));
+                    }
                 }
-            }
-            "settings.context_files" => {
-                if let Some(arr) = value.as_array() {
-                    config.settings.context_files = arr
-                        .iter()
-                        .filter_map(|v| v.as_str().map(String::from))
-                        .collect();
-                    applied.push(format!(
-                        "settings.context_files = {:?}",
-                        config.settings.context_files
-                    ));
+                "settings.require_estimate_hours" => {
+                    if let Some(b) = value.as_bool() {
+                        config.settings.require_estimate_hours = b;
+                        applied.push(format!("settings.require_estimate_hours = {b}"));
+                    }
                 }
-            }
-            "dashboard.scan_dirs" => {
-                if let Some(arr) = value.as_array() {
-                    config.dashboard.scan_dirs = arr
-                        .iter()
-                        .filter_map(|v| v.as_str().map(String::from))
-                        .collect();
-                    applied.push(format!(
-                        "dashboard.scan_dirs = {:?}",
-                        config.dashboard.scan_dirs
-                    ));
+                "settings.ai_estimate_multiplier" => {
+                    if let Some(n) = value.as_f64() {
+                        if n < 0.0 {
+                            anyhow::bail!("settings.ai_estimate_multiplier must be >= 0");
+                        }
+                        config.settings.ai_estimate_multiplier = n;
+                        applied.push(format!("settings.ai_estimate_multiplier = {n}"));
+                    }
                 }
-            }
-            "dashboard.exclude_patterns" => {
-                if let Some(arr) = value.as_array() {
-                    config.dashboard.exclude_patterns = arr
-                        .iter()
-                        .filter_map(|v| v.as_str().map(String::from))
-                        .collect();
-                    applied.push(format!(
-                        "dashboard.exclude_patterns = {:?}",
-                        config.dashboard.exclude_patterns
-                    ));
+                "settings.context_files" => {
+                    if let Some(arr) = value.as_array() {
+                        config.settings.context_files = arr
+                            .iter()
+                            .filter_map(|v| v.as_str().map(String::from))
+                            .collect();
+                        applied.push(format!(
+                            "settings.context_files = {:?}",
+                            config.settings.context_files
+                        ));
+                    }
                 }
-            }
-            "project.name" => {
-                if let Some(s) = value.as_str() {
-                    config.project.name = s.to_string();
-                    applied.push(format!("project.name = {s}"));
+                "dashboard.scan_dirs" => {
+                    if let Some(arr) = value.as_array() {
+                        config.dashboard.scan_dirs = arr
+                            .iter()
+                            .filter_map(|v| v.as_str().map(String::from))
+                            .collect();
+                        applied.push(format!(
+                            "dashboard.scan_dirs = {:?}",
+                            config.dashboard.scan_dirs
+                        ));
+                    }
                 }
-            }
-            "project.description" => {
-                if let Some(s) = value.as_str() {
-                    config.project.description = Some(s.to_string());
-                    applied.push(format!("project.description = {s}"));
+                "dashboard.exclude_patterns" => {
+                    if let Some(arr) = value.as_array() {
+                        config.dashboard.exclude_patterns = arr
+                            .iter()
+                            .filter_map(|v| v.as_str().map(String::from))
+                            .collect();
+                        applied.push(format!(
+                            "dashboard.exclude_patterns = {:?}",
+                            config.dashboard.exclude_patterns
+                        ));
+                    }
                 }
-            }
-            other => {
-                applied.push(format!("{other}: unknown key (skipped)"));
+                "project.name" => {
+                    if let Some(s) = value.as_str() {
+                        config.project.name = s.to_string();
+                        applied.push(format!("project.name = {s}"));
+                    }
+                }
+                "project.description" => {
+                    if let Some(s) = value.as_str() {
+                        config.project.description = Some(s.to_string());
+                        applied.push(format!("project.description = {s}"));
+                    }
+                }
+                _ => {}
             }
         }
+        write_config(&config_path, &config)?;
     }
 
-    write_config(&config_path, &config)?;
+    // Handle raw TOML keys (calendar, assignees, effort_budget, gantt_view, etc.)
+    if has_raw {
+        let raw = std::fs::read_to_string(&config_path)
+            .with_context(|| format!("Failed to read config: {}", config_path.display()))?;
+        let mut doc: DocumentMut = raw
+            .parse()
+            .with_context(|| "Failed to parse config.toml for raw update")?;
+
+        for (key, value) in updates {
+            if typed_keys.contains(&key.as_str()) {
+                continue;
+            }
+
+            let parts: Vec<&str> = key.split('.').collect();
+            if parts.is_empty() {
+                applied.push(format!("{key}: invalid key"));
+                continue;
+            }
+
+            match set_toml_value(&mut doc, &parts, value) {
+                Ok(()) => applied.push(format!("{key} = {value}")),
+                Err(e) => applied.push(format!("{key}: error ({e})")),
+            }
+        }
+
+        crate::storage::atomic_write(&config_path, doc.to_string().as_bytes())
+            .with_context(|| format!("Failed to write config: {}", config_path.display()))?;
+    }
 
     if applied.is_empty() {
         Ok("No updates applied".to_string())
@@ -113,3 +193,85 @@ pub fn handle_update(arguments: &Value) -> Result<String> {
         Ok(format!("Updated config:\n{}", applied.join("\n")))
     }
 }
+
+fn set_toml_value(doc: &mut DocumentMut, parts: &[&str], json_val: &Value) -> Result<()> {
+    let toml_val = json_to_toml_value(json_val)?;
+
+    match parts.len() {
+        1 => {
+            doc[parts[0]] = Item::Value(toml_val);
+        }
+        2 => {
+            if !doc.contains_table(parts[0]) {
+                doc[parts[0]] = Item::Table(toml_edit::Table::new());
+            }
+            doc[parts[0]][parts[1]] = Item::Value(toml_val);
+        }
+        3 => {
+            if !doc.contains_table(parts[0]) {
+                doc[parts[0]] = Item::Table(toml_edit::Table::new());
+            }
+            let table = doc[parts[0]]
+                .as_table_mut()
+                .ok_or_else(|| anyhow::anyhow!("{} is not a table", parts[0]))?;
+            if !table.contains_table(parts[1]) {
+                table[parts[1]] = Item::Table(toml_edit::Table::new());
+            }
+            table[parts[1]][parts[2]] = Item::Value(toml_val);
+        }
+        4 => {
+            if !doc.contains_table(parts[0]) {
+                doc[parts[0]] = Item::Table(toml_edit::Table::new());
+            }
+            let t0 = doc[parts[0]]
+                .as_table_mut()
+                .ok_or_else(|| anyhow::anyhow!("{} is not a table", parts[0]))?;
+            if !t0.contains_table(parts[1]) {
+                t0[parts[1]] = Item::Table(toml_edit::Table::new());
+            }
+            let t1 = t0[parts[1]]
+                .as_table_mut()
+                .ok_or_else(|| anyhow::anyhow!("{}.{} is not a table", parts[0], parts[1]))?;
+            if !t1.contains_table(parts[2]) {
+                t1[parts[2]] = Item::Table(toml_edit::Table::new());
+            }
+            t1[parts[2]][parts[3]] = Item::Value(toml_val);
+        }
+        _ => {
+            anyhow::bail!("Key depth > 4 not supported");
+        }
+    }
+
+    Ok(())
+}
+
+fn json_to_toml_value(val: &Value) -> Result<TomlValue> {
+    match val {
+        Value::String(s) => Ok(TomlValue::from(s.as_str())),
+        Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                Ok(TomlValue::from(i))
+            } else if let Some(f) = n.as_f64() {
+                Ok(TomlValue::from(f))
+            } else {
+                anyhow::bail!("Unsupported number: {n}")
+            }
+        }
+        Value::Bool(b) => Ok(TomlValue::from(*b)),
+        Value::Array(arr) => {
+            let mut toml_arr = toml_edit::Array::new();
+            for item in arr {
+                toml_arr.push(json_to_toml_value(item)?);
+            }
+            Ok(TomlValue::Array(toml_arr))
+        }
+        Value::Object(obj) => {
+            let mut inline = toml_edit::InlineTable::new();
+            for (k, v) in obj {
+                inline.insert(k, json_to_toml_value(v)?);
+            }
+            Ok(TomlValue::InlineTable(inline))
+        }
+        Value::Null => Ok(TomlValue::from("")),
+    }
+}

package/src/mcp/handlers/config_crud.rs

@@ -0,0 +1,183 @@
+//! Shared helpers for config.toml CRUD handlers (assignees, milestones,
+//! calendar, labels, project start). All mutate the raw TOML document via
+//! `toml_edit` so that comments and unrelated keys are preserved, then write it
+//! back atomically.
+
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result};
+use serde_json::Value;
+use toml_edit::{Array, DocumentMut, Item, Value as TomlValue};
+
+use super::resolve_project_dir;
+use crate::storage::ensure_handoff_exists;
+
+/// Resolve the project dir, ensure `.handoff/` exists, and return the
+/// config.toml path.
+pub fn config_path(arguments: &Value) -> Result<PathBuf> {
+    let project_dir = resolve_project_dir(arguments)?;
+    let handoff = ensure_handoff_exists(&project_dir)?;
+    Ok(handoff.join("config.toml"))
+}
+
+/// Parse config.toml into a mutable document.
+pub fn load_doc(path: &Path) -> Result<DocumentMut> {
+    let raw = std::fs::read_to_string(path)
+        .with_context(|| format!("Failed to read config: {}", path.display()))?;
+    raw.parse::<DocumentMut>()
+        .with_context(|| format!("Failed to parse config: {}", path.display()))
+}
+
+/// Serialize and atomically write the document back to disk.
+pub fn save_doc(path: &Path, doc: &DocumentMut) -> Result<()> {
+    crate::storage::atomic_write(path, doc.to_string().as_bytes())
+        .with_context(|| format!("Failed to write config: {}", path.display()))
+}
+
+/// Required string argument or a descriptive error.
+pub fn require_str<'a>(arguments: &'a Value, key: &str) -> Result<&'a str> {
+    arguments
+        .get(key)
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| anyhow::anyhow!("'{key}' is required"))
+}
+
+/// Set `table[field]` to a string if the JSON arg is present; if it is JSON
+/// null, remove the key (allows clearing a value).
+pub fn set_opt_str(table: &mut toml_edit::Table, field: &str, arg: Option<&Value>) {
+    match arg {
+        Some(Value::Null) => {
+            table.remove(field);
+        }
+        Some(v) => {
+            if let Some(s) = v.as_str() {
+                table[field] = Item::Value(TomlValue::from(s));
+            }
+        }
+        None => {}
+    }
+}
+
+/// Set `table[field]` to a number if present; null removes it.
+pub fn set_opt_f64(table: &mut toml_edit::Table, field: &str, arg: Option<&Value>) {
+    match arg {
+        Some(Value::Null) => {
+            table.remove(field);
+        }
+        Some(v) => {
+            if let Some(n) = v.as_f64() {
+                table[field] = Item::Value(TomlValue::from(n));
+            }
+        }
+        None => {}
+    }
+}
+
+/// Set `table[field]` to a bool if present; null removes it.
+pub fn set_opt_bool(table: &mut toml_edit::Table, field: &str, arg: Option<&Value>) {
+    match arg {
+        Some(Value::Null) => {
+            table.remove(field);
+        }
+        Some(v) => {
+            if let Some(b) = v.as_bool() {
+                table[field] = Item::Value(TomlValue::from(b));
+            }
+        }
+        None => {}
+    }
+}
+
+/// Set `table[field]` to a TOML array of strings if the JSON arg is an array;
+/// null removes it.
+pub fn set_string_array(table: &mut toml_edit::Table, field: &str, arg: Option<&Value>) {
+    match arg {
+        Some(Value::Null) => {
+            table.remove(field);
+        }
+        Some(Value::Array(items)) => {
+            let mut arr = Array::new();
+            for it in items {
+                if let Some(s) = it.as_str() {
+                    arr.push(s);
+                }
+            }
+            table[field] = Item::Value(TomlValue::Array(arr));
+        }
+        _ => {}
+    }
+}
+
+/// Set `table[field]` to a TOML array preserving integer-or-string items
+/// (used for `closed_weekdays`, which may be numbers or weekday names); null removes it.
+pub fn set_mixed_array(table: &mut toml_edit::Table, field: &str, arg: Option<&Value>) {
+    match arg {
+        Some(Value::Null) => {
+            table.remove(field);
+        }
+        Some(Value::Array(items)) => {
+            let mut arr = Array::new();
+            for it in items {
+                if let Some(i) = it.as_i64() {
+                    arr.push(i);
+                } else if let Some(s) = it.as_str() {
+                    arr.push(s);
+                }
+            }
+            table[field] = Item::Value(TomlValue::Array(arr));
+        }
+        _ => {}
+    }
+}
+
+/// Replace a nested `[parent.<key>.<field>]`-style map of `{name: hours}` with
+/// the provided JSON object (e.g. `day_hours`). null removes the whole sub-table.
+pub fn set_f64_map(table: &mut toml_edit::Table, field: &str, arg: Option<&Value>) {
+    match arg {
+        Some(Value::Null) => {
+            table.remove(field);
+        }
+        Some(Value::Object(map)) => {
+            let mut sub = toml_edit::Table::new();
+            sub.set_implicit(false);
+            for (k, v) in map {
+                if let Some(n) = v.as_f64() {
+                    sub[k] = Item::Value(TomlValue::from(n));
+                }
+            }
+            table[field] = Item::Table(sub);
+        }
+        _ => {}
+    }
+}
+
+/// Get a mutable reference to `doc[section]` as a table, creating it if absent.
+pub fn ensure_table<'a>(
+    doc: &'a mut DocumentMut,
+    section: &str,
+) -> Result<&'a mut toml_edit::Table> {
+    if !doc.contains_table(section) {
+        doc[section] = Item::Table(toml_edit::Table::new());
+    }
+    doc[section]
+        .as_table_mut()
+        .ok_or_else(|| anyhow::anyhow!("[{section}] exists but is not a table"))
+}
+
+/// Get a mutable reference to `doc[section][key]` as a table, creating both if
+/// absent. Marks the parent as a dotted/implicit table so it serializes as
+/// `[section.key]`.
+pub fn ensure_subtable<'a>(
+    doc: &'a mut DocumentMut,
+    section: &str,
+    key: &str,
+) -> Result<&'a mut toml_edit::Table> {
+    let parent = ensure_table(doc, section)?;
+    parent.set_implicit(true);
+    if !parent.contains_table(key) {
+        parent[key] = Item::Table(toml_edit::Table::new());
+    }
+    parent[key]
+        .as_table_mut()
+        .ok_or_else(|| anyhow::anyhow!("[{section}.{key}] exists but is not a table"))
+}

package/src/mcp/handlers/get_session.rs

@@ -0,0 +1,48 @@
+use anyhow::{Context, Result};
+use serde_json::Value;
+
+use super::resolve_project_dir;
+use crate::storage::ensure_handoff_exists;
+
+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 session_id = arguments
+        .get("session_id")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| anyhow::anyhow!("'session_id' parameter is required"))?;
+
+    if !sessions_dir.exists() {
+        anyhow::bail!("Sessions directory not found");
+    }
+
+    for entry in std::fs::read_dir(&sessions_dir)
+        .with_context(|| format!("Failed to read sessions dir: {}", sessions_dir.display()))?
+    {
+        let entry = entry?;
+        let name = entry.file_name().to_string_lossy().to_string();
+        if !name.ends_with(".json") {
+            continue;
+        }
+
+        let content = match std::fs::read_to_string(entry.path()) {
+            Ok(c) => c,
+            Err(_) => continue,
+        };
+        let data: Value = match serde_json::from_str(&content) {
+            Ok(d) => d,
+            Err(_) => continue,
+        };
+
+        let file_id = data.get("id").and_then(|v| v.as_str()).unwrap_or("");
+        if file_id == session_id || name.contains(session_id) {
+            return serde_json::to_string_pretty(&data).map_err(Into::into);
+        }
+    }
+
+    anyhow::bail!(
+        "Session not found: {session_id}. Use handoff_list_sessions to see available session IDs."
+    )
+}

package/src/mcp/handlers/get_task.rs

@@ -40,6 +40,7 @@ pub fn handle(arguments: &Value) -> Result<String> {
         "schedule": data.schedule,
         "dependencies": data.dependencies,
         "order": data.order,
+        "assignee": data.assignee,
     });
 
     serde_json::to_string_pretty(&result).map_err(Into::into)

package/src/mcp/handlers/import_context.rs

@@ -250,6 +250,11 @@ fn create_task_recursive(
             .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: std::collections::HashMap::new(),
     };
 
     write_task(&task_dir, status, &data)?;
@@ -340,9 +345,11 @@ fn extract_schedule(val: &Value) -> Option<Schedule> {
             .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()),
     })
 }