@scardis/omnifocus-mcp 0.1.0

package/test/integration/createProject.int.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, type TestFixture } from "./fixtures.js";
+import { ProjectDetail } from "../../src/schemas/index.js";
+
+describe("create_project (integration)", () => {
+  let fixture: TestFixture;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("creates a top-level project and returns stable id", async () => {
+    const name = `__mcp_test_proj_${Date.now()}__`;
+    const raw = await runSnippet("create_project", { name });
+    const project = ProjectDetail.parse(raw);
+    expect(project.id).toBeTruthy();
+    expect(project.name).toBe(name);
+    expect(project.folderPath).toBe("");
+    expect(project.type).toBe("parallel");
+    // Clean up the top-level project
+    await runSnippet("delete_project", { id: project.id });
+  });
+
+  it("creates project inside a folder and sets folderPath", async () => {
+    const raw = await runSnippet("create_project", {
+      name: "Folder Project Test",
+      folderId: fixture.folderId,
+    });
+    const project = ProjectDetail.parse(raw);
+    expect(project.id).toBeTruthy();
+    expect(project.folderPath).toBeTruthy();
+    expect(project.type).toBe("parallel");
+  });
+
+  it("creates sequential project and returns type sequential", async () => {
+    const raw = await runSnippet("create_project", {
+      name: "Sequential Project Test",
+      folderId: fixture.folderId,
+      type: "sequential",
+    });
+    const project = ProjectDetail.parse(raw);
+    expect(project.type).toBe("sequential");
+  });
+});

