@scardis/omnifocus-mcp 0.1.0

package/src/snippets/list_tasks.js

@@ -0,0 +1,127 @@
+/**
+ * list_tasks.js — List tasks within a specified scope with optional filtering
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with one of:
+ *     { scope: { projectId: "your-project-id" } }
+ *     { scope: { folderId: "your-folder-id" } }
+ *     { scope: { inbox: true } }
+ *     { scope: { all: true } }
+ *     { scope: { all: true }, filter: { flagged: true } }
+ *     { scope: { all: true }, filter: { status: ["overdue", "dueSoon"] } }
+ *     { scope: { all: true }, filter: { dueBeforeDate: "2026-04-09T23:59:59Z" } }
+ *   Example: const args = { scope: { inbox: true } };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function taskStatusString(task) {
+    try {
+      var 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 containerInfo(task) {
+    if (!task.assignedContainer) return { containerId: null, containerType: null };
+    var c = task.assignedContainer;
+    if (c instanceof Project) {
+      return { containerId: c.id.primaryKey, containerType: "project" };
+    }
+    return { containerId: c.id.primaryKey, containerType: "task" };
+  }
+
+  function mapTask(task, overrideContainerType) {
+    var ci = containerInfo(task);
+    return {
+      id: task.id.primaryKey,
+      name: task.name,
+      status: taskStatusString(task),
+      flagged: task.flagged || false,
+      containerId: ci.containerId,
+      containerType: overrideContainerType || ci.containerType,
+      dueDate: task.dueDate ? task.dueDate.toISOString() : null,
+      tagIds: (task.tags || []).map(function(t) { return t.id.primaryKey; }),
+    };
+  }
+
+  // ── Scope resolution ────────────────────────────────────────────────────────
+
+  var scope = args.scope;
+  var tasks = [];
+
+  if (scope.projectId) {
+    var project = flattenedProjects.find(function(p) {
+      return p.id.primaryKey === scope.projectId;
+    });
+    if (!project) {
+      return JSON.stringify({ ok: false, error: { name: "NotFoundError", message: "Project not found: " + scope.projectId } });
+    }
+    tasks = project.flattenedTasks.map(function(t) { return mapTask(t, "project"); });
+  } else if (scope.folderId) {
+    var folder = flattenedFolders.find(function(f) {
+      return f.id.primaryKey === scope.folderId;
+    });
+    if (!folder) {
+      return JSON.stringify({ ok: false, error: { name: "NotFoundError", message: "Folder not found: " + scope.folderId } });
+    }
+    folder.flattenedProjects.forEach(function(p) {
+      p.flattenedTasks.forEach(function(t) { tasks.push(mapTask(t, "project")); });
+    });
+  } else if (scope.inbox) {
+    tasks = flattenedTasks
+      .filter(function(t) { return !t.containingProject && !t.parentTask; })
+      .map(function(t) { return mapTask(t, "inbox"); });
+  } else if (scope.all) {
+    tasks = flattenedTasks.map(function(t) { return mapTask(t, null); });
+  }
+
+  // ── Filtering ───────────────────────────────────────────────────────────────
+
+  var filter = args.filter || {};
+  var hasStatusFilter = Array.isArray(filter.status) && filter.status.length > 0;
+
+  // Default: exclude complete and dropped when no explicit status filter
+  if (!hasStatusFilter) {
+    tasks = tasks.filter(function(t) {
+      return t.status !== "complete" && t.status !== "dropped";
+    });
+  } else {
+    tasks = tasks.filter(function(t) {
+      return filter.status.indexOf(t.status) !== -1;
+    });
+  }
+
+  if (filter.flagged === true) {
+    tasks = tasks.filter(function(t) { return t.flagged === true; });
+  }
+
+  if (filter.tagId) {
+    tasks = tasks.filter(function(t) {
+      return t.tagIds.indexOf(filter.tagId) !== -1;
+    });
+  }
+
+  if (filter.dueBeforeDate) {
+    var cutoff = new Date(filter.dueBeforeDate);
+    tasks = tasks.filter(function(t) {
+      return t.dueDate !== null && new Date(t.dueDate) <= cutoff;
+    });
+  }
+
+  // ── Limit ───────────────────────────────────────────────────────────────────
+
+  var limit = (args.limit !== undefined && args.limit !== null) ? args.limit : 200;
+  if (tasks.length > limit) {
+    tasks = tasks.slice(0, limit);
+  }
+
+  return JSON.stringify({ ok: true, data: tasks });
+})();

package/src/snippets/move_project.js

@@ -0,0 +1,79 @@
+/**
+ * move_project.js — Move a project to a different folder or to the top level
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with one of:
+ *     { id: "project-id", folderId: "folder-id" }
+ *     { id: "project-id", folderId: null }
+ *   Example: const args = { id: "jMBMptE7rJ1", folderId: null };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+
+  function projectStatusString(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 projectType(project) {
+    if (project.containsSingletonActions) return "singleActions";
+    if (project.sequential) return "sequential";
+    return "parallel";
+  }
+
+  function folderPath(project) {
+    var parts = [];
+    var container = project.parentFolder;
+    while (container) {
+      parts.unshift(container.name);
+      container = container.parent;
+    }
+    return parts.join(" \u25b8 ");
+  }
+
+  // ── Resolve project ────────────────────────────────────────────────────────
+
+  var project = flattenedProjects.find(function(p) {
+    return p.id.primaryKey === args.id;
+  });
+  if (!project) throw new NotFoundError("Project not found: " + args.id);
+
+  // ── Move ───────────────────────────────────────────────────────────────────
+
+  if (args.folderId !== null && args.folderId !== undefined) {
+    var folder = flattenedFolders.find(function(f) {
+      return f.id.primaryKey === args.folderId;
+    });
+    if (!folder) throw new NotFoundError("Folder not found: " + args.folderId);
+    moveSections([project], folder);
+  } else {
+    // moveSections requires a non-null position. To reach the root level, anchor
+    // to the first root-level folder's .before location (a root-level insertion point).
+    var rootFolder = flattenedFolders.find(function(f) { return !f.parent; });
+    if (!rootFolder) {
+      throw new Error("Cannot move project to top level: no root-level folders found to anchor position");
+    }
+    moveSections([project], rootFolder.before);
+  }
+
+  // ── Return updated summary ─────────────────────────────────────────────────
+
+  return JSON.stringify({
+    ok: true,
+    data: {
+      id: project.id.primaryKey,
+      name: project.name,
+      folderPath: folderPath(project),
+      folderId: project.parentFolder ? project.parentFolder.id.primaryKey : null,
+      status: projectStatusString(project),
+      type: projectType(project),
+      flagged: project.flagged || false,
+    },
+  });
+})();

package/src/snippets/move_task.js

@@ -0,0 +1,113 @@
+/**
+ * move_task.js — Move a task to a different project or make it a subtask
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with one of:
+ *     { id: "task-id", projectId: "project-id" }
+ *     { id: "task-id", parentTaskId: "parent-task-id" }
+ *   Example: const args = { id: "jMBMptE7rJ1", projectId: "kABCdef123" };
+ */
+(() => {
+  const args = __ARGS__;
+
+  function NotFoundError(msg) { var e = new Error(msg); e.name = "NotFoundError"; return e; }
+  function ValidationError(msg) { var e = new Error(msg); e.name = "ValidationError"; return e; }
+
+  function taskStatusString(task) {
+    try {
+      var 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 containerInfo(task) {
+    // Use parentTask and containingProject rather than assignedContainer —
+    // assignedContainer reflects original placement and doesn't update after moveTasks.
+    if (task.parentTask) {
+      return { containerId: task.parentTask.id.primaryKey, containerType: "task" };
+    }
+    var proj = task.containingProject;
+    if (proj) {
+      return { containerId: proj.id.primaryKey, containerType: "project" };
+    }
+    return { containerId: null, containerType: "inbox" };
+  }
+
+  // ── Validate: exactly one destination ──────────────────────────────────────
+
+  var hasProject = args.projectId !== undefined && args.projectId !== null;
+  var hasParent = args.parentTaskId !== undefined && args.parentTaskId !== null;
+
+  if (hasProject && hasParent) {
+    throw new ValidationError("Exactly one of projectId or parentTaskId must be provided, not both");
+  }
+  if (!hasProject && !hasParent) {
+    throw new ValidationError("Exactly one of projectId or parentTaskId must be provided");
+  }
+
+  // ── Resolve task ───────────────────────────────────────────────────────────
+
+  var task = flattenedTasks.find(function(t) {
+    return t.id.primaryKey === args.id;
+  });
+  if (!task) throw new NotFoundError("Task not found: " + args.id);
+
+  // ── Move ───────────────────────────────────────────────────────────────────
+
+  if (hasProject) {
+    var project = flattenedProjects.find(function(p) {
+      return p.id.primaryKey === args.projectId;
+    });
+    if (!project) throw new NotFoundError("Project not found: " + args.projectId);
+    moveTasks([task], project);
+  } else {
+    var parentTask = flattenedTasks.find(function(t) {
+      return t.id.primaryKey === args.parentTaskId;
+    });
+    if (!parentTask) throw new NotFoundError("Parent task not found: " + args.parentTaskId);
+    moveTasks([task], parentTask.ending);
+  }
+
+  // ── Return updated summary ─────────────────────────────────────────────────
+
+  // Re-fetch after move.
+  var movedTask = flattenedTasks.find(function(t) { return t.id.primaryKey === args.id; }) || task;
+
+  // task.parentTask is unreliable after moveTasks (can return project root task).
+  // For the subtask case, verify from the parent side via flattenedTasks.
+  var ci;
+  if (hasParent) {
+    var parentTask2 = flattenedTasks.find(function(t) { return t.id.primaryKey === args.parentTaskId; });
+    var isSubtask = parentTask2 && (parentTask2.flattenedTasks || []).some(function(t) {
+      return t.id.primaryKey === args.id;
+    });
+    if (isSubtask) {
+      ci = { containerId: parentTask2.id.primaryKey, containerType: "task" };
+    } else {
+      ci = containerInfo(movedTask);
+    }
+  } else {
+    ci = containerInfo(movedTask);
+  }
+
+  return JSON.stringify({
+    ok: true,
+    data: {
+      id: movedTask.id.primaryKey,
+      name: movedTask.name,
+      status: taskStatusString(movedTask),
+      flagged: movedTask.flagged || false,
+      containerId: ci.containerId,
+      containerType: ci.containerType,
+      dueDate: movedTask.dueDate ? movedTask.dueDate.toISOString() : null,
+      tagIds: (movedTask.tags || []).map(function(t) { return t.id.primaryKey; }),
+    },
+  });
+})();

package/src/snippets/resolve_name.js

@@ -0,0 +1,83 @@
+/**
+ * resolve_name.js — Resolve entity name to ID candidates
+ *
+ * PASTE-TO-CONSOLE:
+ *   Replace ARGS_PLACEHOLDER with: { type: "project", query: "My Project", scope: null }
+ *   Example: const args = { type: "folder", query: "Work", scope: null };
+ *
+ * Returns ALL matches (never silently picks one).
+ * Returns empty array on no match (does not throw).
+ */
+(() => {
+  const args = __ARGS__;
+
+  function buildPath(entity) {
+    const parts = [];
+    let current = entity;
+    while (current) {
+      parts.unshift(current.name);
+      current = current.parent;
+    }
+    return parts.join(" \u25b8 ");
+  }
+
+  // Projects use parentFolder (not .parent, which is the Task parent)
+  function buildProjectPath(project) {
+    const parts = [project.name];
+    let folder = project.parentFolder;
+    while (folder) {
+      parts.unshift(folder.name);
+      folder = folder.parent;
+    }
+    return parts.join(" \u25b8 ");
+  }
+
+  function inScope(path, scope) {
+    if (!scope) return true;
+    return path.startsWith(scope + " \u25b8 ") || path === scope;
+  }
+
+  function matchName(entity, query) {
+    return entity.name === query;
+  }
+
+  const type = args.type;
+  const query = args.query;
+  const scope = args.scope || null;
+
+  var candidates = [];
+
+  if (type === "project") {
+    flattenedProjects.forEach(function(p) {
+      if (!matchName(p, query)) return;
+      const path = buildProjectPath(p);
+      if (!inScope(path, scope)) return;
+      candidates.push({ id: p.id.primaryKey, name: p.name, path: path, type: "project" });
+    });
+  } else if (type === "folder") {
+    flattenedFolders.forEach(function(f) {
+      if (!matchName(f, query)) return;
+      const path = buildPath(f);
+      if (!inScope(path, scope)) return;
+      candidates.push({ id: f.id.primaryKey, name: f.name, path: path, type: "folder" });
+    });
+  } else if (type === "task") {
+    flattenedTasks.forEach(function(t) {
+      if (!matchName(t, query)) return;
+      // Build path as "Project ▸ Task" for disambiguation; fall back to task name for inbox tasks
+      var taskPath = t.containingProject
+        ? t.containingProject.name + " \u25b8 " + t.name
+        : t.name;
+      candidates.push({ id: t.id.primaryKey, name: t.name, path: taskPath, type: "task" });
+    });
+  } else if (type === "tag") {
+    flattenedTags.forEach(function(t) {
+      if (!matchName(t, query)) return;
+      const path = buildPath(t);
+      if (!inScope(path, scope)) return;
+      candidates.push({ id: t.id.primaryKey, name: t.name, path: path, type: "tag" });
+    });
+  }
+
+  return JSON.stringify({ ok: true, data: candidates });
+})();

package/src/tools/completeProject.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, ProjectDetail } from "../schemas/index.js";
+
+const CompleteProjectInput = z.object({
+  id: IdSchema.describe("The project's id.primaryKey"),
+});
+
+export async function completeProjectHandler(
+  input: z.infer<typeof CompleteProjectInput>
+): Promise<z.infer<typeof ProjectDetail>> {
+  const raw = await runSnippet("complete_project", { id: input.id });
+  return ProjectDetail.parse(raw);
+}
+
+export const completeProjectTool = {
+  name: "complete_project",
+  description: "Mark a project as done (complete). Returns the updated project detail.",
+  inputSchema: CompleteProjectInput,
+  handler: completeProjectHandler,
+} as const;

package/src/tools/completeTask.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, TaskDetail } from "../schemas/index.js";
+
+const completeTaskSchema = z.object({
+  id: IdSchema.describe("The task's id.primaryKey"),
+});
+
+export type CompleteTaskInput = z.infer<typeof completeTaskSchema>;
+
+export async function completeTaskHandler(
+  input: CompleteTaskInput
+): Promise<z.infer<typeof TaskDetail>> {
+  const raw = await runSnippet("complete_task", { id: input.id });
+  return TaskDetail.parse(raw);
+}
+
+export const completeTaskTool = {
+  name: "complete_task",
+  description: "Mark a task complete by its stable ID. Returns the updated task detail.",
+  inputSchema: completeTaskSchema,
+  handler: completeTaskHandler,
+} as const;

