handoff-mcp-server 0.1.0

package/tests/storage_tasks.rs

@@ -0,0 +1,302 @@
+use handoff_mcp::storage::tasks::*;
+use std::fs;
+use tempfile::TempDir;
+
+fn setup() -> TempDir {
+    tempfile::tempdir().expect("failed to create temp dir")
+}
+
+fn create_task_dir(base: &std::path::Path, dir_name: &str, status: &str, data: &TaskData) {
+    let dir = base.join(dir_name);
+    fs::create_dir_all(&dir).unwrap();
+    write_task(&dir, status, data).unwrap();
+}
+
+fn make_task(id: &str, title: &str) -> TaskData {
+    TaskData {
+        id: id.to_string(),
+        title: title.to_string(),
+        notes: None,
+        priority: None,
+        created_at: None,
+        updated_at: None,
+        completed_at: None,
+        labels: Vec::new(),
+        links: Vec::new(),
+        done_criteria: Vec::new(),
+    }
+}
+
+#[test]
+fn write_and_read_task() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    let data = make_task("t1", "Test task");
+    write_task(&task_dir, "todo", &data).unwrap();
+
+    let (read_data, status) = read_task(&task_dir).unwrap().unwrap();
+    assert_eq!(read_data.id, "t1");
+    assert_eq!(read_data.title, "Test task");
+    assert_eq!(status, "todo");
+}
+
+#[test]
+fn change_task_status() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    let data = make_task("t1", "Test");
+    write_task(&task_dir, "todo", &data).unwrap();
+
+    change_status(&task_dir, "in_progress").unwrap();
+
+    let (_, status) = read_task(&task_dir).unwrap().unwrap();
+    assert_eq!(status, "in_progress");
+
+    assert!(!task_dir.join("_task.todo.json").exists());
+    assert!(task_dir.join("_task.in_progress.json").exists());
+}
+
+#[test]
+fn change_to_same_status_is_noop() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    let data = make_task("t1", "Test");
+    write_task(&task_dir, "todo", &data).unwrap();
+
+    change_status(&task_dir, "todo").unwrap();
+    let (_, status) = read_task(&task_dir).unwrap().unwrap();
+    assert_eq!(status, "todo");
+}
+
+#[test]
+fn invalid_status_returns_error() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    let data = make_task("t1", "Test");
+    write_task(&task_dir, "todo", &data).unwrap();
+
+    assert!(change_status(&task_dir, "invalid_status").is_err());
+}
+
+#[test]
+fn next_top_level_id_empty() {
+    let dir = setup();
+    let tasks_dir = dir.path().join("tasks");
+    fs::create_dir_all(&tasks_dir).unwrap();
+
+    assert_eq!(next_top_level_id(&tasks_dir).unwrap(), "t1");
+}
+
+#[test]
+fn next_top_level_id_with_existing() {
+    let dir = setup();
+    let tasks_dir = dir.path().join("tasks");
+    fs::create_dir_all(tasks_dir.join("t1-first")).unwrap();
+    fs::create_dir_all(tasks_dir.join("t3-third")).unwrap();
+
+    assert_eq!(next_top_level_id(&tasks_dir).unwrap(), "t4");
+}
+
+#[test]
+fn next_child_id_empty_parent() {
+    let dir = setup();
+    let parent_dir = dir.path().join("tasks/t1-parent");
+    fs::create_dir_all(&parent_dir).unwrap();
+
+    assert_eq!(next_child_id(&parent_dir, "t1").unwrap(), "t1.1");
+}
+
+#[test]
+fn next_child_id_with_existing_children() {
+    let dir = setup();
+    let parent_dir = dir.path().join("tasks/t1-parent");
+    fs::create_dir_all(parent_dir.join("t1.1-first")).unwrap();
+    fs::create_dir_all(parent_dir.join("t1.2-second")).unwrap();
+
+    assert_eq!(next_child_id(&parent_dir, "t1").unwrap(), "t1.3");
+}
+
+#[test]
+fn title_to_slug_basic() {
+    assert_eq!(title_to_slug("Hello World"), "hello-world");
+    assert_eq!(title_to_slug("P0: SM_RESTART"), "p0-sm-restart");
+    assert_eq!(title_to_slug("  Multiple   Spaces  "), "multiple-spaces");
+}
+
+#[test]
+fn title_to_slug_empty() {
+    assert_eq!(title_to_slug(""), "task");
+}
+
+#[test]
+fn find_task_dir_by_id_finds_nested() {
+    let dir = setup();
+    let tasks_dir = dir.path().join("tasks");
+    let nested = tasks_dir.join("t1-parent/t1.1-child");
+    fs::create_dir_all(&nested).unwrap();
+    write_task(&nested, "todo", &make_task("t1.1", "child")).unwrap();
+
+    let found = find_task_dir_by_id(&tasks_dir, "t1.1").unwrap();
+    assert!(found.is_some());
+    assert!(found.unwrap().ends_with("t1.1-child"));
+}
+
+#[test]
+fn find_task_dir_by_id_not_found() {
+    let dir = setup();
+    let tasks_dir = dir.path().join("tasks");
+    fs::create_dir_all(&tasks_dir).unwrap();
+
+    assert!(find_task_dir_by_id(&tasks_dir, "t99").unwrap().is_none());
+}
+
+#[test]
+fn build_task_index_basic() {
+    let dir = setup();
+    let tasks_dir = dir.path().join("tasks");
+
+    create_task_dir(
+        &tasks_dir,
+        "t1-parent",
+        "in_progress",
+        &make_task("t1", "Parent"),
+    );
+    create_task_dir(
+        &tasks_dir.join("t1-parent"),
+        "t1.1-child",
+        "done",
+        &make_task("t1.1", "Child Done"),
+    );
+    create_task_dir(&tasks_dir, "t2-other", "todo", &make_task("t2", "Other"));
+
+    let (tree, summary) = build_task_index(&tasks_dir, 10).unwrap();
+    assert_eq!(summary.total, 3);
+    assert_eq!(*summary.by_status.get("in_progress").unwrap_or(&0), 1);
+    assert_eq!(*summary.by_status.get("done").unwrap_or(&0), 1);
+    assert_eq!(*summary.by_status.get("todo").unwrap_or(&0), 1);
+
+    assert_eq!(tree.len(), 2);
+    let t1 = tree.iter().find(|t| t.id == "t1").unwrap();
+    assert_eq!(t1.children.len(), 1);
+    assert_eq!(t1.children[0].id, "t1.1");
+}
+
+#[test]
+fn build_task_index_done_limit() {
+    let dir = setup();
+    let tasks_dir = dir.path().join("tasks");
+
+    for i in 1..=5 {
+        create_task_dir(
+            &tasks_dir,
+            &format!("t{i}-task-{i}"),
+            "done",
+            &make_task(&format!("t{i}"), &format!("Task {i}")),
+        );
+    }
+
+    let (tree, summary) = build_task_index(&tasks_dir, 3).unwrap();
+    assert_eq!(summary.total, 5);
+    assert_eq!(*summary.by_status.get("done").unwrap(), 5);
+    assert_eq!(tree.len(), 3);
+}
+
+#[test]
+fn validate_done_unchecked_criteria_fails() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    let data = TaskData {
+        done_criteria: vec![
+            DoneCriterion {
+                item: "test passes".to_string(),
+                checked: true,
+            },
+            DoneCriterion {
+                item: "review done".to_string(),
+                checked: false,
+            },
+        ],
+        ..make_task("t1", "Test")
+    };
+
+    assert!(validate_done_transition(&task_dir, &data).is_err());
+}
+
+#[test]
+fn validate_done_all_checked_passes() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    let data = TaskData {
+        done_criteria: vec![DoneCriterion {
+            item: "test passes".to_string(),
+            checked: true,
+        }],
+        ..make_task("t1", "Test")
+    };
+
+    assert!(validate_done_transition(&task_dir, &data).is_ok());
+}
+
+#[test]
+fn validate_done_child_not_terminal_fails() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    create_task_dir(
+        &task_dir,
+        "t1.1-child",
+        "in_progress",
+        &make_task("t1.1", "Child"),
+    );
+
+    let data = make_task("t1", "Parent");
+    assert!(validate_done_transition(&task_dir, &data).is_err());
+}
+
+#[test]
+fn validate_done_child_all_terminal_passes() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    create_task_dir(
+        &task_dir,
+        "t1.1-child-a",
+        "done",
+        &make_task("t1.1", "Child A"),
+    );
+    create_task_dir(
+        &task_dir,
+        "t1.2-child-b",
+        "skipped",
+        &make_task("t1.2", "Child B"),
+    );
+
+    let data = make_task("t1", "Parent");
+    assert!(validate_done_transition(&task_dir, &data).is_ok());
+}
+
+#[test]
+fn validate_skipped_child_not_terminal_fails() {
+    let dir = setup();
+    let task_dir = dir.path().join("t1-test");
+    fs::create_dir_all(&task_dir).unwrap();
+
+    create_task_dir(&task_dir, "t1.1-child", "todo", &make_task("t1.1", "Child"));
+
+    let data = make_task("t1", "Parent");
+    assert!(validate_skipped_transition(&task_dir, &data).is_err());
+}

