@scardis/omnifocus-mcp 0.1.0

package/openspec/specs/task-write/spec.md

@@ -0,0 +1,115 @@
+# task-write
+
+## Purpose
+
+TBD — Defines tools for creating and mutating OmniFocus tasks, including create, edit, complete, drop, and delete operations.
+
+## Requirements
+
+### Requirement: Create task
+
+The system SHALL provide a `create_task` tool that creates a new OmniFocus task and returns its full detail record. The tool SHALL accept `{name: string, note?: string, flagged?: boolean, deferDate?: string, plannedDate?: string, dueDate?: string, estimatedMinutes?: number, projectId?: string, parentTaskId?: string, tagIds?: string[], repetitionRule?: RepetitionRuleInput}`. Placement SHALL be determined as follows: if both `projectId` and `parentTaskId` are provided the tool SHALL return an error; if only `projectId` is provided the task is placed at the project root; if only `parentTaskId` is provided the task is created as a subtask inheriting its parent's project; if neither is provided the task is placed in the inbox. When `repetitionRule` is provided, the task SHALL have the specified recurrence set at creation.
+
+#### Scenario: Create inbox task
+- **WHEN** `create_task` is called with `{name: "Buy milk"}` and no `projectId` or `parentTaskId`
+- **THEN** the tool creates the task in the OmniFocus inbox and returns its full detail record including a stable `id`
+
+#### Scenario: Create task in a project
+- **WHEN** `create_task` is called with `{name: "Write tests", projectId: "abc123"}`
+- **THEN** the tool creates the task at the root of the specified project and returns its full detail record
+
+#### Scenario: Create subtask
+- **WHEN** `create_task` is called with `{name: "Review PR", parentTaskId: "xyz789"}`
+- **THEN** the tool creates the task as a child of the specified parent task and returns its full detail record
+
+#### Scenario: Ambiguous placement is rejected
+- **WHEN** `create_task` is called with both `projectId` and `parentTaskId`
+- **THEN** the tool returns a validation error before any snippet executes
+
+#### Scenario: Non-existent project returns not-found error
+- **WHEN** `create_task` is called with a `projectId` that does not correspond to any project
+- **THEN** the tool returns a structured not-found error
+
+#### Scenario: Create task with repetition rule
+- **WHEN** `create_task` is called with `{ name: "Weekly review", repetitionRule: { frequency: "weekly", interval: 1, method: "start" } }`
+- **THEN** the task is created with the specified recurrence and the returned TaskDetail includes the parsed repetitionRule
+
+#### Scenario: Create task with planned date
+- **WHEN** `create_task` is called with `{ name: "Clean kitchen", plannedDate: "2026-04-15T09:00:00Z" }`
+- **THEN** the task is created with the specified planned date and the returned TaskDetail includes `plannedDate`
+
+### Requirement: Edit task
+
+The system SHALL provide an `edit_task` tool that modifies an existing task and returns its updated full detail record. The tool SHALL accept `{id: string}` plus any subset of `{name?: string, note?: string, flagged?: boolean, deferDate?: string | null, plannedDate?: string | null, dueDate?: string | null, estimatedMinutes?: number | null, tagIds?: string[], repetitionRule?: RepetitionRuleInput | null}`. Fields omitted from the call SHALL be left unchanged. When `tagIds` is provided it SHALL replace the task's entire tag set; when omitted, tags SHALL be unchanged. Passing `null` for a date or `estimatedMinutes` SHALL clear the field. Passing `repetitionRule: null` SHALL clear the task's recurrence; passing a `RepetitionRuleInput` object SHALL set or replace the recurrence; omitting `repetitionRule` SHALL leave the existing recurrence unchanged.
+
+#### Scenario: Edit a single field
+- **WHEN** `edit_task` is called with `{id: "abc123", flagged: true}`
+- **THEN** only the `flagged` field is changed; all other fields retain their previous values
+
+#### Scenario: Replace tag set
+- **WHEN** `edit_task` is called with `{id: "abc123", tagIds: ["t1", "t2"]}`
+- **THEN** the task's tags are set to exactly `["t1", "t2"]`, replacing any previously assigned tags
+
+#### Scenario: Clear a date field
+- **WHEN** `edit_task` is called with `{id: "abc123", dueDate: null}`
+- **THEN** the task's due date is cleared
+
+#### Scenario: Clear planned date
+- **WHEN** `edit_task` is called with `{id: "abc123", plannedDate: null}`
+- **THEN** the task's planned date is cleared
+
+#### Scenario: Non-existent task returns not-found error
+- **WHEN** `edit_task` is called with an ID that does not correspond to any task
+- **THEN** the tool returns a structured not-found error
+
+#### Scenario: Non-existent tag ID returns not-found error
+- **WHEN** `edit_task` is called with a `tagIds` array containing an ID that does not correspond to any tag
+- **THEN** the tool returns a structured not-found error and the task is not modified
+
+#### Scenario: Set repetition via edit
+- **WHEN** `edit_task` is called with `{ id: "t1", repetitionRule: { frequency: "monthly", interval: 1, method: "dueDate" } }`
+- **THEN** the task's recurrence is set and all other fields are unchanged
+
+#### Scenario: Clear repetition via edit
+- **WHEN** `edit_task` is called with `{ id: "t1", repetitionRule: null }`
+- **THEN** the task's recurrence is cleared and all other fields are unchanged
+
+### Requirement: Complete task
+
+The system SHALL provide a `complete_task` tool that marks an existing task complete using OmniJS `markComplete()` and returns the task's updated full detail record.
+
+#### Scenario: Complete an existing task
+- **WHEN** `complete_task` is called with the ID of an available task
+- **THEN** the task's status becomes `"complete"` and the tool returns the updated detail record
+
+#### Scenario: Non-existent task returns not-found error
+- **WHEN** `complete_task` is called with an ID that does not correspond to any task
+- **THEN** the tool returns a structured not-found error
+
+### Requirement: Drop task
+
+The system SHALL provide a `drop_task` tool that marks an existing task dropped using OmniJS `drop()` and returns the task's updated full detail record.
+
+#### Scenario: Drop an existing task
+- **WHEN** `drop_task` is called with the ID of an available task
+- **THEN** the task's status becomes `"dropped"` and the tool returns the updated detail record
+
+#### Scenario: Non-existent task returns not-found error
+- **WHEN** `drop_task` is called with an ID that does not correspond to any task
+- **THEN** the tool returns a structured not-found error
+
+### Requirement: Delete task
+
+The system SHALL provide a `delete_task` tool that permanently deletes a task and all its subtasks using OmniJS `deleteObject()`. The tool description SHALL instruct the AI to confirm with the user before invoking this tool, noting that deletion is permanent and includes all subtasks.
+
+#### Scenario: Delete an existing task
+- **WHEN** `delete_task` is called with the ID of an existing task
+- **THEN** the task and all its subtasks are permanently removed from OmniFocus and the tool returns a confirmation envelope
+
+#### Scenario: Delete task with subtasks removes all children
+- **WHEN** `delete_task` is called with the ID of a task that has subtasks
+- **THEN** the task and all descendant subtasks are deleted
+
+#### Scenario: Non-existent task returns not-found error
+- **WHEN** `delete_task` is called with an ID that does not correspond to any task
+- **THEN** the tool returns a structured not-found error

