@scardis/omnifocus-mcp 0.1.0

package/test/unit/schemas.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect } from "vitest";
+import {
+  ProjectType,
+  ProjectStatus,
+  TaskStatus,
+  FolderStatus,
+  TagStatus,
+  TaskSummary,
+  TaskDetail,
+  ProjectSummary,
+  FolderSummary,
+  TagSummary,
+} from "../../src/schemas/index.js";
+
+describe("ProjectType enum", () => {
+  it("accepts valid values", () => {
+    expect(ProjectType.parse("parallel")).toBe("parallel");
+    expect(ProjectType.parse("sequential")).toBe("sequential");
+    expect(ProjectType.parse("singleActions")).toBe("singleActions");
+  });
+
+  it("rejects boolean (the sequential-as-boolean regression)", () => {
+    expect(() => ProjectType.parse(true)).toThrow();
+    expect(() => ProjectType.parse(false)).toThrow();
+  });
+
+  it("rejects string 'true' (the sequential-as-string regression)", () => {
+    expect(() => ProjectType.parse("true")).toThrow();
+    expect(() => ProjectType.parse("false")).toThrow();
+  });
+});
+
+describe("ProjectSummary schema", () => {
+  const valid = {
+    id: "abc123",
+    name: "My Project",
+    folderPath: "Work ▸ Projects",
+    folderId: "folder1",
+    status: "active",
+    type: "parallel",
+    flagged: false,
+  };
+
+  it("parses a valid summary", () => {
+    expect(() => ProjectSummary.parse(valid)).not.toThrow();
+  });
+
+  it("rejects empty id", () => {
+    expect(() => ProjectSummary.parse({ ...valid, id: "" })).toThrow();
+  });
+
+  it("rejects invalid status", () => {
+    expect(() =>
+      ProjectSummary.parse({ ...valid, status: "unknown" })
+    ).toThrow();
+  });
+});
+
+describe("TaskSummary schema", () => {
+  const valid = {
+    id: "t1",
+    name: "Buy milk",
+    status: "available",
+    flagged: false,
+    containerId: "p1",
+    containerType: "project",
+    dueDate: null,
+    tagIds: [],
+  };
+
+  it("parses a valid task summary", () => {
+    expect(() => TaskSummary.parse(valid)).not.toThrow();
+  });
+
+  it("rejects items-as-string on TaskDetail (the batch_remove_items regression)", () => {
+    // The regression: passing a serialised JSON string where an array is expected
+    const detailBase = {
+      id: "t1", name: "Buy milk", note: "", status: "available",
+      flagged: false, deferDate: null, dueDate: null, completionDate: null,
+      estimatedMinutes: null, containerId: "p1", containerType: "project",
+    };
+    expect(() =>
+      TaskDetail.parse({ ...detailBase, tagIds: '["abc"]' })
+    ).toThrow();
+  });
+});
+
+describe("FolderSummary schema", () => {
+  it("parses valid folder summary with null parent", () => {
+    expect(() =>
+      FolderSummary.parse({
+        id: "f1",
+        name: "Work",
+        path: "Work",
+        parentId: null,
+        status: "active",
+      })
+    ).not.toThrow();
+  });
+
+  it("rejects invalid status", () => {
+    expect(() =>
+      FolderSummary.parse({
+        id: "f1",
+        name: "Work",
+        path: "Work",
+        parentId: null,
+        status: "onHold", // folders only have active/dropped
+      })
+    ).toThrow();
+  });
+});
+
+describe("TagSummary schema", () => {
+  it("parses valid tag summary with onHold status", () => {
+    expect(() =>
+      TagSummary.parse({
+        id: "t1",
+        name: "Waiting",
+        path: "Waiting",
+        parentId: null,
+        status: "onHold",
+      })
+    ).not.toThrow();
+  });
+});

package/test/unit/snippetLoader.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// We test the loader logic directly by pointing it at temp fixture files.
+// The real loader uses __dirname-relative paths; we test the core validation
+// logic by importing the internals.
+
+describe("snippet __ARGS__ validation", () => {
+  // Test the validation logic inline (mirrors snippetLoader.ts exactly)
+  function validate(content: string, name: string): void {
+    const matches = content.split("__ARGS__").length - 1;
+    if (matches === 0) {
+      throw new Error(`Snippet "${name}" contains no __ARGS__ placeholder.`);
+    }
+    if (matches > 1) {
+      throw new Error(
+        `Snippet "${name}" contains ${matches} __ARGS__ placeholders. Exactly one is required.`
+      );
+    }
+  }
+
+  it("accepts snippet with exactly one __ARGS__", () => {
+    expect(() =>
+      validate("const args = __ARGS__; return args;", "valid")
+    ).not.toThrow();
+  });
+
+  it("rejects snippet with zero __ARGS__", () => {
+    expect(() =>
+      validate("const x = 1; return x;", "no-placeholder")
+    ).toThrow(/no __ARGS__ placeholder/);
+  });
+
+  it("rejects snippet with two __ARGS__", () => {
+    expect(() =>
+      validate("const a = __ARGS__; const b = __ARGS__;", "two-placeholders")
+    ).toThrow(/2 __ARGS__ placeholders/);
+  });
+
+  it("all real snippets contain exactly one __ARGS__", async () => {
+    const { readdirSync, readFileSync } = await import("fs");
+    const { join: pathJoin } = await import("path");
+    const { fileURLToPath } = await import("url");
+    const { dirname } = await import("path");
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const snippetsDir = pathJoin(__dirname, "../../src/snippets");
+    const files = readdirSync(snippetsDir).filter((f) => f.endsWith(".js"));
+    expect(files.length).toBeGreaterThan(0);
+    for (const file of files) {
+      const content = readFileSync(pathJoin(snippetsDir, file), "utf-8");
+      expect(() => validate(content, file), `${file}`).not.toThrow();
+    }
+  });
+});

