@scardis/omnifocus-mcp 0.1.0

package/test/unit/resultProtocol.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { parseResultLine, ExecutionError } from "../../src/runtime/resultProtocol.js";
+
+describe("parseResultLine", () => {
+  it("parses a well-formed success envelope", () => {
+    const stdout = JSON.stringify({ ok: true, data: { id: "abc" } });
+    const result = parseResultLine(stdout);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.data).toEqual({ id: "abc" });
+    }
+  });
+
+  it("parses a well-formed error envelope", () => {
+    const stdout = JSON.stringify({
+      ok: false,
+      error: { name: "NotFoundError", message: "Not found", stack: "..." },
+    });
+    const result = parseResultLine(stdout);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.name).toBe("NotFoundError");
+      expect(result.error.message).toBe("Not found");
+    }
+  });
+
+  it("selects first parseable JSON line when preceded by chatter", () => {
+    const stdout =
+      "osascript warning: something\nnot json at all\n" +
+      JSON.stringify({ ok: true, data: [1, 2, 3] }) +
+      "\n";
+    const result = parseResultLine(stdout);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.data).toEqual([1, 2, 3]);
+    }
+  });
+
+  it("throws on empty stdout", () => {
+    expect(() => parseResultLine("")).toThrow(/No valid JSON result envelope/);
+  });
+
+  it("throws on non-envelope JSON", () => {
+    expect(() => parseResultLine('{"foo":"bar"}')).toThrow(/not a valid result envelope/);
+  });
+
+  it("throws on malformed-only stdout with no parseable lines", () => {
+    expect(() => parseResultLine("not json\nalso not json\n")).toThrow(
+      /No valid JSON result envelope/
+    );
+  });
+});
+
+describe("ExecutionError", () => {
+  it("carries name, message, and stack from the error detail", () => {
+    const err = new ExecutionError({
+      name: "TypeError",
+      message: "cannot read property",
+      stack: "TypeError: cannot...\n  at line 1",
+    });
+    expect(err.message).toBe("cannot read property");
+    expect(err.errorName).toBe("TypeError");
+    expect(err.remoteStack).toContain("TypeError:");
+    expect(err.name).toBe("ExecutionError");
+  });
+
+  it("works without a stack field", () => {
+    const err = new ExecutionError({ name: "Error", message: "boom" });
+    expect(err.remoteStack).toBeUndefined();
+  });
+});

package/test/unit/schemas.createFolder.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { CreateFolderInput, EditFolderInput } from "../../src/schemas/index.js";
+
+describe("CreateFolderInput schema", () => {
+  it("accepts name only (top-level)", () => {
+    expect(() => CreateFolderInput.parse({ name: "My Folder" })).not.toThrow();
+  });
+
+  it("accepts name with parentFolderId", () => {
+    expect(() =>
+      CreateFolderInput.parse({ name: "Nested", parentFolderId: "abc123" })
+    ).not.toThrow();
+  });
+
+  it("rejects missing name", () => {
+    expect(() => CreateFolderInput.parse({})).toThrow();
+  });
+
+  it("rejects empty name", () => {
+    expect(() => CreateFolderInput.parse({ name: "" })).toThrow();
+  });
+});
+
+describe("EditFolderInput schema", () => {
+  it("accepts id and name", () => {
+    expect(() =>
+      EditFolderInput.parse({ id: "abc123", name: "Renamed" })
+    ).not.toThrow();
+  });
+
+  it("rejects missing id", () => {
+    expect(() => EditFolderInput.parse({ name: "Renamed" })).toThrow();
+  });
+
+  it("rejects empty name", () => {
+    expect(() => EditFolderInput.parse({ id: "abc123", name: "" })).toThrow();
+  });
+});