package/openspec/specs/url-automation/spec.md

@@ -0,0 +1,15 @@
+# url-automation
+
+## Purpose
+
+Covers `omnifocus://` URL construction and parsing. Individual tools will be defined in the `url-automation` change.
+
+## Requirements
+
+### Requirement: Capability declared
+
+The `url-automation` capability SHALL cover `omnifocus://` URL construction (including task-paste format for bulk creation, add-to-inbox URLs, and deep links to entities by ID) and parsing of incoming `omnifocus://` URLs into structured form. Requirements for individual tools SHALL be added by the `url-automation` change.
+
+#### Scenario: Capability is named and scoped
+- **WHEN** a future change proposes adding URL-automation tools
+- **THEN** it lands requirements under this capability rather than inventing a new capability name

package/openspec/specs/window-state/spec.md

@@ -0,0 +1,15 @@
+# window-state
+
+## Purpose
+
+Covers read-only inspection of OmniFocus document window state. Window mutation is an explicit non-goal. Individual tools will be defined in the `perspectives-and-windows` change.
+
+## Requirements
+
+### Requirement: Capability declared
+
+The `window-state` capability SHALL cover read-only inspection of OmniFocus document window state, including the currently active window, active perspective, sidebar selection, and content selection. Window *mutation* (resize, close, focus, open) is an explicit non-goal. Requirements for individual tools SHALL be added by the `perspectives-and-windows` change.
+
+#### Scenario: Capability is named and read-only scope is fixed
+- **WHEN** a future change proposes adding window-state tools
+- **THEN** it lands read-only requirements under this capability; any mutation proposal requires first revisiting the non-goal in design

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@scardis/omnifocus-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for OmniFocus via Omni Automation JavaScript API",
+  "license": "MIT",
+  "mcpName": "io.github.steveardis/omnifocus",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "omnifocus-mcp": "dist/server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "start": "tsx src/server.ts",
+    "test": "vitest run --config vitest.config.ts",
+    "test:integration": "node -e \"if(process.platform!=='darwin'){console.error('Integration tests require macOS');process.exit(1)}\" && vitest run --config vitest.integration.config.ts",
+    "test:cleanup-fixtures": "tsx scripts/cleanup-fixtures.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  }
+}

