@scardis/omnifocus-mcp 0.1.1 → 0.1.2

package/test/unit/bridge.injection.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-/**
- * Proves Design Decision 2:
- * JSON.stringify(args) produces a valid JS expression for any args value,
- * including apostrophes, quotes, backslashes, newlines, and unicode.
- *
- * We test the injection logic directly without hitting the bridge or OmniFocus.
- */
-
-const TRICKY_ARGS = {
-  name: "Finn's \"birthday\" 🎯",
-  note: "line1\nline2\ttabbed",
-  path: "Work ▸ Clients ▸ Acme",
-  backslash: "C:\\Users\\test",
-  unicode: "\u2603 snowman \u0000 null",
-};
-
-function injectArgs(template: string, args: unknown): string {
-  return template.replace("__ARGS__", JSON.stringify(args));
-}
-
-describe("argument injection safety", () => {
-  it("produces valid JavaScript for tricky string values", () => {
-    const template = "(() => { const args = __ARGS__; return args; })()";
-    const injected = injectArgs(template, TRICKY_ARGS);
-    // new Function wraps the body in a function; we eval the IIFE directly
-    let result: unknown;
-    expect(() => {
-      result = new Function(`return ${injected}`)();
-    }).not.toThrow();
-    expect(result).toEqual(TRICKY_ARGS);
-  });
-
-  it("recovers apostrophes exactly", () => {
-    const template = "(() => { const args = __ARGS__; return args; })()";
-    const args = { name: "it's a test's value" };
-    const injected = injectArgs(template, args);
-    const result = new Function(`return ${injected}`)() as typeof args;
-    expect(result.name).toBe("it's a test's value");
-  });
-
-  it("recovers double quotes exactly", () => {
-    const template = "(() => { const args = __ARGS__; return args; })()";
-    const args = { name: 'She said "hello"' };
-    const injected = injectArgs(template, args);
-    const result = new Function(`return ${injected}`)() as typeof args;
-    expect(result.name).toBe('She said "hello"');
-  });
-
-  it("recovers newlines exactly", () => {
-    const template = "(() => { const args = __ARGS__; return args; })()";
-    const args = { note: "line1\nline2\nline3" };
-    const injected = injectArgs(template, args);
-    const result = new Function(`return ${injected}`)() as typeof args;
-    expect(result.note).toBe("line1\nline2\nline3");
-  });
-
-  it("recovers unicode exactly", () => {
-    const template = "(() => { const args = __ARGS__; return args; })()";
-    const args = { symbol: "▸ ★ 🎉" };
-    const injected = injectArgs(template, args);
-    const result = new Function(`return ${injected}`)() as typeof args;
-    expect(result.symbol).toBe("▸ ★ 🎉");
-  });
-});

package/test/unit/resultProtocol.test.ts

@@ -1,71 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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 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 clearRepetitionRule true (clear rule)", () => {
-    expect(() =>
-      EditTaskInput.parse({ id: "abc", clearRepetitionRule: true })
-    ).not.toThrow();
-  });
-});