package/tests/tool_dashboard.rs

@@ -0,0 +1,165 @@
+use serde_json::{json, Value};
+use std::fs;
+use tempfile::TempDir;
+
+fn send(input: &str) -> Option<Value> {
+    let result = handoff_mcp::mcp::protocol::process_line(input)?;
+    Some(serde_json::from_str(&result).expect("response should be valid JSON"))
+}
+
+fn call_tool(name: &str, arguments: Value) -> Value {
+    let req = json!({
+        "jsonrpc": "2.0", "id": 1,
+        "method": "tools/call",
+        "params": { "name": name, "arguments": arguments }
+    });
+    send(&req.to_string()).unwrap()
+}
+
+fn get_text(resp: &Value) -> String {
+    resp["result"]["content"][0]["text"]
+        .as_str()
+        .unwrap_or("")
+        .to_string()
+}
+
+fn is_error(resp: &Value) -> bool {
+    resp["result"]["isError"].as_bool().unwrap_or(false)
+}
+
+fn init_project(base: &std::path::Path, name: &str) {
+    let project_dir = base.join(name);
+    fs::create_dir_all(&project_dir).unwrap();
+
+    let req = json!({
+        "jsonrpc": "2.0", "id": 0,
+        "method": "tools/call",
+        "params": {
+            "name": "handoff_init",
+            "arguments": {
+                "project_dir": project_dir.to_string_lossy(),
+                "project_name": name
+            }
+        }
+    });
+    send(&req.to_string()).unwrap();
+}
+
+fn setup_scan_dir() -> TempDir {
+    tempfile::tempdir().expect("failed to create temp dir")
+}
+
+#[test]
+fn dashboard_multiple_projects() {
+    let scan_dir = setup_scan_dir();
+
+    init_project(scan_dir.path(), "project-a");
+    init_project(scan_dir.path(), "project-b");
+
+    let resp = call_tool(
+        "handoff_dashboard",
+        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
+    );
+
+    assert!(!is_error(&resp), "error: {}", get_text(&resp));
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+
+    let projects = parsed["projects"].as_array().unwrap();
+    assert_eq!(projects.len(), 2);
+
+    let names: Vec<&str> = projects
+        .iter()
+        .map(|p| p["name"].as_str().unwrap())
+        .collect();
+    assert!(names.contains(&"project-a"));
+    assert!(names.contains(&"project-b"));
+}
+
+#[test]
+fn dashboard_skips_non_handoff_dirs() {
+    let scan_dir = setup_scan_dir();
+
+    init_project(scan_dir.path(), "real-project");
+    fs::create_dir_all(scan_dir.path().join("not-a-project")).unwrap();
+
+    let resp = call_tool(
+        "handoff_dashboard",
+        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
+    );
+
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+    let projects = parsed["projects"].as_array().unwrap();
+    assert_eq!(projects.len(), 1);
+}
+
+#[test]
+fn dashboard_with_tasks() {
+    let scan_dir = setup_scan_dir();
+    init_project(scan_dir.path(), "proj-tasks");
+
+    let pd = scan_dir
+        .path()
+        .join("proj-tasks")
+        .to_string_lossy()
+        .to_string();
+
+    call_tool(
+        "handoff_update_task",
+        json!({
+            "project_dir": &pd,
+            "task": { "title": "Task 1", "status": "in_progress" }
+        }),
+    );
+    call_tool(
+        "handoff_update_task",
+        json!({
+            "project_dir": &pd,
+            "task": { "title": "Task 2", "status": "blocked", "notes": "Waiting" }
+        }),
+    );
+
+    let resp = call_tool(
+        "handoff_dashboard",
+        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
+    );
+
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+
+    assert_eq!(parsed["total_active_tasks"], 1);
+    assert_eq!(parsed["total_blocked"], 1);
+
+    let proj = &parsed["projects"][0];
+    assert_eq!(proj["active_tasks"], 1);
+    assert_eq!(proj["blocked_tasks"], 1);
+}
+
+#[test]
+fn dashboard_empty_scan_dir() {
+    let scan_dir = setup_scan_dir();
+
+    let resp = call_tool(
+        "handoff_dashboard",
+        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
+    );
+
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+    assert!(parsed["projects"].as_array().unwrap().is_empty());
+    assert_eq!(parsed["total_active_tasks"], 0);
+}
+
+#[test]
+fn dashboard_nonexistent_scan_dir() {
+    let resp = call_tool(
+        "handoff_dashboard",
+        json!({ "scan_dirs": ["/nonexistent/path/that/does/not/exist"] }),
+    );
+
+    assert!(!is_error(&resp));
+    let text = get_text(&resp);
+    let parsed: Value = serde_json::from_str(&text).unwrap();
+    assert!(parsed["projects"].as_array().unwrap().is_empty());
+}