package/test/unit/schemas.createProject.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import { CreateProjectInput, EditProjectInput, ReviewIntervalInput } from "../../src/schemas/index.js";
+
+describe("ReviewIntervalInput schema", () => {
+  it("accepts valid steps and unit", () => {
+    expect(() =>
+      ReviewIntervalInput.parse({ steps: 2, unit: "weeks" })
+    ).not.toThrow();
+  });
+
+  it("rejects invalid unit", () => {
+    expect(() =>
+      ReviewIntervalInput.parse({ steps: 2, unit: "fortnights" })
+    ).toThrow();
+  });
+
+  it("rejects non-positive steps", () => {
+    expect(() =>
+      ReviewIntervalInput.parse({ steps: 0, unit: "weeks" })
+    ).toThrow();
+  });
+});
+
+describe("CreateProjectInput schema", () => {
+  it("accepts name only (top-level)", () => {
+    expect(() => CreateProjectInput.parse({ name: "My Project" })).not.toThrow();
+  });
+
+  it("accepts name with folderId", () => {
+    expect(() =>
+      CreateProjectInput.parse({ name: "My Project", folderId: "abc123" })
+    ).not.toThrow();
+  });
+
+  it("accepts valid type enum values", () => {
+    for (const type of ["parallel", "sequential", "singleActions"] as const) {
+      expect(() =>
+        CreateProjectInput.parse({ name: "P", type })
+      ).not.toThrow();
+    }
+  });
+
+  it("rejects invalid type", () => {
+    expect(() =>
+      CreateProjectInput.parse({ name: "P", type: "waterfall" })
+    ).toThrow();
+  });
+
+  it("accepts valid status values", () => {
+    for (const status of ["active", "onHold"] as const) {
+      expect(() =>
+        CreateProjectInput.parse({ name: "P", status })
+      ).not.toThrow();
+    }
+  });
+
+  it("accepts reviewInterval", () => {
+    expect(() =>
+      CreateProjectInput.parse({
+        name: "P",
+        reviewInterval: { steps: 1, unit: "months" },
+      })
+    ).not.toThrow();
+  });
+
+  it("rejects missing name", () => {
+    expect(() => CreateProjectInput.parse({})).toThrow();
+  });
+
+  it("rejects empty name", () => {
+    expect(() => CreateProjectInput.parse({ name: "" })).toThrow();
+  });
+});
+
+describe("EditProjectInput schema", () => {
+  it("accepts id with a single field", () => {
+    expect(() =>
+      EditProjectInput.parse({ id: "abc123", status: "onHold" })
+    ).not.toThrow();
+  });
+
+  it("accepts null deferDate to clear the field", () => {
+    expect(() =>
+      EditProjectInput.parse({ id: "abc123", deferDate: null })
+    ).not.toThrow();
+  });
+
+  it("accepts null dueDate", () => {
+    expect(() =>
+      EditProjectInput.parse({ id: "abc123", dueDate: null })
+    ).not.toThrow();
+  });
+
+  it("accepts structured reviewInterval", () => {
+    expect(() =>
+      EditProjectInput.parse({
+        id: "abc123",
+        reviewInterval: { steps: 2, unit: "weeks" },
+      })
+    ).not.toThrow();
+  });
+
+  it("rejects invalid reviewInterval unit", () => {
+    expect(() =>
+      EditProjectInput.parse({
+        id: "abc123",
+        reviewInterval: { steps: 2, unit: "fortnights" },
+      })
+    ).toThrow();
+  });
+
+  it("rejects missing id", () => {
+    expect(() => EditProjectInput.parse({ name: "Updated" })).toThrow();
+  });
+});