package/scripts/cleanup-fixtures.ts

@@ -0,0 +1,89 @@
+/**
+ * Cleanup script: removes any stale __MCP_TEST_*__ folders, __mcp_*__ projects,
+ * __MCP_*__ tags, and __mcp_*__ inbox tasks from OmniFocus.
+ * Run via: npm run test:cleanup-fixtures
+ */
+
+import { spawnSync } from "child_process";
+
+const snippet = `(() => {
+  function deleteFolder(f) {
+    f.flattenedProjects.forEach(function(p) { deleteObject(p); });
+    f.folders.forEach(function(child) { deleteFolder(child); });
+    deleteObject(f);
+  }
+  var removed = [];
+
+  // Stale test folders
+  flattenedFolders.filter(function(f) {
+    return f.name.startsWith('__MCP_TEST_') && f.name.endsWith('__');
+  }).forEach(function(f) { removed.push("folder: " + f.name); deleteFolder(f); });
+
+  // Stale test projects (orphaned at top level by move_project tests)
+  flattenedProjects.filter(function(p) {
+    return p.name.startsWith('__mcp_') && p.name.endsWith('__');
+  }).forEach(function(p) { removed.push("project: " + p.name); deleteObject(p); });
+
+  // Stale test tags
+  flattenedTags.filter(function(t) {
+    return (t.name.startsWith('__mcp_') || t.name.startsWith('__MCP_')) && t.name.endsWith('__');
+  }).forEach(function(t) { removed.push("tag: " + t.name); deleteObject(t); });
+
+  // Stale test inbox tasks
+  inbox.filter(function(t) {
+    return t.name.startsWith('__mcp_') && t.name.endsWith('__');
+  }).forEach(function(t) { removed.push("task: " + t.name); deleteObject(t); });
+
+  return JSON.stringify({ok:true,data:{removed:removed,count:removed.length}});
+})()`;
+
+const script = `
+(function() {
+  var app = Application('OmniFocus');
+  app.includeStandardAdditions = true;
+  try {
+    var r = app.evaluateJavascript(${JSON.stringify(snippet)});
+    $.NSFileHandle.fileHandleWithStandardOutput.writeData(
+      $.NSString.alloc.initWithString(r+'\\n').dataUsingEncoding($.NSUTF8StringEncoding)
+    );
+  } catch(e) {
+    $.NSFileHandle.fileHandleWithStandardOutput.writeData(
+      $.NSString.alloc.initWithString(JSON.stringify({ok:false,error:{message:e.message}})+'\\n').dataUsingEncoding($.NSUTF8StringEncoding)
+    );
+  }
+})();
+`;
+
+const result = spawnSync("osascript", ["-l", "JavaScript"], {
+  input: script,
+  encoding: "utf-8",
+  timeout: 15_000,
+});
+
+const stdout = result.stdout || "";
+const line = stdout.split("\n").find((l) => l.trim().startsWith("{"));
+if (!line) {
+  console.error("No output from OmniFocus:", stdout);
+  process.exit(1);
+}
+
+const parsed = JSON.parse(line) as {
+  ok: boolean;
+  data?: { removed: string[]; count: number };
+  error?: { message: string };
+};
+
+if (!parsed.ok) {
+  console.error("Cleanup failed:", parsed.error?.message);
+  process.exit(1);
+}
+
+const { removed, count } = parsed.data!;
+if (count === 0) {
+  console.log("No stale test fixtures found.");
+} else {
+  console.log(`Removed ${count} stale test fixture(s):`);
+  for (const item of removed) {
+    console.log(`  - ${item}`);
+  }
+}

