@scardis/omnifocus-mcp 0.1.0 → 0.1.2

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

@@ -1,120 +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 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();
-  });
-});

package/test/unit/schemas.test.ts

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

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

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

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

@@ -1,19 +0,0 @@
-{
-  "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

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

package/vitest.integration.config.ts

@@ -1,18 +0,0 @@
-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,
-  },
-});