package/test/unit/schemas.createTask.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { CreateTaskInput, EditTaskInput } from "../../src/schemas/index.js";
+
+describe("CreateTaskInput schema", () => {
+  it("accepts name only (inbox placement)", () => {
+    expect(() => CreateTaskInput.parse({ name: "Buy milk" })).not.toThrow();
+  });
+
+  it("accepts name with projectId", () => {
+    expect(() =>
+      CreateTaskInput.parse({ name: "Write tests", projectId: "abc123" })
+    ).not.toThrow();
+  });
+
+  it("accepts name with parentTaskId", () => {
+    expect(() =>
+      CreateTaskInput.parse({ name: "Review PR", parentTaskId: "xyz789" })
+    ).not.toThrow();
+  });
+
+  it("accepts all optional fields", () => {
+    expect(() =>
+      CreateTaskInput.parse({
+        name: "Full task",
+        note: "some note",
+        flagged: true,
+        deferDate: "2026-04-10T00:00:00.000Z",
+        dueDate: "2026-04-15T00:00:00.000Z",
+        estimatedMinutes: 30,
+        projectId: "proj1",
+        tagIds: ["tag1", "tag2"],
+      })
+    ).not.toThrow();
+  });
+
+  it("rejects both projectId and parentTaskId", () => {
+    expect(() =>
+      CreateTaskInput.parse({
+        name: "Ambiguous",
+        projectId: "proj1",
+        parentTaskId: "task1",
+      })
+    ).toThrow();
+  });
+
+  it("rejects missing name", () => {
+    expect(() => CreateTaskInput.parse({})).toThrow();
+  });
+
+  it("rejects empty name", () => {
+    expect(() => CreateTaskInput.parse({ name: "" })).toThrow();
+  });
+});
+
+describe("EditTaskInput schema", () => {
+  it("accepts id with a single field", () => {
+    expect(() =>
+      EditTaskInput.parse({ id: "abc123", flagged: true })
+    ).not.toThrow();
+  });
+
+  it("accepts null deferDate to clear the field", () => {
+    expect(() =>
+      EditTaskInput.parse({ id: "abc123", deferDate: null })
+    ).not.toThrow();
+  });
+
+  it("accepts null dueDate", () => {
+    expect(() =>
+      EditTaskInput.parse({ id: "abc123", dueDate: null })
+    ).not.toThrow();
+  });
+
+  it("accepts null estimatedMinutes", () => {
+    expect(() =>
+      EditTaskInput.parse({ id: "abc123", estimatedMinutes: null })
+    ).not.toThrow();
+  });
+
+  it("rejects missing id", () => {
+    expect(() => EditTaskInput.parse({ name: "Updated" })).toThrow();
+  });
+
+  it("rejects empty id", () => {
+    expect(() => EditTaskInput.parse({ id: "", name: "Updated" })).toThrow();
+  });
+});

package/test/unit/schemas.editTag.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import { CreateTagInput, EditTagInput } from "../../src/schemas/index.js";
+
+describe("CreateTagInput schema", () => {
+  it("accepts name only (top-level)", () => {
+    expect(() => CreateTagInput.parse({ name: "Waiting" })).not.toThrow();
+  });
+
+  it("accepts name with parentTagId", () => {
+    expect(() =>
+      CreateTagInput.parse({ name: "Email", parentTagId: "abc123" })
+    ).not.toThrow();
+  });
+
+  it("rejects missing name", () => {
+    expect(() => CreateTagInput.parse({})).toThrow();
+  });
+
+  it("rejects empty name", () => {
+    expect(() => CreateTagInput.parse({ name: "" })).toThrow();
+  });
+});
+
+describe("EditTagInput schema", () => {
+  it("accepts id with name only", () => {
+    expect(() =>
+      EditTagInput.parse({ id: "abc123", name: "Renamed" })
+    ).not.toThrow();
+  });
+
+  it("accepts id with status only", () => {
+    expect(() =>
+      EditTagInput.parse({ id: "abc123", status: "onHold" })
+    ).not.toThrow();
+  });
+
+  it("accepts id with both name and status", () => {
+    expect(() =>
+      EditTagInput.parse({ id: "abc123", name: "New", status: "active" })
+    ).not.toThrow();
+  });
+
+  it("accepts all valid status values", () => {
+    for (const status of ["active", "onHold", "dropped"] as const) {
+      expect(() =>
+        EditTagInput.parse({ id: "abc123", status })
+      ).not.toThrow();
+    }
+  });
+
+  it("rejects neither name nor status (refine)", () => {
+    expect(() => EditTagInput.parse({ id: "abc123" })).toThrow();
+  });
+
+  it("rejects invalid status enum", () => {
+    expect(() =>
+      EditTagInput.parse({ id: "abc123", status: "paused" })
+    ).toThrow();
+  });
+
+  it("rejects missing id", () => {
+    expect(() => EditTagInput.parse({ name: "X" })).toThrow();
+  });
+});