package/tests/tool_init.rs

@@ -0,0 +1,176 @@
+use serde_json::{json, Value};
+use tempfile::TempDir;
+
+fn send(input: &str) -> Option<Value> {
+    let result = handoff_mcp::mcp::protocol::process_line(input)?;
+    Some(serde_json::from_str(&result).expect("response should be valid JSON"))
+}
+
+fn setup() -> TempDir {
+    tempfile::tempdir().expect("failed to create temp dir")
+}
+
+#[test]
+fn init_creates_handoff_directory() {
+    let dir = setup();
+    let project_dir = dir.path().to_string_lossy();
+
+    let req = json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {
+            "name": "handoff_init",
+            "arguments": {
+                "project_dir": project_dir,
+                "project_name": "test-project",
+                "description": "A test project"
+            }
+        }
+    });
+
+    let resp = send(&req.to_string()).expect("should return response");
+    assert_eq!(resp["id"], 1);
+    assert!(resp["error"].is_null(), "error: {:?}", resp["error"]);
+
+    let content = &resp["result"]["content"][0]["text"];
+    assert!(
+        content.as_str().unwrap().contains("test-project"),
+        "response: {content}"
+    );
+
+    let handoff = dir.path().join(".handoff");
+    assert!(handoff.exists());
+    assert!(handoff.join("config.toml").exists());
+    assert!(handoff.join("sessions").is_dir());
+    assert!(handoff.join("tasks").is_dir());
+
+    let config_content = std::fs::read_to_string(handoff.join("config.toml")).unwrap();
+    assert!(config_content.contains("test-project"));
+    assert!(config_content.contains("A test project"));
+}
+
+#[test]
+fn init_double_init_returns_error() {
+    let dir = setup();
+    let project_dir = dir.path().to_string_lossy();
+
+    let req = json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {
+            "name": "handoff_init",
+            "arguments": {
+                "project_dir": project_dir,
+                "project_name": "test-project"
+            }
+        }
+    });
+
+    send(&req.to_string()).unwrap();
+
+    let req2 = json!({
+        "jsonrpc": "2.0",
+        "id": 2,
+        "method": "tools/call",
+        "params": {
+            "name": "handoff_init",
+            "arguments": {
+                "project_dir": project_dir,
+                "project_name": "test-project"
+            }
+        }
+    });
+
+    let resp = send(&req2.to_string()).unwrap();
+    let content = &resp["result"]["content"][0]["text"];
+    assert!(content.as_str().unwrap().contains("already"));
+    assert_eq!(resp["result"]["isError"], true);
+}
+
+#[test]
+fn init_without_project_name_returns_error() {
+    let dir = setup();
+    let project_dir = dir.path().to_string_lossy();
+
+    let req = json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {
+            "name": "handoff_init",
+            "arguments": {
+                "project_dir": project_dir
+            }
+        }
+    });
+
+    let resp = send(&req.to_string()).unwrap();
+    assert_eq!(resp["result"]["isError"], true);
+}
+
+#[test]
+fn init_config_has_defaults() {
+    let dir = setup();
+    let project_dir = dir.path().to_string_lossy();
+
+    let req = json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {
+            "name": "handoff_init",
+            "arguments": {
+                "project_dir": project_dir,
+                "project_name": "defaults-test"
+            }
+        }
+    });
+
+    send(&req.to_string()).unwrap();
+
+    let config =
+        handoff_mcp::storage::config::read_config(&dir.path().join(".handoff/config.toml"))
+            .unwrap();
+
+    assert_eq!(config.project.name, "defaults-test");
+    assert_eq!(config.settings.history_limit, 20);
+    assert_eq!(config.settings.done_task_limit, 10);
+    assert!(config.settings.auto_git_summary);
+}
+
+#[test]
+fn tools_call_unknown_tool_returns_error() {
+    let req = json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {
+            "name": "nonexistent_tool",
+            "arguments": {}
+        }
+    });
+
+    let resp = send(&req.to_string()).unwrap();
+    assert_eq!(resp["result"]["isError"], true);
+    assert!(resp["result"]["content"][0]["text"]
+        .as_str()
+        .unwrap()
+        .contains("not implemented"));
+}
+
+#[test]
+fn tools_call_missing_name_returns_error() {
+    let req = json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {
+            "arguments": {}
+        }
+    });
+
+    let resp = send(&req.to_string()).unwrap();
+    assert!(resp["error"].is_object());
+}