package/src/tools/createFolder.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { CreateFolderInput, FolderDetail } from "../schemas/index.js";
+
+export type CreateFolderInputType = z.infer<typeof CreateFolderInput>;
+
+export async function createFolderHandler(
+  input: CreateFolderInputType
+): Promise<z.infer<typeof FolderDetail>> {
+  const raw = await runSnippet("create_folder", input);
+  return FolderDetail.parse(raw);
+}
+
+export const createFolderTool = {
+  name: "create_folder",
+  description:
+    "Create a new OmniFocus folder. Omit parentFolderId to create at the top level; provide parentFolderId to nest it inside an existing folder.",
+  inputSchema: CreateFolderInput,
+  handler: createFolderHandler,
+} as const;

package/src/tools/createProject.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { CreateProjectInput, ProjectDetail } from "../schemas/index.js";
+
+export type CreateProjectInputType = z.infer<typeof CreateProjectInput>;
+
+export async function createProjectHandler(
+  input: CreateProjectInputType
+): Promise<z.infer<typeof ProjectDetail>> {
+  const raw = await runSnippet("create_project", input);
+  return ProjectDetail.parse(raw);
+}
+
+export const createProjectTool = {
+  name: "create_project",
+  description:
+    "Create a new OmniFocus project. Omit folderId to create at the top level; provide folderId to place it inside a folder. Optionally set type (parallel/sequential/singleActions), status (active/onHold), review interval, and tags.",
+  inputSchema: CreateProjectInput,
+  handler: createProjectHandler,
+} as const;