package/test/unit/schemas.folderTagFiltering.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { ListFoldersFilter, ListTagsFilter } from "../../src/schemas/index.js";
+
+describe("ListFoldersFilter schema", () => {
+  it("accepts empty filter object", () => {
+    expect(() => ListFoldersFilter.parse({})).not.toThrow();
+  });
+
+  it("accepts status 'active'", () => {
+    expect(() => ListFoldersFilter.parse({ status: "active" })).not.toThrow();
+  });
+
+  it("accepts status 'dropped'", () => {
+    expect(() => ListFoldersFilter.parse({ status: "dropped" })).not.toThrow();
+  });
+
+  it("rejects invalid status value", () => {
+    expect(() => ListFoldersFilter.parse({ status: "pending" })).toThrow();
+  });
+});
+
+describe("ListTagsFilter schema", () => {
+  it("accepts empty filter object", () => {
+    expect(() => ListTagsFilter.parse({})).not.toThrow();
+  });
+
+  it("accepts status 'active'", () => {
+    expect(() => ListTagsFilter.parse({ status: "active" })).not.toThrow();
+  });
+
+  it("accepts status 'onHold'", () => {
+    expect(() => ListTagsFilter.parse({ status: "onHold" })).not.toThrow();
+  });
+
+  it("accepts status 'dropped'", () => {
+    expect(() => ListTagsFilter.parse({ status: "dropped" })).not.toThrow();
+  });
+
+  it("rejects invalid status value", () => {
+    expect(() => ListTagsFilter.parse({ status: "unknown" })).toThrow();
+  });
+});

package/test/unit/schemas.listProjects.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { ListProjectsFilter } from "../../src/schemas/index.js";
+
+describe("ListProjectsFilter schema", () => {
+  it("accepts empty filter object", () => {
+    expect(() => ListProjectsFilter.parse({})).not.toThrow();
+  });
+
+  it("accepts status array", () => {
+    expect(() =>
+      ListProjectsFilter.parse({ status: ["active", "onHold"] })
+    ).not.toThrow();
+  });
+
+  it("accepts folderId", () => {
+    expect(() =>
+      ListProjectsFilter.parse({ folderId: "folder123" })
+    ).not.toThrow();
+  });
+
+  it("accepts flagged: true", () => {
+    expect(() =>
+      ListProjectsFilter.parse({ flagged: true })
+    ).not.toThrow();
+  });
+
+  it("accepts all fields together", () => {
+    expect(() =>
+      ListProjectsFilter.parse({ status: ["active"], folderId: "f1", flagged: true })
+    ).not.toThrow();
+  });
+
+  it("rejects invalid status enum in array", () => {
+    expect(() =>
+      ListProjectsFilter.parse({ status: ["active", "flying"] })
+    ).toThrow();
+  });
+
+  it("rejects flagged: false (must be literal true or absent)", () => {
+    expect(() =>
+      ListProjectsFilter.parse({ flagged: false })
+    ).toThrow();
+  });
+});

package/test/unit/schemas.moveOperations.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { MoveTaskInput, MoveProjectInput } from "../../src/schemas/index.js";
+
+describe("MoveTaskInput schema", () => {
+  it("accepts projectId only", () => {
+    expect(() =>
+      MoveTaskInput.parse({ id: "t1", projectId: "p1" })
+    ).not.toThrow();
+  });
+
+  it("accepts parentTaskId only", () => {
+    expect(() =>
+      MoveTaskInput.parse({ id: "t1", parentTaskId: "t2" })
+    ).not.toThrow();
+  });
+
+  it("rejects both projectId and parentTaskId", () => {
+    expect(() =>
+      MoveTaskInput.parse({ id: "t1", projectId: "p1", parentTaskId: "t2" })
+    ).toThrow();
+  });
+
+  it("rejects neither projectId nor parentTaskId", () => {
+    expect(() =>
+      MoveTaskInput.parse({ id: "t1" })
+    ).toThrow();
+  });
+
+  it("rejects missing id", () => {
+    expect(() =>
+      MoveTaskInput.parse({ projectId: "p1" })
+    ).toThrow();
+  });
+});
+
+describe("MoveProjectInput schema", () => {
+  it("accepts folderId as string", () => {
+    expect(() =>
+      MoveProjectInput.parse({ id: "p1", folderId: "f1" })
+    ).not.toThrow();
+  });
+
+  it("accepts folderId as null", () => {
+    expect(() =>
+      MoveProjectInput.parse({ id: "p1", folderId: null })
+    ).not.toThrow();
+  });
+
+  it("rejects missing id", () => {
+    expect(() =>
+      MoveProjectInput.parse({ folderId: "f1" })
+    ).toThrow();
+  });
+
+  it("rejects missing folderId (undefined not same as null)", () => {
+    expect(() =>
+      MoveProjectInput.parse({ id: "p1" })
+    ).toThrow();
+  });
+});