package/server.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.steveardis/omnifocus",
+  "title": "OmniFocus",
+  "description": "MCP server for OmniFocus (macOS task manager) via Omni Automation JavaScript API. Full CRUD on tasks, projects, folders, and tags, plus repetition rules, planned dates, filtering, and move operations.",
+  "repository": {
+    "url": "https://github.com/steveardis/omnifocus-mcp",
+    "source": "github"
+  },
+  "version": "0.1.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@scardis/omnifocus-mcp",
+      "version": "0.1.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

package/src/runtime/bridge.ts

@@ -0,0 +1,97 @@
+import { spawn } from "child_process";
+import { loadSnippet } from "./snippetLoader.js";
+import { buildJxaScript } from "./jxaShim.js";
+import { parseResultLine, ExecutionError } from "./resultProtocol.js";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+export interface RunOptions {
+  timeoutMs?: number;
+}
+
+/**
+ * Execute an OmniJS snippet inside OmniFocus via the JXA bridge.
+ *
+ * @param name - Snippet filename (without .js extension) under src/snippets/
+ * @param args - Arguments to inject. Embedded as a JSON literal; safe for
+ *               all unicode, apostrophes, quotes, etc. (Design Decision 2).
+ * @param opts - Optional timeout override (default 30s)
+ * @returns The `data` field from the success envelope
+ * @throws ExecutionError if the snippet throws inside OmniJS
+ * @throws Error on timeout, process errors, or protocol violations
+ */
+export async function runSnippet(
+  name: string,
+  args: unknown,
+  opts: RunOptions = {}
+): Promise<unknown> {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+  // Load and inject args — the only interpolation allowed (Decision 2)
+  const template = loadSnippet(name);
+  const snippet = template.replace("__ARGS__", JSON.stringify(args));
+
+  // Wrap snippet in JXA shim
+  const jxaScript = buildJxaScript(snippet);
+
+  return new Promise((resolve, reject) => {
+    const MAX_OUTPUT_BYTES = 10 * 1024 * 1024; // 10 MB
+
+    const ac = new AbortController();
+    const timer = setTimeout(() => {
+      ac.abort();
+      child.kill("SIGKILL");
+      reject(new Error(`Snippet "${name}" timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    const child = spawn("osascript", ["-l", "JavaScript"], {
+      signal: ac.signal,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
+      if (stdout.length > MAX_OUTPUT_BYTES) {
+        child.kill("SIGKILL");
+        clearTimeout(timer);
+        reject(new Error(`Snippet "${name}" exceeded maximum output size`));
+      }
+    });
+
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      if ((err as NodeJS.ErrnoException).code === "ABORT_ERR") return; // handled by timer
+      reject(err);
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      try {
+        const envelope = parseResultLine(stdout);
+        if (envelope.ok) {
+          resolve(envelope.data);
+        } else {
+          reject(new ExecutionError(envelope.error));
+        }
+      } catch (parseErr) {
+        const hint = stdout.slice(0, 200) || stderr.slice(0, 200);
+        reject(
+          new Error(
+            `Failed to parse bridge output for snippet "${name}" (exit ${code})` +
+              (hint ? `: ${hint}` : "")
+          )
+        );
+      }
+    });
+
+    // Write JXA script to stdin
+    child.stdin.write(jxaScript);
+    child.stdin.end();
+  });
+}

package/src/runtime/index.ts

@@ -0,0 +1,4 @@
+export { runSnippet, type RunOptions } from "./bridge.js";
+export { loadSnippet, clearSnippetCache } from "./snippetLoader.js";
+export { parseResultLine, ExecutionError, type ResultEnvelope } from "./resultProtocol.js";
+export { buildJxaScript } from "./jxaShim.js";

package/src/runtime/jxaShim.ts

@@ -0,0 +1,55 @@
+/**
+ * JXA wrapper template. The `__SNIPPET__` placeholder is replaced with the
+ * OmniJS snippet to execute. The resulting script is passed to
+ * `osascript -l JavaScript` via stdin.
+ *
+ * This shim:
+ *  - Calls Application('OmniFocus').evaluateJavascript() with the snippet
+ *  - Wraps in try/catch
+ *  - Prints exactly one line of JSON: {ok, data} | {ok: false, error: {...}}
+ *
+ * The JXA scripting dictionary is used ONLY for evaluateJavascript.
+ * No other scripting-dictionary domain methods are invoked here.
+ */
+export const JXA_SHIM_TEMPLATE = `
+(function() {
+  var snippet = __SNIPPET__;
+  var app = Application('OmniFocus');
+  app.includeStandardAdditions = true;
+  try {
+    var result = app.evaluateJavascript(snippet);
+    // result is already a JSON string produced by the snippet
+    $.NSFileHandle.fileHandleWithStandardOutput.writeData(
+      $.NSString.alloc.initWithString(result + '\\n')
+        .dataUsingEncoding($.NSUTF8StringEncoding)
+    );
+  } catch(e) {
+    var errName = e.name || 'Error';
+    var errMsg = e.message || String(e);
+    // OmniJS wraps thrown errors; the original name is embedded in the message
+    // as "SomeName: original message". Recover it when the name is generic.
+    var nameMatch = errMsg.match(/^([A-Z]\\w*Error): ([\\s\\S]*)$/);
+    if (nameMatch) { errName = nameMatch[1]; errMsg = nameMatch[2]; }
+    var err = JSON.stringify({
+      ok: false,
+      error: {
+        name: errName,
+        message: errMsg
+      }
+    });
+    $.NSFileHandle.fileHandleWithStandardOutput.writeData(
+      $.NSString.alloc.initWithString(err + '\\n')
+        .dataUsingEncoding($.NSUTF8StringEncoding)
+    );
+  }
+})();
+`;
+
+/**
+ * Build the complete JXA script to pass to osascript.
+ * The snippet is embedded as a JS string literal via JSON.stringify,
+ * so it is safe to contain any characters including quotes, backslashes, etc.
+ */
+export function buildJxaScript(snippet: string): string {
+  return JXA_SHIM_TEMPLATE.replace("__SNIPPET__", JSON.stringify(snippet));
+}

package/src/runtime/resultProtocol.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+const ErrorDetail = z.object({
+  name: z.string(),
+  message: z.string(),
+  stack: z.string().optional(),
+});
+
+const SuccessEnvelope = z.object({
+  ok: z.literal(true),
+  data: z.unknown(),
+});
+
+const ErrorEnvelope = z.object({
+  ok: z.literal(false),
+  error: ErrorDetail,
+});
+
+const Envelope = z.discriminatedUnion("ok", [SuccessEnvelope, ErrorEnvelope]);
+
+export type ResultEnvelope = z.infer<typeof Envelope>;
+
+export class ExecutionError extends Error {
+  readonly errorName: string;
+  readonly remoteStack?: string;
+
+  constructor(detail: z.infer<typeof ErrorDetail>) {
+    super(detail.message);
+    this.name = "ExecutionError";
+    this.errorName = detail.name;
+    this.remoteStack = detail.stack;
+  }
+}
+
+/**
+ * Scans stdout for the first JSON-parseable line and validates it as a result
+ * envelope. Ignores any preceding non-JSON chatter (e.g. osascript warnings).
+ */
+export function parseResultLine(stdout: string): ResultEnvelope {
+  const lines = stdout.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue; // not JSON, skip
+    }
+    const result = Envelope.safeParse(parsed);
+    if (result.success) {
+      return result.data;
+    }
+    // Parsed as JSON but not a valid envelope — this is a protocol error
+    throw new Error(
+      `Bridge returned JSON that is not a valid result envelope: ${trimmed}`
+    );
+  }
+  throw new Error(
+    `No valid JSON result envelope found in osascript output:\n${stdout}`
+  );
+}

package/src/runtime/snippetLoader.ts

@@ -0,0 +1,79 @@
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SNIPPETS_DIR = join(__dirname, "..", "snippets");
+
+// Allowlist of valid snippet names. Adding a new snippet requires an explicit
+// entry here, which prevents path-traversal attacks if a snippet name ever
+// reaches this loader from a dynamic source.
+const ALLOWED_SNIPPETS = new Set([
+  "get_folder",
+  "get_project",
+  "get_tag",
+  "get_task",
+  "list_folders",
+  "list_projects",
+  "list_tags",
+  "list_tasks",
+  "resolve_name",
+  "create_task",
+  "edit_task",
+  "complete_task",
+  "drop_task",
+  "delete_task",
+  "create_project",
+  "edit_project",
+  "complete_project",
+  "drop_project",
+  "delete_project",
+  "create_folder",
+  "edit_folder",
+  "delete_folder",
+  "create_tag",
+  "edit_tag",
+  "delete_tag",
+  "move_task",
+  "move_project",
+]);
+
+const cache = new Map<string, string>();
+
+export function loadSnippet(name: string): string {
+  if (!ALLOWED_SNIPPETS.has(name)) {
+    throw new Error(`Unknown snippet: "${name}"`);
+  }
+
+  if (cache.has(name)) {
+    return cache.get(name)!;
+  }
+
+  const filePath = join(SNIPPETS_DIR, `${name}.js`);
+  let content: string;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    throw new Error(`Snippet "${name}" could not be loaded`);
+  }
+
+  const matches = content.split("__ARGS__").length - 1;
+  if (matches === 0) {
+    throw new Error(
+      `Snippet "${name}" contains no __ARGS__ placeholder. Every snippet must have exactly one.`
+    );
+  }
+  if (matches > 1) {
+    throw new Error(
+      `Snippet "${name}" contains ${matches} __ARGS__ placeholders. Exactly one is required.`
+    );
+  }
+
+  cache.set(name, content);
+  return content;
+}
+
+/** For testing: clear the in-memory cache. */
+export function clearSnippetCache(): void {
+  cache.clear();
+}

package/src/schemas/enums.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+export const IdSchema = z.string().min(1, "ID must be a non-empty string");
+
+export const EntityType = z.enum([
+  "task",
+  "project",
+  "folder",
+  "tag",
+  "perspective",
+]);
+
+export const ProjectType = z.enum(["parallel", "sequential", "singleActions"]);
+
+export const ProjectStatus = z.enum(["active", "onHold", "done", "dropped"]);
+
+export const TaskStatus = z.enum([
+  "available",
+  "incomplete",
+  "completedByChildren",
+  "complete",
+  "dropped",
+  "dueSoon",
+  "overdue",
+  "flagged",
+  "blocked",
+  "next",
+]);
+
+export const TagStatus = z.enum(["active", "onHold", "dropped"]);
+
+export const FolderStatus = z.enum(["active", "dropped"]);

package/src/schemas/index.ts

@@ -0,0 +1,38 @@
+export {
+  IdSchema,
+  EntityType,
+  ProjectType,
+  ProjectStatus,
+  TaskStatus,
+  TagStatus,
+  FolderStatus,
+} from "./enums.js";
+
+export {
+  RepetitionRuleInput,
+  RepetitionRuleDetail,
+  TaskSummary,
+  ListTasksFilter,
+  TaskDetail,
+  CreateTaskInput,
+  EditTaskInput,
+  MoveTaskInput,
+  ReviewIntervalInput,
+  CreateProjectInput,
+  EditProjectInput,
+  MoveProjectInput,
+  ListProjectsFilter,
+  ProjectSummary,
+  ProjectDetail,
+  ListFoldersFilter,
+  CreateFolderInput,
+  EditFolderInput,
+  FolderSummary,
+  FolderDetail,
+  ListTagsFilter,
+  CreateTagInput,
+  EditTagInput,
+  TagSummary,
+  TagDetail,
+  ResolveCandidate,
+} from "./shapes.js";