handoff-mcp-server 0.26.0 → 0.27.0

package/src/mcp/handlers/config.rs

@@ -1,402 +0,0 @@
-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};
-use crate::storage::ensure_handoff_exists;
-
-pub fn handle_get(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 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> {
-    let project_dir = resolve_project_dir(arguments)?;
-
-    let handoff = ensure_handoff_exists(&project_dir)?;
-    let config_path = handoff.join("config.toml");
-
-    let updates = arguments
-        .get("updates")
-        .ok_or_else(|| anyhow::anyhow!("'updates' parameter is required"))?;
-
-    let updates = updates
-        .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",
-        "settings.memory_enabled",
-        "settings.memory_dup_threshold",
-        "settings.memory_query_min_score",
-        "settings.memory_query_relative_threshold",
-        "settings.memory_query_limit",
-        "settings.memory_stale_days",
-        "settings.memory_injected_gc_days",
-        "settings.timer_provider",
-        "settings.timer_authority_ttl_secs",
-        "settings.timer_idle_timeout_minutes",
-        "dashboard.scan_dirs",
-        "dashboard.exclude_patterns",
-        "dashboard.max_depth",
-        "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();
-
-    // 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.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.require_estimate_hours" => {
-                    if let Some(b) = value.as_bool() {
-                        config.settings.require_estimate_hours = b;
-                        applied.push(format!("settings.require_estimate_hours = {b}"));
-                    }
-                }
-                "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}"));
-                    }
-                }
-                "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.memory_enabled" => {
-                    let Some(b) = value.as_bool() else {
-                        anyhow::bail!("settings.memory_enabled must be a boolean");
-                    };
-                    config.settings.memory_enabled = b;
-                    applied.push(format!("settings.memory_enabled = {b}"));
-                }
-                "settings.memory_dup_threshold" => {
-                    let Some(n) = value.as_f64() else {
-                        anyhow::bail!("settings.memory_dup_threshold must be a number");
-                    };
-                    if !(0.0..=1.0).contains(&n) {
-                        anyhow::bail!("settings.memory_dup_threshold must be between 0 and 1");
-                    }
-                    config.settings.memory_dup_threshold = n;
-                    applied.push(format!("settings.memory_dup_threshold = {n}"));
-                }
-                "settings.memory_query_min_score" => {
-                    let Some(n) = value.as_f64() else {
-                        anyhow::bail!("settings.memory_query_min_score must be a number");
-                    };
-                    if n < 0.0 {
-                        anyhow::bail!("settings.memory_query_min_score must be >= 0");
-                    }
-                    config.settings.memory_query_min_score = n;
-                    applied.push(format!("settings.memory_query_min_score = {n}"));
-                }
-                "settings.memory_query_relative_threshold" => {
-                    let Some(n) = value.as_f64() else {
-                        anyhow::bail!("settings.memory_query_relative_threshold must be a number");
-                    };
-                    if !(0.0..=1.0).contains(&n) {
-                        anyhow::bail!(
-                            "settings.memory_query_relative_threshold must be between 0 and 1"
-                        );
-                    }
-                    config.settings.memory_query_relative_threshold = n;
-                    applied.push(format!("settings.memory_query_relative_threshold = {n}"));
-                }
-                "settings.memory_query_limit" => {
-                    let Some(n) = value.as_u64() else {
-                        anyhow::bail!("settings.memory_query_limit must be a non-negative integer");
-                    };
-                    if n == 0 {
-                        anyhow::bail!("settings.memory_query_limit must be >= 1");
-                    }
-                    config.settings.memory_query_limit = n as u32;
-                    applied.push(format!("settings.memory_query_limit = {n}"));
-                }
-                "settings.memory_stale_days" => {
-                    let Some(n) = value.as_i64() else {
-                        anyhow::bail!("settings.memory_stale_days must be an integer");
-                    };
-                    if n < 0 {
-                        anyhow::bail!("settings.memory_stale_days must be >= 0");
-                    }
-                    config.settings.memory_stale_days = n;
-                    applied.push(format!("settings.memory_stale_days = {n}"));
-                }
-                "settings.memory_injected_gc_days" => {
-                    let Some(n) = value.as_i64() else {
-                        anyhow::bail!("settings.memory_injected_gc_days must be an integer");
-                    };
-                    if n < 0 {
-                        anyhow::bail!("settings.memory_injected_gc_days must be >= 0");
-                    }
-                    config.settings.memory_injected_gc_days = n;
-                    applied.push(format!("settings.memory_injected_gc_days = {n}"));
-                }
-                "settings.timer_provider" => {
-                    let Some(s) = value.as_str() else {
-                        anyhow::bail!("settings.timer_provider must be a string");
-                    };
-                    let valid = ["auto", "vscode", "mcp", "off"];
-                    if !valid.contains(&s) {
-                        anyhow::bail!(
-                            "settings.timer_provider must be one of: {}",
-                            valid.join(", ")
-                        );
-                    }
-                    config.settings.timer_provider = s.to_string();
-                    applied.push(format!("settings.timer_provider = {s}"));
-                }
-                "settings.timer_authority_ttl_secs" => {
-                    let Some(n) = value.as_u64() else {
-                        anyhow::bail!(
-                            "settings.timer_authority_ttl_secs must be a positive integer"
-                        );
-                    };
-                    if n == 0 {
-                        anyhow::bail!("settings.timer_authority_ttl_secs must be >= 1");
-                    }
-                    config.settings.timer_authority_ttl_secs = n;
-                    applied.push(format!("settings.timer_authority_ttl_secs = {n}"));
-                }
-                "settings.timer_idle_timeout_minutes" => {
-                    let Some(n) = value.as_u64() else {
-                        anyhow::bail!(
-                            "settings.timer_idle_timeout_minutes must be a non-negative integer"
-                        );
-                    };
-                    config.settings.timer_idle_timeout_minutes = n;
-                    applied.push(format!("settings.timer_idle_timeout_minutes = {n}"));
-                }
-                "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
-                        ));
-                    }
-                }
-                "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
-                        ));
-                    }
-                }
-                "dashboard.max_depth" => {
-                    let Some(n) = value.as_u64() else {
-                        anyhow::bail!("dashboard.max_depth must be a non-negative integer");
-                    };
-                    if n == 0 {
-                        anyhow::bail!("dashboard.max_depth must be >= 1");
-                    }
-                    config.dashboard.max_depth = n as usize;
-                    applied.push(format!("dashboard.max_depth = {n}"));
-                }
-                "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)?;
-    }
-
-    // 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())
-    } else {
-        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

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