package/test/unit/schemas.recurrence.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from "vitest";
+import { RepetitionRuleInput, CreateTaskInput, EditTaskInput } from "../../src/schemas/index.js";
+
+describe("RepetitionRuleInput schema", () => {
+  it("accepts daily repetition", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({ frequency: "daily", interval: 1, method: "fixed" })
+    ).not.toThrow();
+  });
+
+  it("accepts weekly repetition with daysOfWeek", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({
+        frequency: "weekly",
+        interval: 2,
+        daysOfWeek: ["monday", "wednesday", "friday"],
+        method: "start",
+      })
+    ).not.toThrow();
+  });
+
+  it("accepts monthly repetition", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({ frequency: "monthly", interval: 1, method: "dueDate" })
+    ).not.toThrow();
+  });
+
+  it("accepts yearly repetition", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({ frequency: "yearly", interval: 1, method: "fixed" })
+    ).not.toThrow();
+  });
+
+  it("defaults interval to 1 when omitted", () => {
+    const result = RepetitionRuleInput.parse({ frequency: "daily", method: "fixed" });
+    expect(result.interval).toBe(1);
+  });
+
+  it("rejects daysOfWeek on non-weekly frequency", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({
+        frequency: "daily",
+        interval: 1,
+        daysOfWeek: ["monday"],
+        method: "fixed",
+      })
+    ).toThrow();
+  });
+
+  it("rejects daysOfWeek on monthly frequency", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({
+        frequency: "monthly",
+        interval: 1,
+        daysOfWeek: ["tuesday"],
+        method: "fixed",
+      })
+    ).toThrow();
+  });
+
+  it("rejects interval of zero", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({ frequency: "daily", interval: 0, method: "fixed" })
+    ).toThrow();
+  });
+
+  it("rejects negative interval", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({ frequency: "weekly", interval: -1, method: "fixed" })
+    ).toThrow();
+  });
+
+  it("rejects invalid frequency", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({ frequency: "hourly", interval: 1, method: "fixed" })
+    ).toThrow();
+  });
+
+  it("rejects invalid method", () => {
+    expect(() =>
+      RepetitionRuleInput.parse({ frequency: "daily", interval: 1, method: "completion" })
+    ).toThrow();
+  });
+});
+
+describe("CreateTaskInput with repetitionRule", () => {
+  it("accepts task without repetitionRule (backward compat)", () => {
+    expect(() => CreateTaskInput.parse({ name: "Buy milk" })).not.toThrow();
+  });
+
+  it("accepts task with repetitionRule", () => {
+    expect(() =>
+      CreateTaskInput.parse({
+        name: "Stand-up",
+        repetitionRule: { frequency: "daily", interval: 1, method: "fixed" },
+      })
+    ).not.toThrow();
+  });
+});
+
+describe("EditTaskInput with repetitionRule", () => {
+  it("accepts edit without repetitionRule (leave unchanged)", () => {
+    expect(() => EditTaskInput.parse({ id: "abc", flagged: true })).not.toThrow();
+  });
+
+  it("accepts edit with repetitionRule object (set rule)", () => {
+    expect(() =>
+      EditTaskInput.parse({
+        id: "abc",
+        repetitionRule: { frequency: "weekly", interval: 1, method: "start" },
+      })
+    ).not.toThrow();
+  });
+
+  it("accepts edit with repetitionRule null (clear rule)", () => {
+    expect(() =>
+      EditTaskInput.parse({ id: "abc", repetitionRule: null })
+    ).not.toThrow();
+  });
+});