package/src/tools/createTag.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { CreateTagInput, TagDetail } from "../schemas/index.js";
+
+export type CreateTagInputType = z.infer<typeof CreateTagInput>;
+
+export async function createTagHandler(
+  input: CreateTagInputType
+): Promise<z.infer<typeof TagDetail>> {
+  const raw = await runSnippet("create_tag", input);
+  return TagDetail.parse(raw);
+}
+
+export const createTagTool = {
+  name: "create_tag",
+  description:
+    "Create a new OmniFocus tag. Omit parentTagId to create at the top level; provide parentTagId to nest it under an existing tag.",
+  inputSchema: CreateTagInput,
+  handler: createTagHandler,
+} as const;

package/src/tools/createTask.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { CreateTaskInput, TaskDetail } from "../schemas/index.js";
+
+export type CreateTaskInputType = z.infer<typeof CreateTaskInput>;
+
+export async function createTaskHandler(
+  input: CreateTaskInputType
+): Promise<z.infer<typeof TaskDetail>> {
+  const raw = await runSnippet("create_task", input);
+  return TaskDetail.parse(raw);
+}
+
+export const createTaskTool = {
+  name: "create_task",
+  description:
+    "Create a new task. Placement: omit projectId and parentTaskId for inbox; provide projectId to add to a project; provide parentTaskId to create a subtask. Providing both projectId and parentTaskId is an error.",
+  inputSchema: CreateTaskInput,
+  handler: createTaskHandler,
+} as const;