package/test/unit/tools.deleteTask.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { deleteTaskTool } from "../../src/tools/deleteTask.js";
+
+describe("deleteTask tool description", () => {
+  it("contains confirmation language", () => {
+    const desc = deleteTaskTool.description.toLowerCase();
+    expect(desc).toMatch(/confirm/);
+  });
+
+  it("mentions permanent deletion", () => {
+    const desc = deleteTaskTool.description.toLowerCase();
+    expect(desc).toMatch(/permanent/);
+  });
+
+  it("warns about subtasks", () => {
+    const desc = deleteTaskTool.description.toLowerCase();
+    expect(desc).toMatch(/subtask/);
+  });
+});

package/test/unit/tools.listTasks.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect } from "vitest";
+import { listTasksSchema } from "../../src/tools/listTasks.js";
+import { ListTasksFilter } from "../../src/schemas/index.js";
+
+describe("listTasks input validation", () => {
+  it("accepts projectId scope", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { projectId: "abc" } })
+    ).not.toThrow();
+  });
+
+  it("accepts folderId scope", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { folderId: "f1" } })
+    ).not.toThrow();
+  });
+
+  it("accepts inbox scope", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { inbox: true } })
+    ).not.toThrow();
+  });
+
+  it("accepts all scope", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { all: true } })
+    ).not.toThrow();
+  });
+
+  it("rejects scope with both projectId and inbox (mutual exclusivity)", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { projectId: "abc", inbox: true } })
+    ).toThrow();
+  });
+
+  it("rejects scope with both folderId and all", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { folderId: "f1", all: true } })
+    ).toThrow();
+  });
+
+  it("rejects empty scope object (no discriminator)", () => {
+    expect(() => listTasksSchema.parse({ scope: {} })).toThrow();
+  });
+
+  it("rejects missing scope", () => {
+    expect(() => listTasksSchema.parse({})).toThrow();
+  });
+
+  it("rejects empty projectId string", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { projectId: "" } })
+    ).toThrow();
+  });
+
+  it("accepts filter with flagged", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { all: true }, filter: { flagged: true } })
+    ).not.toThrow();
+  });
+
+  it("accepts filter with status array", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { all: true }, filter: { status: ["overdue", "dueSoon"] } })
+    ).not.toThrow();
+  });
+
+  it("accepts filter with tagId", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { all: true }, filter: { tagId: "tag123" } })
+    ).not.toThrow();
+  });
+
+  it("accepts filter with dueBeforeDate", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { all: true }, filter: { dueBeforeDate: "2026-04-09T23:59:59.000Z" } })
+    ).not.toThrow();
+  });
+
+  it("accepts limit", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { all: true }, limit: 50 })
+    ).not.toThrow();
+  });
+
+  it("rejects non-positive limit", () => {
+    expect(() =>
+      listTasksSchema.parse({ scope: { all: true }, limit: 0 })
+    ).toThrow();
+  });
+});
+
+describe("ListTasksFilter schema", () => {
+  it("accepts empty filter object", () => {
+    expect(() => ListTasksFilter.parse({})).not.toThrow();
+  });
+
+  it("accepts all valid filter fields", () => {
+    expect(() =>
+      ListTasksFilter.parse({
+        flagged: true,
+        status: ["available", "overdue"],
+        tagId: "tag123",
+        dueBeforeDate: "2026-04-09T23:59:59.000Z",
+      })
+    ).not.toThrow();
+  });
+
+  it("rejects invalid status enum in array", () => {
+    expect(() =>
+      ListTasksFilter.parse({ status: ["available", "flying"] })
+    ).toThrow();
+  });
+
+  it("rejects non-ISO dueBeforeDate", () => {
+    expect(() =>
+      ListTasksFilter.parse({ dueBeforeDate: "April 9, 2026" })
+    ).toThrow();
+  });
+
+  it("rejects flagged: false (must be literal true or absent)", () => {
+    expect(() =>
+      ListTasksFilter.parse({ flagged: false })
+    ).toThrow();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["test/unit/**/*.test.ts"],
+    environment: "node",
+  },
+});

package/vitest.integration.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["test/integration/**/*.int.test.ts"],
+    environment: "node",
+    pool: "forks",
+    poolOptions: {
+      forks: {
+        maxForks: 1,
+        minForks: 1,
+      },
+    },
+    globalSetup: ["./test/integration/preflight.ts"],
+    testTimeout: 60_000,
+    hookTimeout: 60_000,
+  },
+});