handoff-mcp-server 0.10.0 → 0.12.0

package/src/mcp/handlers/list_sessions.rs

@@ -0,0 +1,129 @@
+use anyhow::{Context, Result};
+use serde_json::{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 status_filter = arguments.get("status_filter").and_then(|v| v.as_str());
+    let limit = arguments
+        .get("limit")
+        .and_then(|v| v.as_u64())
+        .unwrap_or(20) as usize;
+
+    if !sessions_dir.exists() {
+        return serde_json::to_string_pretty(&json!([])).map_err(Into::into);
+    }
+
+    let mut sessions: Vec<Value> = Vec::new();
+
+    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 status = extract_session_status(&name);
+        if let Some(filter) = status_filter {
+            if status != filter {
+                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 id = data
+            .get("id")
+            .and_then(|v| v.as_str())
+            .map(String::from)
+            .unwrap_or_else(|| synthesize_id_from_filename(&name));
+
+        let summary = data.get("summary").and_then(|v| v.as_str()).unwrap_or("");
+        let started_at = data.get("started_at").and_then(|v| v.as_str());
+        let ended_at = data.get("ended_at").and_then(|v| v.as_str());
+        let branch = data.get("branch").and_then(|v| v.as_str());
+        let commit = data.get("commit").and_then(|v| v.as_str());
+
+        let decisions_count = data
+            .get("decisions")
+            .and_then(|v| v.as_array())
+            .map(|a| a.len())
+            .unwrap_or(0);
+
+        let checklist = data.get("checklist").and_then(|v| v.as_array());
+        let checklist_count = checklist.map(|a| a.len()).unwrap_or(0);
+        let checklist_checked = checklist
+            .map(|a| {
+                a.iter()
+                    .filter(|item| {
+                        item.get("checked")
+                            .and_then(|v| v.as_bool())
+                            .unwrap_or(false)
+                    })
+                    .count()
+            })
+            .unwrap_or(0);
+
+        sessions.push(json!({
+            "id": id,
+            "status": status,
+            "summary": summary,
+            "started_at": started_at,
+            "ended_at": ended_at,
+            "branch": branch,
+            "commit": commit,
+            "decisions_count": decisions_count,
+            "checklist_progress": format!("{}/{}", checklist_checked, checklist_count),
+        }));
+    }
+
+    sessions.sort_by(|a, b| {
+        let a_time = a.get("ended_at").and_then(|v| v.as_str()).unwrap_or("");
+        let b_time = b.get("ended_at").and_then(|v| v.as_str()).unwrap_or("");
+        b_time.cmp(a_time)
+    });
+
+    sessions.truncate(limit);
+
+    serde_json::to_string_pretty(&sessions).map_err(Into::into)
+}
+
+fn extract_session_status(filename: &str) -> &str {
+    let name = filename.strip_suffix(".json").unwrap_or(filename);
+    if name.ends_with(".open") {
+        "open"
+    } else if name.ends_with(".active") {
+        "active"
+    } else if name.ends_with(".paused") {
+        "paused"
+    } else if name.ends_with(".closed") {
+        "closed"
+    } else {
+        "unknown"
+    }
+}
+
+fn synthesize_id_from_filename(filename: &str) -> String {
+    let name = filename.strip_suffix(".json").unwrap_or(filename);
+    let base = name
+        .strip_suffix(".open")
+        .or_else(|| name.strip_suffix(".active"))
+        .or_else(|| name.strip_suffix(".paused"))
+        .or_else(|| name.strip_suffix(".closed"))
+        .unwrap_or(name);
+    format!("s-{}", &base[..std::cmp::min(base.len(), 20)])
+}

package/src/mcp/handlers/list_tasks.rs

@@ -4,7 +4,7 @@ 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;
+use crate::storage::tasks::{build_task_index, TaskIndex};
 
 pub fn handle(arguments: &Value) -> Result<String> {
     let project_dir = resolve_project_dir(arguments)?;
@@ -24,9 +24,21 @@ pub fn handle(arguments: &Value) -> Result<String> {
     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 assignee_filter = arguments.get("assignee_filter").and_then(|v| v.as_str());
+    let milestone_filter = arguments.get("milestone_filter").and_then(|v| v.as_str());
+    let priority_filter = arguments.get("priority_filter").and_then(|v| v.as_str());
+    let label_filter = arguments.get("label_filter").and_then(|v| v.as_str());
 
-    let filtered_tree = if let Some(filter) = status_filter {
-        filter_tree(&tree, filter)
+    let filters = Filters {
+        status: status_filter,
+        assignee: assignee_filter,
+        milestone: milestone_filter,
+        priority: priority_filter,
+        label: label_filter,
+    };
+
+    let filtered_tree = if filters.any_active() {
+        filter_tree(&tree, &filters)
     } else {
         tree
     };
@@ -39,21 +51,75 @@ pub fn handle(arguments: &Value) -> Result<String> {
     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> {
+struct Filters<'a> {
+    status: Option<&'a str>,
+    assignee: Option<&'a str>,
+    milestone: Option<&'a str>,
+    priority: Option<&'a str>,
+    label: Option<&'a str>,
+}
+
+impl Filters<'_> {
+    fn any_active(&self) -> bool {
+        self.status.is_some()
+            || self.assignee.is_some()
+            || self.milestone.is_some()
+            || self.priority.is_some()
+            || self.label.is_some()
+    }
+
+    fn matches(&self, node: &TaskIndex, data: Option<&crate::storage::tasks::TaskData>) -> bool {
+        if let Some(status) = self.status {
+            if node.status != status {
+                return false;
+            }
+        }
+        if let Some(assignee) = self.assignee {
+            if node.assignee.as_deref() != Some(assignee) {
+                return false;
+            }
+        }
+        if let Some(milestone) = self.milestone {
+            let ms = node.schedule.as_ref().and_then(|s| s.milestone.as_deref());
+            if ms != Some(milestone) {
+                return false;
+            }
+        }
+        if let Some(priority) = self.priority {
+            if let Some(d) = data {
+                if d.priority.as_deref() != Some(priority) {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
+        if let Some(label) = self.label {
+            if let Some(d) = data {
+                if !d.labels.iter().any(|l| l == label) {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+fn filter_tree(tree: &[TaskIndex], filters: &Filters) -> Vec<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 {
+            let children = filter_tree(&node.children, filters);
+            if filters.matches(node, None) || !children.is_empty() {
+                Some(TaskIndex {
                     id: node.id.clone(),
                     title: node.title.clone(),
                     status: node.status.clone(),
                     schedule: node.schedule.clone(),
                     dependencies: node.dependencies.clone(),
                     order: node.order,
+                    assignee: node.assignee.clone(),
                     children,
                 })
             } else {

package/src/mcp/handlers/load_context.rs

@@ -209,6 +209,22 @@ pub fn handle(arguments: &Value) -> Result<String> {
         result["referrals"] = serde_json::to_value(&open_referrals)?;
     }
 
+    let current_open = read_open_sessions(&sessions_dir)?;
+    if !current_open.is_empty() {
+        let summaries: Vec<Value> = current_open
+            .iter()
+            .map(|s| {
+                serde_json::json!({
+                    "id": s.id,
+                    "summary": s.summary,
+                    "ended_at": s.ended_at,
+                    "branch": s.branch,
+                })
+            })
+            .collect();
+        result["open_sessions"] = serde_json::json!(summaries);
+    }
+
     let current_paused = read_paused_sessions(&sessions_dir)?;
     if !current_paused.is_empty() {
         let summaries: Vec<Value> = current_paused

package/src/mcp/handlers/log_time.rs

@@ -0,0 +1,70 @@
+use std::cell::Cell;
+
+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, read_modify_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 hours = arguments
+        .get("hours")
+        .and_then(|v| v.as_f64())
+        .ok_or_else(|| anyhow::anyhow!("'hours' parameter is required (number)"))?;
+
+    if hours <= 0.0 {
+        anyhow::bail!("'hours' must be positive");
+    }
+
+    let task_dir = find_task_dir_by_id(&tasks_dir, task_id)?.ok_or_else(|| {
+        anyhow::anyhow!(
+            "Task not found: {task_id}. Use handoff_list_tasks to see available task IDs."
+        )
+    })?;
+
+    // Capture the post-update values for the response message. read_modify_write
+    // re-runs the closure on a concurrent-write retry, so the cells always hold
+    // the values from the committed attempt.
+    let new_actual = Cell::new(0.0_f64);
+    let new_remaining: Cell<Option<f64>> = Cell::new(None);
+
+    read_modify_write_task(&task_dir, |data, status| {
+        let schedule = data.schedule.get_or_insert_with(Default::default);
+        let actual = schedule.actual_hours.unwrap_or(0.0) + hours;
+        schedule.actual_hours = Some(actual);
+        new_actual.set(actual);
+
+        if let Some(rem) = schedule.remaining_hours {
+            let r = (rem - hours).max(0.0);
+            schedule.remaining_hours = Some(r);
+            new_remaining.set(Some(r));
+        } else {
+            new_remaining.set(None);
+        }
+
+        data.updated_at = Some(Utc::now().to_rfc3339());
+        Ok(status.to_string())
+    })?;
+
+    let remaining_msg = match new_remaining.get() {
+        Some(r) => format!(", remaining={r:.1}h"),
+        None => String::new(),
+    };
+
+    Ok(format!(
+        "Logged {hours:.1}h on {task_id}: actual={:.1}h{remaining_msg}",
+        new_actual.get()
+    ))
+}

package/src/mcp/handlers/metrics.rs

@@ -0,0 +1,196 @@
+use std::collections::HashMap;
+
+use anyhow::Result;
+use chrono::Utc;
+use serde_json::{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, 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 tasks_dir = handoff.join("tasks");
+
+    let assignee_filter = arguments.get("assignee").and_then(|v| v.as_str());
+
+    let (tree, _) = build_task_index(&tasks_dir, u32::MAX)?;
+
+    let today = Utc::now().format("%Y-%m-%d").to_string();
+
+    let mut total: u32 = 0;
+    let mut by_status: HashMap<String, u32> = HashMap::new();
+    let mut estimate_sum: f64 = 0.0;
+    let mut actual_sum: f64 = 0.0;
+    let mut remaining_sum: f64 = 0.0;
+    let mut overdue_tasks: Vec<Value> = Vec::new();
+    let mut milestones: HashMap<String, (u32, u32, f64, f64)> = HashMap::new();
+
+    collect_metrics(
+        &tree,
+        assignee_filter,
+        &today,
+        &mut total,
+        &mut by_status,
+        &mut estimate_sum,
+        &mut actual_sum,
+        &mut remaining_sum,
+        &mut overdue_tasks,
+        &mut milestones,
+    );
+
+    let done_count = *by_status.get("done").unwrap_or(&0);
+    let skipped_count = *by_status.get("skipped").unwrap_or(&0);
+    let completion_percent = if total > 0 {
+        ((done_count + skipped_count) as f64 / total as f64) * 100.0
+    } else {
+        0.0
+    };
+
+    let budget = read_budget(&handoff);
+
+    // AI-effort multiplier: the raw estimate is the human-effort estimate;
+    // multiplying by ai_estimate_multiplier yields the expected AI-effort hours.
+    // Raw estimates are preserved; only the adjusted view is derived here.
+    let multiplier = read_config(&handoff.join("config.toml"))
+        .map(|c| c.settings.ai_estimate_multiplier)
+        .unwrap_or(0.2);
+
+    let milestone_list: Vec<Value> = milestones
+        .into_iter()
+        .map(|(name, (done, ms_total, est, act))| {
+            json!({
+                "name": name,
+                "done": done,
+                "total": ms_total,
+                "estimate_hours": est,
+                "adjusted_estimate_hours": est * multiplier,
+                "actual_hours": act,
+            })
+        })
+        .collect();
+
+    let result = json!({
+        "total": total,
+        "by_status": by_status,
+        "completion_percent": (completion_percent * 10.0).round() / 10.0,
+        "total_estimate_hours": estimate_sum,
+        "ai_estimate_multiplier": multiplier,
+        "total_adjusted_estimate_hours": estimate_sum * multiplier,
+        "total_actual_hours": actual_sum,
+        "total_remaining_hours": remaining_sum,
+        "overdue_count": overdue_tasks.len(),
+        "overdue_tasks": overdue_tasks,
+        "budget": budget,
+        "milestones": milestone_list,
+    });
+
+    serde_json::to_string_pretty(&result).map_err(Into::into)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn collect_metrics(
+    tree: &[TaskIndex],
+    assignee_filter: Option<&str>,
+    today: &str,
+    total: &mut u32,
+    by_status: &mut HashMap<String, u32>,
+    estimate_sum: &mut f64,
+    actual_sum: &mut f64,
+    remaining_sum: &mut f64,
+    overdue_tasks: &mut Vec<Value>,
+    milestones: &mut HashMap<String, (u32, u32, f64, f64)>,
+) {
+    for node in tree {
+        let task_assignee = node.assignee.as_deref();
+        let include = match assignee_filter {
+            Some(f) => task_assignee == Some(f),
+            None => true,
+        };
+
+        if include {
+            *total += 1;
+            *by_status.entry(node.status.clone()).or_insert(0) += 1;
+
+            if let Some(ref sched) = node.schedule {
+                if let Some(est) = sched.estimate_hours {
+                    *estimate_sum += est;
+                }
+                if let Some(act) = sched.actual_hours {
+                    *actual_sum += act;
+                }
+                if let Some(rem) = sched.remaining_hours {
+                    *remaining_sum += rem;
+                }
+
+                if let Some(ref due) = sched.due_date {
+                    if !is_terminal_status(&node.status) && due.as_str() < today {
+                        let days_overdue = days_between(due, today).unwrap_or(0);
+                        overdue_tasks.push(json!({
+                            "id": node.id,
+                            "title": node.title,
+                            "due_date": due,
+                            "days_overdue": days_overdue,
+                        }));
+                    }
+                }
+
+                if let Some(ref ms) = sched.milestone {
+                    let entry = milestones.entry(ms.clone()).or_insert((0, 0, 0.0, 0.0));
+                    entry.1 += 1;
+                    if is_terminal_status(&node.status) {
+                        entry.0 += 1;
+                    }
+                    if let Some(est) = sched.estimate_hours {
+                        entry.2 += est;
+                    }
+                    if let Some(act) = sched.actual_hours {
+                        entry.3 += act;
+                    }
+                }
+            }
+        }
+
+        collect_metrics(
+            &node.children,
+            assignee_filter,
+            today,
+            total,
+            by_status,
+            estimate_sum,
+            actual_sum,
+            remaining_sum,
+            overdue_tasks,
+            milestones,
+        );
+    }
+}
+
+fn days_between(from: &str, to: &str) -> Option<i64> {
+    let from_date = chrono::NaiveDate::parse_from_str(from, "%Y-%m-%d").ok()?;
+    let to_date = chrono::NaiveDate::parse_from_str(to, "%Y-%m-%d").ok()?;
+    Some((to_date - from_date).num_days())
+}
+
+fn read_budget(handoff: &std::path::Path) -> Value {
+    let config_path = handoff.join("config.toml");
+    let content = match std::fs::read_to_string(&config_path) {
+        Ok(c) => c,
+        Err(_) => return Value::Null,
+    };
+
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with("total_hours") {
+            if let Some(val_str) = trimmed.split('=').nth(1) {
+                if let Ok(total) = val_str.trim().parse::<f64>() {
+                    return json!({ "total_hours": total });
+                }
+            }
+        }
+    }
+
+    Value::Null
+}

package/src/mcp/handlers/milestones.rs

@@ -0,0 +1,102 @@
+//! Milestone CRUD over the `[milestones.<name>]` config.toml section.
+//! Mirrors the VSCode extension's addMilestone/updateMilestone/removeMilestone.
+
+use anyhow::Result;
+use serde_json::{json, Value};
+use toml_edit::{Item, Table};
+
+use super::config_crud::{
+    config_path, ensure_subtable, ensure_table, load_doc, require_str, save_doc, set_opt_str,
+};
+
+/// handoff_list_milestones — return every `[milestones.*]` entry.
+pub fn handle_list(arguments: &Value) -> Result<String> {
+    let path = config_path(arguments)?;
+    let doc = load_doc(&path)?;
+
+    let mut out = serde_json::Map::new();
+    if let Some(table) = doc.get("milestones").and_then(|v| v.as_table()) {
+        for (name, item) in table.iter() {
+            let sub = match item.as_table() {
+                Some(t) => t,
+                None => continue,
+            };
+            out.insert(
+                name.to_string(),
+                json!({
+                    "date": sub.get("date").and_then(|v| v.as_str()),
+                    "color": sub.get("color").and_then(|v| v.as_str()),
+                    "description": sub.get("description").and_then(|v| v.as_str()),
+                }),
+            );
+        }
+    }
+    serde_json::to_string_pretty(&json!({ "milestones": out })).map_err(Into::into)
+}
+
+/// handoff_add_milestone — create a `[milestones.<name>]` entry. Fails if it exists.
+pub fn handle_add(arguments: &Value) -> Result<String> {
+    let path = config_path(arguments)?;
+    let name = require_str(arguments, "name")?;
+    let mut doc = load_doc(&path)?;
+
+    let table = ensure_table(&mut doc, "milestones")?;
+    table.set_implicit(true);
+    if table.contains_key(name) {
+        anyhow::bail!(
+            "Milestone '{name}' already exists. Use handoff_update_milestone to modify it."
+        );
+    }
+    let mut sub = Table::new();
+    apply_fields(&mut sub, arguments);
+    doc["milestones"][name] = Item::Table(sub);
+
+    save_doc(&path, &doc)?;
+    Ok(format!("Added milestone '{name}'"))
+}
+
+/// handoff_update_milestone — patch an existing `[milestones.<name>]` entry.
+pub fn handle_update(arguments: &Value) -> Result<String> {
+    let path = config_path(arguments)?;
+    let name = require_str(arguments, "name")?;
+    let mut doc = load_doc(&path)?;
+
+    let exists = doc
+        .get("milestones")
+        .and_then(|v| v.as_table())
+        .map(|t| t.contains_key(name))
+        .unwrap_or(false);
+    if !exists {
+        anyhow::bail!("Milestone '{name}' not found. Use handoff_add_milestone to create it.");
+    }
+    let sub = ensure_subtable(&mut doc, "milestones", name)?;
+    apply_fields(sub, arguments);
+
+    save_doc(&path, &doc)?;
+    Ok(format!("Updated milestone '{name}'"))
+}
+
+/// handoff_remove_milestone — delete a `[milestones.<name>]` entry.
+pub fn handle_remove(arguments: &Value) -> Result<String> {
+    let path = config_path(arguments)?;
+    let name = require_str(arguments, "name")?;
+    let mut doc = load_doc(&path)?;
+
+    let removed = doc
+        .get_mut("milestones")
+        .and_then(|v| v.as_table_mut())
+        .map(|t| t.remove(name).is_some())
+        .unwrap_or(false);
+    if !removed {
+        anyhow::bail!("Milestone '{name}' not found.");
+    }
+    save_doc(&path, &doc)?;
+    Ok(format!("Removed milestone '{name}'"))
+}
+
+fn apply_fields(table: &mut Table, arguments: &Value) {
+    table.set_implicit(false);
+    set_opt_str(table, "date", arguments.get("date"));
+    set_opt_str(table, "color", arguments.get("color"));
+    set_opt_str(table, "description", arguments.get("description"));
+}

package/src/mcp/handlers/mod.rs

@@ -1,11 +1,22 @@
+pub mod assignees;
+pub mod auto_schedule;
+pub mod bulk_update;
+pub mod calendar;
+pub mod capacity;
 pub mod check_criterion;
 pub mod config;
+pub mod config_crud;
 pub mod dashboard;
+pub mod get_session;
 pub mod get_task;
 pub mod import_context;
 pub mod init;
+pub mod list_sessions;
 pub mod list_tasks;
 pub mod load_context;
+pub mod log_time;
+pub mod metrics;
+pub mod milestones;
 pub mod refer;
 pub mod referrals;
 pub mod save_context;
@@ -42,8 +53,27 @@ pub fn handle_tool_call(name: &str, arguments: &Value) -> JsonRpcResponse {
         "handoff_import_context" => import_context::handle(arguments),
         "handoff_refer" => refer::handle(arguments),
         "handoff_list_referrals" => referrals::handle_list(arguments),
+        "handoff_get_referral" => referrals::handle_get(arguments),
         "handoff_update_referral" => referrals::handle_update(arguments),
         "handoff_update_session" => update_session::handle(arguments),
+        "handoff_log_time" => log_time::handle(arguments),
+        "handoff_get_metrics" => metrics::handle(arguments),
+        "handoff_list_sessions" => list_sessions::handle(arguments),
+        "handoff_list_assignees" => assignees::handle(arguments),
+        "handoff_bulk_update_tasks" => bulk_update::handle(arguments),
+        "handoff_get_session" => get_session::handle(arguments),
+        "handoff_get_capacity" => capacity::handle(arguments),
+        "handoff_auto_schedule" => auto_schedule::handle(arguments),
+        "handoff_add_assignee" => assignees::handle_add(arguments),
+        "handoff_update_assignee" => assignees::handle_update(arguments),
+        "handoff_remove_assignee" => assignees::handle_remove(arguments),
+        "handoff_list_milestones" => milestones::handle_list(arguments),
+        "handoff_add_milestone" => milestones::handle_add(arguments),
+        "handoff_update_milestone" => milestones::handle_update(arguments),
+        "handoff_remove_milestone" => milestones::handle_remove(arguments),
+        "handoff_update_calendar" => calendar::handle_update_calendar(arguments),
+        "handoff_update_labels" => calendar::handle_update_labels(arguments),
+        "handoff_start_project" => calendar::handle_start_project(arguments),
         _ => Err(anyhow::anyhow!("Tool not implemented: {name}")),
     };