package/src/tools/deleteFolder.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema } from "../schemas/index.js";
+
+const DeleteFolderInput = z.object({
+  id: IdSchema.describe("The folder's id.primaryKey"),
+});
+
+const DeleteFolderResult = z.object({ id: z.string() });
+
+export async function deleteFolderHandler(
+  input: z.infer<typeof DeleteFolderInput>
+): Promise<z.infer<typeof DeleteFolderResult>> {
+  const raw = await runSnippet("delete_folder", { id: input.id });
+  return DeleteFolderResult.parse(raw);
+}
+
+export const deleteFolderTool = {
+  name: "delete_folder",
+  description:
+    "Permanently and recursively delete an OmniFocus folder. THIS ACTION CANNOT BE UNDONE. The ENTIRE subtree is destroyed: all child folders, all projects within those folders, and all tasks within those projects. Before calling this tool you MUST ask the user to explicitly confirm they want to permanently delete the folder and all of its contents.",
+  inputSchema: DeleteFolderInput,
+  handler: deleteFolderHandler,
+} as const;

package/src/tools/deleteProject.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema } from "../schemas/index.js";
+
+const DeleteProjectInput = z.object({
+  id: IdSchema.describe("The project's id.primaryKey"),
+});
+
+const DeleteProjectResult = z.object({ id: z.string() });
+
+export async function deleteProjectHandler(
+  input: z.infer<typeof DeleteProjectInput>
+): Promise<z.infer<typeof DeleteProjectResult>> {
+  const raw = await runSnippet("delete_project", { id: input.id });
+  return DeleteProjectResult.parse(raw);
+}
+
+export const deleteProjectTool = {
+  name: "delete_project",
+  description:
+    "Permanently delete a project and ALL its tasks. THIS ACTION CANNOT BE UNDONE. Before calling this tool you MUST ask the user to explicitly confirm they want to permanently delete the project, and inform them that all tasks within the project will also be deleted.",
+  inputSchema: DeleteProjectInput,
+  handler: deleteProjectHandler,
+} as const;