package/test/integration/createTag.int.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { deleteTestTag } from "./fixtures.js";
+import { TagDetail } from "../../src/schemas/index.js";
+
+describe("create_tag (integration)", () => {
+  const createdTagIds: string[] = [];
+
+  afterAll(async () => {
+    for (const id of createdTagIds) {
+      await deleteTestTag(id);
+    }
+  });
+
+  it("creates a top-level tag and returns stable id", async () => {
+    const name = `__mcp_test_tag_${Date.now()}__`;
+    const raw = await runSnippet("create_tag", { name });
+    const tag = TagDetail.parse(raw);
+    expect(tag.id).toBeTruthy();
+    expect(tag.name).toBe(name);
+    expect(tag.parentId).toBeNull();
+    expect(tag.path).toBe(name);
+    createdTagIds.push(tag.id);
+  });
+
+  it("creates a child tag with correct path and parentId", async () => {
+    const parentName = `__mcp_test_parent_tag_${Date.now()}__`;
+    const parentRaw = await runSnippet("create_tag", { name: parentName });
+    const parent = TagDetail.parse(parentRaw);
+    createdTagIds.push(parent.id);
+
+    const childRaw = await runSnippet("create_tag", {
+      name: "Child",
+      parentTagId: parent.id,
+    });
+    const child = TagDetail.parse(childRaw);
+    expect(child.parentId).toBe(parent.id);
+    expect(child.path).toContain(parentName);
+    expect(child.path).toContain("Child");
+    // Parent should now list child
+    expect(parent.childTagIds).not.toContain(child.id); // stale parent object; child is real
+  });
+
+  it("returns not-found error for invalid parentTagId", async () => {
+    await expect(
+      runSnippet("create_tag", { name: "X", parentTagId: "nonexistent-id-xyz" })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+});

package/test/integration/createTask.int.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { TaskDetail } from "../../src/schemas/index.js";
+
+describe("create_task (integration)", () => {
+  let fixture: TestFixture;
+  let projectId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    projectId = await createTestProject(fixture.folderId, "CreateTask Test Project");
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("creates an inbox task and returns a stable id", async () => {
+    const raw = await runSnippet("create_task", { name: "Inbox task test" });
+    const task = TaskDetail.parse(raw);
+    expect(task.id).toBeTruthy();
+    expect(task.name).toBe("Inbox task test");
+    expect(task.containerType).toBe("inbox");
+    // Clean up inbox task
+    await runSnippet("delete_task", { id: task.id });
+  });
+
+  it("creates a task in a project and sets containerId", async () => {
+    const raw = await runSnippet("create_task", {
+      name: "Project task test",
+      projectId,
+    });
+    const task = TaskDetail.parse(raw);
+    expect(task.id).toBeTruthy();
+    expect(task.name).toBe("Project task test");
+    expect(task.containerId).toBe(projectId);
+    expect(task.containerType).toBe("project");
+  });
+
+  it("creates a subtask and sets parentTaskId", async () => {
+    const parentRaw = await runSnippet("create_task", {
+      name: "Parent task",
+      projectId,
+    });
+    const parent = TaskDetail.parse(parentRaw);
+
+    const childRaw = await runSnippet("create_task", {
+      name: "Child task",
+      parentTaskId: parent.id,
+    });
+    const child = TaskDetail.parse(childRaw);
+    expect(child.parentTaskId).toBe(parent.id);
+  });
+});

package/test/integration/deleteFolder.int.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { FolderDetail } from "../../src/schemas/index.js";
+
+describe("delete_folder (integration)", () => {
+  let fixture: TestFixture;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+  });
+
+  afterAll(async () => {
+    // Best-effort cleanup — the folder may already be deleted by the test
+    try { await cleanupTestFolder(fixture.folderId); } catch (_) {}
+  });
+
+  it("deletes folder with child project and get_folder returns not-found afterwards", async () => {
+    // Create a nested folder with a project inside the fixture
+    const childRaw = await runSnippet("create_folder", {
+      name: "ToDelete",
+      parentFolderId: fixture.folderId,
+    });
+    const childFolder = FolderDetail.parse(childRaw);
+    await createTestProject(childFolder.id, "Project inside folder");
+
+    // Delete the child folder
+    await runSnippet("delete_folder", { id: childFolder.id });
+
+    // get_folder should return not-found
+    await expect(
+      runSnippet("get_folder", { id: childFolder.id })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+
+  it("deletes an empty folder", async () => {
+    const raw = await runSnippet("create_folder", {
+      name: "EmptyToDelete",
+      parentFolderId: fixture.folderId,
+    });
+    const folder = FolderDetail.parse(raw);
+
+    await runSnippet("delete_folder", { id: folder.id });
+
+    await expect(
+      runSnippet("get_folder", { id: folder.id })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+
+  it("returns not-found error for invalid id", async () => {
+    await expect(
+      runSnippet("delete_folder", { id: "nonexistent-id-xyz" })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+});

package/test/integration/deleteProject.int.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { ProjectDetail } from "../../src/schemas/index.js";
+
+describe("delete_project (integration)", () => {
+  let fixture: TestFixture;
+  let projectId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    projectId = await createTestProject(fixture.folderId, "DeleteProject Test Project");
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("deletes the project and get_project returns not-found afterwards", async () => {
+    await runSnippet("delete_project", { id: projectId });
+
+    await expect(
+      runSnippet("get_project", { id: projectId })
+    ).rejects.toSatisfy(
+      (e: unknown) => {
+        const err = e as Record<string, unknown>;
+        return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+      }
+    );
+  });
+});

package/test/integration/deleteTag.int.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestTag } from "./fixtures.js";
+import { TagDetail } from "../../src/schemas/index.js";
+
+describe("delete_tag (integration)", () => {
+  let tagId: string;
+  let parentTagId: string;
+
+  beforeAll(async () => {
+    tagId = await createTestTag(`__mcp_test_del_tag_${Date.now()}__`);
+    parentTagId = await createTestTag(`__mcp_test_del_parent_${Date.now()}__`);
+  });
+
+  it("deletes a tag and get_tag returns not-found afterwards", async () => {
+    await runSnippet("delete_tag", { id: tagId });
+
+    await expect(
+      runSnippet("get_tag", { id: tagId })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+
+  it("deletes parent tag and child tags are also gone", async () => {
+    // Create a child tag under parentTagId
+    const childRaw = await runSnippet("create_tag", {
+      name: "ChildToDelete",
+      parentTagId,
+    });
+    const child = TagDetail.parse(childRaw);
+
+    // Delete the parent
+    await runSnippet("delete_tag", { id: parentTagId });
+
+    // Both parent and child should be gone
+    await expect(
+      runSnippet("get_tag", { id: parentTagId })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+
+    await expect(
+      runSnippet("get_tag", { id: child.id })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+
+  it("returns not-found error for invalid id", async () => {
+    await expect(
+      runSnippet("delete_tag", { id: "nonexistent-id-xyz" })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+});

package/test/integration/deleteTask.int.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { TaskDetail } from "../../src/schemas/index.js";
+
+describe("delete_task (integration)", () => {
+  let fixture: TestFixture;
+  let taskId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    const projectId = await createTestProject(fixture.folderId, "DeleteTask Test Project");
+    const taskRaw = await runSnippet("create_task", {
+      name: "Task to delete",
+      projectId,
+    });
+    taskId = TaskDetail.parse(taskRaw).id;
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("deletes the task and get_task returns not-found afterwards", async () => {
+    await runSnippet("delete_task", { id: taskId });
+
+    await expect(
+      runSnippet("get_task", { id: taskId })
+    ).rejects.toSatisfy(
+      (e: unknown) => {
+        const err = e as Record<string, unknown>;
+        return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+      }
+    );
+  });
+});

package/test/integration/dropProject.int.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { ProjectDetail } from "../../src/schemas/index.js";
+
+describe("drop_project (integration)", () => {
+  let fixture: TestFixture;
+  let projectId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    projectId = await createTestProject(fixture.folderId, "DropProject Test Project");
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("marks project dropped and returns status dropped", async () => {
+    const raw = await runSnippet("drop_project", { id: projectId });
+    const project = ProjectDetail.parse(raw);
+    expect(project.status).toBe("dropped");
+  });
+});

package/test/integration/dropTask.int.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { TaskDetail } from "../../src/schemas/index.js";
+
+describe("drop_task (integration)", () => {
+  let fixture: TestFixture;
+  let taskId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    const projectId = await createTestProject(fixture.folderId, "DropTask Test Project");
+    const taskRaw = await runSnippet("create_task", {
+      name: "Task to drop",
+      projectId,
+    });
+    taskId = TaskDetail.parse(taskRaw).id;
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("marks task dropped and returns status dropped", async () => {
+    const raw = await runSnippet("drop_task", { id: taskId });
+    const task = TaskDetail.parse(raw);
+    expect(task.status).toBe("dropped");
+  });
+});

package/test/integration/editFolder.int.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, type TestFixture } from "./fixtures.js";
+import { FolderDetail } from "../../src/schemas/index.js";
+
+describe("edit_folder (integration)", () => {
+  let fixture: TestFixture;
+  let childFolderId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    // Create a child folder to rename
+    const raw = await runSnippet("create_folder", {
+      name: "Original Name",
+      parentFolderId: fixture.folderId,
+    });
+    const folder = FolderDetail.parse(raw);
+    childFolderId = folder.id;
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("renames a folder and returns updated name and path", async () => {
+    const raw = await runSnippet("edit_folder", {
+      id: childFolderId,
+      name: "Renamed Folder",
+    });
+    const folder = FolderDetail.parse(raw);
+    expect(folder.name).toBe("Renamed Folder");
+    expect(folder.path).toContain("Renamed Folder");
+  });
+
+  it("returns not-found error for invalid id", async () => {
+    await expect(
+      runSnippet("edit_folder", { id: "nonexistent-id-xyz", name: "X" })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+});

package/test/integration/editProject.int.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, type TestFixture } from "./fixtures.js";
+import { ProjectDetail } from "../../src/schemas/index.js";
+
+describe("edit_project (integration)", () => {
+  let fixture: TestFixture;
+  let projectId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    projectId = await createTestProject(fixture.folderId, "EditProject Test Project");
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("edits name only; other fields unchanged", async () => {
+    const raw = await runSnippet("edit_project", { id: projectId, name: "Updated name" });
+    const project = ProjectDetail.parse(raw);
+    expect(project.name).toBe("Updated name");
+  });
+
+  it("sets status to onHold", async () => {
+    const raw = await runSnippet("edit_project", { id: projectId, status: "onHold" });
+    const project = ProjectDetail.parse(raw);
+    expect(project.status).toBe("onHold");
+  });
+
+  it("sets review interval", async () => {
+    const raw = await runSnippet("edit_project", {
+      id: projectId,
+      reviewInterval: { steps: 2, unit: "weeks" },
+    });
+    const project = ProjectDetail.parse(raw);
+    expect(project.reviewInterval).toBeTruthy();
+  });
+});

package/test/integration/editTag.int.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestTag, deleteTestTag } from "./fixtures.js";
+import { TagDetail } from "../../src/schemas/index.js";
+
+describe("edit_tag (integration)", () => {
+  let tagId: string;
+
+  beforeAll(async () => {
+    tagId = await createTestTag(`__mcp_test_edit_tag_${Date.now()}__`);
+  });
+
+  afterAll(async () => {
+    await deleteTestTag(tagId);
+  });
+
+  it("renames a tag", async () => {
+    const raw = await runSnippet("edit_tag", { id: tagId, name: "Renamed Tag" });
+    const tag = TagDetail.parse(raw);
+    expect(tag.name).toBe("Renamed Tag");
+  });
+
+  it("puts tag on hold", async () => {
+    const raw = await runSnippet("edit_tag", { id: tagId, status: "onHold" });
+    const tag = TagDetail.parse(raw);
+    expect(tag.status).toBe("onHold");
+  });
+
+  it("restores tag to active", async () => {
+    const raw = await runSnippet("edit_tag", { id: tagId, status: "active" });
+    const tag = TagDetail.parse(raw);
+    expect(tag.status).toBe("active");
+  });
+
+  it("returns not-found error for invalid id", async () => {
+    await expect(
+      runSnippet("edit_tag", { id: "nonexistent-id-xyz", name: "X" })
+    ).rejects.toSatisfy((e: unknown) => {
+      const err = e as Record<string, unknown>;
+      return err.name === "ExecutionError" && err.errorName === "NotFoundError";
+    });
+  });
+});

package/test/integration/editTask.int.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { runSnippet } from "../../src/runtime/bridge.js";
+import { createTestFolder, cleanupTestFolder, createTestProject, createTestTag, deleteTestTag, type TestFixture } from "./fixtures.js";
+import { TaskDetail } from "../../src/schemas/index.js";
+
+describe("edit_task (integration)", () => {
+  let fixture: TestFixture;
+  let taskId: string;
+
+  beforeAll(async () => {
+    fixture = await createTestFolder();
+    const projectId = await createTestProject(fixture.folderId, "EditTask Test Project");
+    const taskRaw = await runSnippet("create_task", {
+      name: "Original name",
+      projectId,
+      dueDate: "2026-12-31T00:00:00.000Z",
+    });
+    taskId = TaskDetail.parse(taskRaw).id;
+  });
+
+  afterAll(async () => {
+    await cleanupTestFolder(fixture.folderId);
+  });
+
+  it("edits name only; other fields unchanged", async () => {
+    const raw = await runSnippet("edit_task", { id: taskId, name: "Updated name" });
+    const task = TaskDetail.parse(raw);
+    expect(task.name).toBe("Updated name");
+    expect(task.dueDate).not.toBeNull();
+  });
+
+  it("sets flagged", async () => {
+    const raw = await runSnippet("edit_task", { id: taskId, flagged: true });
+    const task = TaskDetail.parse(raw);
+    expect(task.flagged).toBe(true);
+  });
+
+  it("clears due date with null", async () => {
+    const raw = await runSnippet("edit_task", { id: taskId, dueDate: null });
+    const task = TaskDetail.parse(raw);
+    expect(task.dueDate).toBeNull();
+  });
+
+  it("replaces tag set", async () => {
+    const tagId = await createTestTag(`__mcp_test_tag_${Date.now()}__`);
+    try {
+      const raw = await runSnippet("edit_task", { id: taskId, tagIds: [tagId] });
+      const task = TaskDetail.parse(raw);
+      expect(task.tagIds).toContain(tagId);
+      // Clear tags before deleting the tag
+      await runSnippet("edit_task", { id: taskId, tagIds: [] });
+    } finally {
+      await deleteTestTag(tagId);
+    }
+  });
+});