@scardis/omnifocus-mcp 0.1.0

package/src/snippets/create_task.js

@@ -0,0 +1,159 @@
+/**
+ * create_task.js — Create a new task in OmniFocus
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with one of:
+ *     { name: "Buy milk" }
+ *     { name: "Write tests", projectId: "abc123" }
+ *     { name: "Stand-up", repetitionRule: { frequency: "daily", interval: 1, method: "fixed" } }
+ *   Example: const args = { name: "Buy milk" };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+  function ConflictError(msg) { var e = new Error(msg); e.name = "ConflictError"; return e; }
+
+  function isoOrNull(d) { return d ? d.toISOString() : null; }
+
+  function taskStatus(task) {
+    try {
+      const s = task.taskStatus;
+      if (s === Task.Status.Available) return "available";
+      if (s === Task.Status.Blocked) return "blocked";
+      if (s === Task.Status.Completed) return "complete";
+      if (s === Task.Status.Dropped) return "dropped";
+      if (s === Task.Status.DueSoon) return "dueSoon";
+      if (s === Task.Status.Next) return "next";
+      if (s === Task.Status.Overdue) return "overdue";
+      return "incomplete";
+    } catch(_) { return "incomplete"; }
+  }
+
+  var DAY_ABBR = {
+    sunday: "SU", monday: "MO", tuesday: "TU", wednesday: "WE",
+    thursday: "TH", friday: "FR", saturday: "SA"
+  };
+
+  var FREQ_MAP = { daily: "DAILY", weekly: "WEEKLY", monthly: "MONTHLY", yearly: "YEARLY" };
+
+  function buildRrule(rule) {
+    var rrule = "FREQ=" + FREQ_MAP[rule.frequency] + ";INTERVAL=" + (rule.interval || 1);
+    if (rule.daysOfWeek && rule.daysOfWeek.length > 0) {
+      rrule += ";BYDAY=" + rule.daysOfWeek.map(function(d) { return DAY_ABBR[d]; }).join(",");
+    }
+    return rrule;
+  }
+
+  function buildMethod(methodStr) {
+    var m = Task.RepetitionMethod;
+    if (methodStr === "dueDate") return m.DueDate;
+    if (methodStr === "start") return m.DeferUntilDate;
+    return m.Fixed;
+  }
+
+  function parseMethod(method) {
+    var s = String(method);
+    if (s.indexOf("DueDate") >= 0) return "dueDate";
+    if (s.indexOf("DeferUntilDate") >= 0) return "start";
+    return "fixed";
+  }
+
+  function parseRepetitionRule(rule) {
+    if (!rule) return null;
+    try {
+      var ruleStr = rule.ruleString || "";
+      var parts = {};
+      ruleStr.split(";").forEach(function(part) {
+        var kv = part.split("=");
+        if (kv.length === 2) parts[kv[0]] = kv[1];
+      });
+      var freqMap = { DAILY: "daily", WEEKLY: "weekly", MONTHLY: "monthly", YEARLY: "yearly" };
+      var frequency = freqMap[parts["FREQ"]] || "daily";
+      var interval = parts["INTERVAL"] ? parseInt(parts["INTERVAL"], 10) : 1;
+      var ABBR_DAY = { SU: "sunday", MO: "monday", TU: "tuesday", WE: "wednesday", TH: "thursday", FR: "friday", SA: "saturday" };
+      var daysOfWeek = parts["BYDAY"] ? parts["BYDAY"].split(",").map(function(a) { return ABBR_DAY[a]; }).filter(Boolean) : undefined;
+      var result = { frequency: frequency, interval: interval, method: parseMethod(rule.method) };
+      if (daysOfWeek && daysOfWeek.length > 0) result.daysOfWeek = daysOfWeek;
+      return result;
+    } catch(_) { return null; }
+  }
+
+  function taskDetail(task) {
+    var containerId = null;
+    var containerType = null;
+    var parentTaskId = null;
+    if (task.parentTask) {
+      containerId = task.parentTask.id.primaryKey;
+      containerType = "task";
+      parentTaskId = task.parentTask.id.primaryKey;
+    } else if (args.parentTaskId) {
+      // task.parentTask may be null immediately after creation; fall back to args
+      containerId = args.parentTaskId;
+      containerType = "task";
+      parentTaskId = args.parentTaskId;
+    } else if (task.containingProject) {
+      containerId = task.containingProject.id.primaryKey;
+      containerType = "project";
+    } else if (!args.projectId && !args.parentTaskId) {
+      containerType = "inbox";
+    }
+    return {
+      id: task.id.primaryKey,
+      name: task.name,
+      note: task.note || "",
+      status: taskStatus(task),
+      flagged: task.flagged || false,
+      deferDate: isoOrNull(task.deferDate),
+      plannedDate: isoOrNull(task.plannedDate),
+      dueDate: isoOrNull(task.dueDate),
+      completionDate: isoOrNull(task.completionDate),
+      estimatedMinutes: task.estimatedMinutes || null,
+      containerId: containerId,
+      containerType: containerType,
+      tagIds: (task.tags || []).map(function(t) { return t.id.primaryKey; }),
+      parentTaskId: parentTaskId,
+      repetitionRule: parseRepetitionRule(task.repetitionRule),
+    };
+  }
+
+  if (args.projectId && args.parentTaskId) {
+    throw new ConflictError("Provide projectId or parentTaskId, not both");
+  }
+
+  var position;
+  if (args.projectId) {
+    var project = flattenedProjects.find(function(p) { return p.id.primaryKey === args.projectId; });
+    if (!project) throw new NotFoundError("Project not found: " + args.projectId);
+    position = project;
+  } else if (args.parentTaskId) {
+    var parentTask = flattenedTasks.find(function(t) { return t.id.primaryKey === args.parentTaskId; });
+    if (!parentTask) throw new NotFoundError("Parent task not found: " + args.parentTaskId);
+    position = parentTask;
+  } else {
+    position = inbox.beginning;
+  }
+
+  var task = new Task(args.name, position);
+
+  if (args.note !== undefined) task.note = args.note;
+  if (args.flagged !== undefined) task.flagged = args.flagged;
+  if (args.deferDate !== undefined && args.deferDate !== null) task.deferDate = new Date(args.deferDate);
+  if (args.plannedDate !== undefined && args.plannedDate !== null) task.plannedDate = new Date(args.plannedDate);
+  if (args.dueDate !== undefined && args.dueDate !== null) task.dueDate = new Date(args.dueDate);
+  if (args.estimatedMinutes !== undefined && args.estimatedMinutes !== null) task.estimatedMinutes = args.estimatedMinutes;
+
+  if (args.tagIds && args.tagIds.length > 0) {
+    args.tagIds.forEach(function(tagId) {
+      var tag = flattenedTags.find(function(t) { return t.id.primaryKey === tagId; });
+      if (!tag) throw new NotFoundError("Tag not found: " + tagId);
+      task.addTag(tag);
+    });
+  }
+
+  if (args.repetitionRule) {
+    task.repetitionRule = new Task.RepetitionRule(buildRrule(args.repetitionRule), buildMethod(args.repetitionRule.method));
+  }
+
+  return JSON.stringify({ ok: true, data: taskDetail(task) });
+})();

package/src/snippets/delete_folder.js

@@ -0,0 +1,26 @@
+/**
+ * delete_folder.js — Recursively delete a folder and all its contents by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-folder-id" }
+ *   WARNING: Permanently deletes all child folders, projects, and tasks.
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  function deleteFolder(f) {
+    f.flattenedProjects.forEach(function(p) { deleteObject(p); });
+    f.folders.forEach(function(child) { deleteFolder(child); });
+    deleteObject(f);
+  }
+
+  var folder = flattenedFolders.find(function(f) { return f.id.primaryKey === args.id; });
+  if (!folder) throw new NotFoundError("Folder not found: " + args.id);
+
+  var id = folder.id.primaryKey;
+  deleteFolder(folder);
+
+  return JSON.stringify({ ok: true, data: { id: id } });
+})();

package/src/snippets/delete_project.js

@@ -0,0 +1,20 @@
+/**
+ * delete_project.js — Permanently delete a project and all its tasks by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-project-id" }
+ *   Example: const args = { id: "jMBMptE7rJ1" };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  var project = flattenedProjects.find(function(p) { return p.id.primaryKey === args.id; });
+  if (!project) throw new NotFoundError("Project not found: " + args.id);
+
+  var id = project.id.primaryKey;
+  deleteObject(project);
+
+  return JSON.stringify({ ok: true, data: { id: id } });
+})();

package/src/snippets/delete_tag.js

@@ -0,0 +1,20 @@
+/**
+ * delete_tag.js — Delete a tag by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-tag-id" }
+ *   WARNING: Child tags are also permanently deleted.
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  var tag = flattenedTags.find(function(t) { return t.id.primaryKey === args.id; });
+  if (!tag) throw new NotFoundError("Tag not found: " + args.id);
+
+  var id = tag.id.primaryKey;
+  deleteObject(tag);
+
+  return JSON.stringify({ ok: true, data: { id: id } });
+})();

package/src/snippets/delete_task.js

@@ -0,0 +1,20 @@
+/**
+ * delete_task.js — Permanently delete a task and all its subtasks by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-task-id" }
+ *   Example: const args = { id: "jMBMptE7rJ1" };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  var task = flattenedTasks.find(function(t) { return t.id.primaryKey === args.id; });
+  if (!task) throw new NotFoundError("Task not found: " + args.id);
+
+  var id = task.id.primaryKey;
+  deleteObject(task);
+
+  return JSON.stringify({ ok: true, data: { id: id } });
+})();

package/src/snippets/drop_project.js

@@ -0,0 +1,73 @@
+/**
+ * drop_project.js — Mark a project dropped by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-project-id" }
+ *   Example: const args = { id: "jMBMptE7rJ1" };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  function isoOrNull(d) { return d ? d.toISOString() : null; }
+
+  function folderPath(project) {
+    var parts = [];
+    var container = project.parentFolder;
+    while (container) {
+      parts.unshift(container.name);
+      container = container.parent;
+    }
+    return parts.join(" \u25b8 ");
+  }
+
+  function projectType(project) {
+    if (project.containsSingletonActions) return "singleActions";
+    if (project.sequential) return "sequential";
+    return "parallel";
+  }
+
+  function projectStatus(project) {
+    var s = project.status;
+    if (s === Project.Status.Active) return "active";
+    if (s === Project.Status.OnHold) return "onHold";
+    if (s === Project.Status.Done) return "done";
+    if (s === Project.Status.Dropped) return "dropped";
+    return "active";
+  }
+
+  function reviewIntervalString(p) {
+    try {
+      var ri = p.reviewInterval;
+      if (!ri) return null;
+      return ri.steps + ' ' + ri.unit;
+    } catch(_) { return null; }
+  }
+
+  function projectDetail(project) {
+    return {
+      id: project.id.primaryKey,
+      name: project.name,
+      note: project.note || "",
+      folderPath: folderPath(project),
+      status: projectStatus(project),
+      type: projectType(project),
+      flagged: project.flagged || false,
+      deferDate: isoOrNull(project.deferDate),
+      dueDate: isoOrNull(project.dueDate),
+      completionDate: isoOrNull(project.completionDate),
+      reviewInterval: reviewIntervalString(project),
+      nextReviewDate: isoOrNull(project.nextReviewDate),
+      lastReviewDate: isoOrNull(project.lastReviewDate),
+      tagIds: (project.tags || []).map(function(t) { return t.id.primaryKey; }),
+    };
+  }
+
+  var project = flattenedProjects.find(function(p) { return p.id.primaryKey === args.id; });
+  if (!project) throw new NotFoundError("Project not found: " + args.id);
+
+  project.status = Project.Status.Dropped;
+
+  return JSON.stringify({ ok: true, data: projectDetail(project) });
+})();

package/src/snippets/drop_task.js

@@ -0,0 +1,85 @@
+/**
+ * drop_task.js — Mark a task dropped by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-task-id" }
+ *   Example: const args = { id: "jMBMptE7rJ1" };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  function isoOrNull(d) { return d ? d.toISOString() : null; }
+
+  function taskStatus(task) {
+    try {
+      const s = task.taskStatus;
+      if (s === Task.Status.Available) return "available";
+      if (s === Task.Status.Blocked) return "blocked";
+      if (s === Task.Status.Completed) return "complete";
+      if (s === Task.Status.Dropped) return "dropped";
+      if (s === Task.Status.DueSoon) return "dueSoon";
+      if (s === Task.Status.Next) return "next";
+      if (s === Task.Status.Overdue) return "overdue";
+      return "incomplete";
+    } catch(_) { return "incomplete"; }
+  }
+
+  function parseRepetitionRule(rule) {
+    if (!rule) return null;
+    try {
+      var parts = {};
+      (rule.ruleString || "").split(";").forEach(function(part) {
+        var kv = part.split("=");
+        if (kv.length === 2) parts[kv[0]] = kv[1];
+      });
+      var freqMap = { DAILY: "daily", WEEKLY: "weekly", MONTHLY: "monthly", YEARLY: "yearly" };
+      var frequency = freqMap[parts["FREQ"]] || "daily";
+      var interval = parts["INTERVAL"] ? parseInt(parts["INTERVAL"], 10) : 1;
+      var ABBR_DAY = { SU: "sunday", MO: "monday", TU: "tuesday", WE: "wednesday", TH: "thursday", FR: "friday", SA: "saturday" };
+      var daysOfWeek = parts["BYDAY"] ? parts["BYDAY"].split(",").map(function(a) { return ABBR_DAY[a]; }).filter(Boolean) : undefined;
+      var ms = String(rule.method);
+      var method = ms.indexOf("DueDate") >= 0 ? "dueDate" : ms.indexOf("DeferUntilDate") >= 0 ? "start" : "fixed";
+      var result = { frequency: frequency, interval: interval, method: method };
+      if (daysOfWeek && daysOfWeek.length > 0) result.daysOfWeek = daysOfWeek;
+      return result;
+    } catch(_) { return null; }
+  }
+
+  function taskDetail(task) {
+    var containerId = null;
+    var containerType = null;
+    if (task.parentTask) {
+      containerId = task.parentTask.id.primaryKey;
+      containerType = "task";
+    } else if (task.containingProject) {
+      containerId = task.containingProject.id.primaryKey;
+      containerType = "project";
+    }
+    return {
+      id: task.id.primaryKey,
+      name: task.name,
+      note: task.note || "",
+      status: taskStatus(task),
+      flagged: task.flagged || false,
+      deferDate: isoOrNull(task.deferDate),
+      plannedDate: isoOrNull(task.plannedDate),
+      dueDate: isoOrNull(task.dueDate),
+      completionDate: isoOrNull(task.completionDate),
+      estimatedMinutes: task.estimatedMinutes || null,
+      containerId: containerId,
+      containerType: containerType,
+      tagIds: (task.tags || []).map(function(t) { return t.id.primaryKey; }),
+      parentTaskId: task.parentTask ? task.parentTask.id.primaryKey : null,
+      repetitionRule: parseRepetitionRule(task.repetitionRule),
+    };
+  }
+
+  var task = flattenedTasks.find(function(t) { return t.id.primaryKey === args.id; });
+  if (!task) throw new NotFoundError("Task not found: " + args.id);
+
+  task.drop(false);
+
+  return JSON.stringify({ ok: true, data: taskDetail(task) });
+})();

package/src/snippets/edit_folder.js

@@ -0,0 +1,46 @@
+/**
+ * edit_folder.js — Rename an existing folder by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-folder-id", name: "New Name" }
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  function buildPath(folder) {
+    var parts = [];
+    var current = folder;
+    while (current) {
+      parts.unshift(current.name);
+      current = current.parent;
+    }
+    return parts.join(" \u25b8 ");
+  }
+
+  function folderStatus(folder) {
+    try {
+      return folder.active === false ? "dropped" : "active";
+    } catch(_) { return "active"; }
+  }
+
+  function folderDetail(folder) {
+    return {
+      id: folder.id.primaryKey,
+      name: folder.name,
+      path: buildPath(folder),
+      parentId: folder.parent ? folder.parent.id.primaryKey : null,
+      status: folderStatus(folder),
+      childFolderIds: (folder.folders || []).map(function(f) { return f.id.primaryKey; }),
+      projectIds: (folder.projects || []).map(function(p) { return p.id.primaryKey; }),
+    };
+  }
+
+  var folder = flattenedFolders.find(function(f) { return f.id.primaryKey === args.id; });
+  if (!folder) throw new NotFoundError("Folder not found: " + args.id);
+
+  folder.name = args.name;
+
+  return JSON.stringify({ ok: true, data: folderDetail(folder) });
+})();

package/src/snippets/edit_project.js

@@ -0,0 +1,106 @@
+/**
+ * edit_project.js — Edit an existing project by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-project-id", status: "onHold" }
+ *   Example: const args = { id: "jMBMptE7rJ1", name: "Updated name", flagged: true };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  function isoOrNull(d) { return d ? d.toISOString() : null; }
+
+  function folderPath(project) {
+    var parts = [];
+    var container = project.parentFolder;
+    while (container) {
+      parts.unshift(container.name);
+      container = container.parent;
+    }
+    return parts.join(" \u25b8 ");
+  }
+
+  function projectType(project) {
+    if (project.containsSingletonActions) return "singleActions";
+    if (project.sequential) return "sequential";
+    return "parallel";
+  }
+
+  function projectStatus(project) {
+    var s = project.status;
+    if (s === Project.Status.Active) return "active";
+    if (s === Project.Status.OnHold) return "onHold";
+    if (s === Project.Status.Done) return "done";
+    if (s === Project.Status.Dropped) return "dropped";
+    return "active";
+  }
+
+  function reviewIntervalString(p) {
+    try {
+      var ri = p.reviewInterval;
+      if (!ri) return null;
+      return ri.steps + ' ' + ri.unit;
+    } catch(_) { return null; }
+  }
+
+  function projectDetail(project) {
+    return {
+      id: project.id.primaryKey,
+      name: project.name,
+      note: project.note || "",
+      folderPath: folderPath(project),
+      status: projectStatus(project),
+      type: projectType(project),
+      flagged: project.flagged || false,
+      deferDate: isoOrNull(project.deferDate),
+      dueDate: isoOrNull(project.dueDate),
+      completionDate: isoOrNull(project.completionDate),
+      reviewInterval: reviewIntervalString(project),
+      nextReviewDate: isoOrNull(project.nextReviewDate),
+      lastReviewDate: isoOrNull(project.lastReviewDate),
+      tagIds: (project.tags || []).map(function(t) { return t.id.primaryKey; }),
+    };
+  }
+
+  var project = flattenedProjects.find(function(p) { return p.id.primaryKey === args.id; });
+  if (!project) throw new NotFoundError("Project not found: " + args.id);
+
+  if (args.name !== undefined) project.name = args.name;
+  if (args.note !== undefined) project.note = args.note;
+  if (args.flagged !== undefined) project.flagged = args.flagged;
+
+  if ("deferDate" in args) {
+    project.deferDate = args.deferDate ? new Date(args.deferDate) : null;
+  }
+  if ("dueDate" in args) {
+    project.dueDate = args.dueDate ? new Date(args.dueDate) : null;
+  }
+
+  if (args.type !== undefined) {
+    project.sequential = args.type === "sequential";
+    project.containsSingletonActions = args.type === "singleActions";
+  }
+
+  if (args.status !== undefined) {
+    project.status = args.status === "onHold" ? Project.Status.OnHold : Project.Status.Active;
+  }
+
+  if (args.reviewInterval !== undefined && args.reviewInterval !== null) {
+    // Project.ReviewInterval is not constructible via evaluateJavascript;
+    // mutate the existing reviewInterval object in-place instead.
+    project.reviewInterval.steps = args.reviewInterval.steps;
+  }
+
+  if (args.tagIds !== undefined) {
+    (project.tags || []).slice().forEach(function(t) { project.removeTag(t); });
+    args.tagIds.forEach(function(tagId) {
+      var tag = flattenedTags.find(function(t) { return t.id.primaryKey === tagId; });
+      if (!tag) throw new NotFoundError("Tag not found: " + tagId);
+      project.addTag(tag);
+    });
+  }
+
+  return JSON.stringify({ ok: true, data: projectDetail(project) });
+})();

package/src/snippets/edit_tag.js

@@ -0,0 +1,56 @@
+/**
+ * edit_tag.js — Edit an existing tag by ID
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { id: "your-tag-id", name: "New Name" }
+ *   Or: { id: "your-tag-id", status: "onHold" }
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  function buildPath(tag) {
+    var parts = [];
+    var current = tag;
+    while (current) {
+      parts.unshift(current.name);
+      current = current.parent;
+    }
+    return parts.join(" \u25b8 ");
+  }
+
+  function tagStatus(tag) {
+    try {
+      var s = tag.status;
+      if (s === Tag.Status.Active) return "active";
+      if (s === Tag.Status.OnHold) return "onHold";
+      if (s === Tag.Status.Dropped) return "dropped";
+      return "active";
+    } catch(_) { return "active"; }
+  }
+
+  function tagDetail(tag) {
+    return {
+      id: tag.id.primaryKey,
+      name: tag.name,
+      path: buildPath(tag),
+      parentId: tag.parent ? tag.parent.id.primaryKey : null,
+      status: tagStatus(tag),
+      childTagIds: (tag.children || []).map(function(c) { return c.id.primaryKey; }),
+    };
+  }
+
+  var tag = flattenedTags.find(function(t) { return t.id.primaryKey === args.id; });
+  if (!tag) throw new NotFoundError("Tag not found: " + args.id);
+
+  if (args.name !== undefined) tag.name = args.name;
+
+  if (args.status !== undefined) {
+    if (args.status === "onHold") tag.status = Tag.Status.OnHold;
+    else if (args.status === "dropped") tag.status = Tag.Status.Dropped;
+    else tag.status = Tag.Status.Active;
+  }
+
+  return JSON.stringify({ ok: true, data: tagDetail(tag) });
+})();