package/src/tools/deleteTag.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema } from "../schemas/index.js";
+
+const DeleteTagInput = z.object({
+  id: IdSchema.describe("The tag's id.primaryKey"),
+});
+
+const DeleteTagResult = z.object({ id: z.string() });
+
+export async function deleteTagHandler(
+  input: z.infer<typeof DeleteTagInput>
+): Promise<z.infer<typeof DeleteTagResult>> {
+  const raw = await runSnippet("delete_tag", { id: input.id });
+  return DeleteTagResult.parse(raw);
+}
+
+export const deleteTagTool = {
+  name: "delete_tag",
+  description:
+    "Permanently delete an OmniFocus tag. THIS ACTION CANNOT BE UNDONE. All child tags are also deleted, and all tasks/projects that held this tag have it removed automatically. Before calling this tool you MUST ask the user to explicitly confirm they want to permanently delete the tag and all its child tags.",
+  inputSchema: DeleteTagInput,
+  handler: deleteTagHandler,
+} as const;

package/src/tools/deleteTask.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema } from "../schemas/index.js";
+
+const deleteTaskSchema = z.object({
+  id: IdSchema.describe("The task's id.primaryKey"),
+});
+
+export type DeleteTaskInput = z.infer<typeof deleteTaskSchema>;
+
+const DeleteTaskResult = z.object({ id: IdSchema });
+
+export async function deleteTaskHandler(
+  input: DeleteTaskInput
+): Promise<z.infer<typeof DeleteTaskResult>> {
+  const raw = await runSnippet("delete_task", { id: input.id });
+  return DeleteTaskResult.parse(raw);
+}
+
+export const deleteTaskTool = {
+  name: "delete_task",
+  description:
+    "Permanently delete a task and all its subtasks. THIS ACTION CANNOT BE UNDONE. Before calling this tool you MUST ask the user to explicitly confirm they want to permanently delete the task, and inform them that all subtasks will also be deleted.",
+  inputSchema: deleteTaskSchema,
+  handler: deleteTaskHandler,
+} as const;

package/src/tools/dropProject.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { runSnippet } from "../runtime/index.js";
+import { IdSchema, ProjectDetail } from "../schemas/index.js";
+
+const DropProjectInput = z.object({
+  id: IdSchema.describe("The project's id.primaryKey"),
+});
+
+export async function dropProjectHandler(
+  input: z.infer<typeof DropProjectInput>
+): Promise<z.infer<typeof ProjectDetail>> {
+  const raw = await runSnippet("drop_project", { id: input.id });
+  return ProjectDetail.parse(raw);
+}
+
+export const dropProjectTool = {
+  name: "drop_project",
+  description: "Mark a project as dropped. Returns the updated project detail.",
+  inputSchema: DropProjectInput,
+  handler: dropProjectHandler,
+} as const;