@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/mcp-server-6tm7Rhyz.js

@@ -0,0 +1,2840 @@
+import { getTaskUrl as le, getProjectUrl as de, TodoistApi as Ce } from "@doist/todoist-api-typescript";
+import { McpServer as ve } from "@modelcontextprotocol/sdk/server/mcp.js";
+import F, { z as d } from "zod";
+import { addDays as ue, formatISO as Se } from "date-fns";
+function q(e) {
+  if (e == null)
+    return e;
+  if (Array.isArray(e))
+    return e.map((t) => q(t));
+  if (typeof e == "object") {
+    const t = {};
+    for (const [s, o] of Object.entries(e))
+      if (o !== null) {
+        const n = q(o);
+        if (Array.isArray(n) && n.length === 0 || n !== null && typeof n == "object" && !Array.isArray(n) && Object.keys(n).length === 0)
+          continue;
+        t[s] = n;
+      }
+    return t;
+  }
+  return e;
+}
+const De = process.env.USE_STRUCTURED_CONTENT === "true" || process.env.NODE_ENV === "test";
+function T({
+  textContent: e,
+  structuredContent: t
+}) {
+  const s = q(t);
+  if (De)
+    return {
+      content: [{ type: "text", text: e }],
+      structuredContent: s
+    };
+  const o = JSON.stringify(s);
+  return {
+    content: [
+      { type: "text", text: e },
+      { type: "text", mimeType: "application/json", text: o }
+    ]
+  };
+}
+function Z(e) {
+  return {
+    content: [{ type: "text", text: e }],
+    isError: !0
+  };
+}
+function w(e, t, s) {
+  const o = async (n, r) => {
+    try {
+      return await e.execute(n, s);
+    } catch (i) {
+      console.error(`Error executing tool ${e.name}:`, {
+        args: n,
+        error: i
+      });
+      const a = i instanceof Error ? i.message : "An unknown error occurred";
+      return Z(a);
+    }
+  };
+  t.tool(e.name, e.description, e.parameters, o);
+}
+const I = {
+  // Task management tools
+  ADD_TASKS: "add-tasks",
+  COMPLETE_TASKS: "complete-tasks",
+  UPDATE_TASKS: "update-tasks",
+  FIND_TASKS: "find-tasks",
+  FIND_TASKS_BY_DATE: "find-tasks-by-date",
+  FIND_COMPLETED_TASKS: "find-completed-tasks",
+  // Project management tools
+  ADD_PROJECTS: "add-projects",
+  UPDATE_PROJECTS: "update-projects",
+  FIND_PROJECTS: "find-projects",
+  // Section management tools
+  ADD_SECTIONS: "add-sections",
+  UPDATE_SECTIONS: "update-sections",
+  FIND_SECTIONS: "find-sections",
+  // Comment management tools
+  ADD_COMMENTS: "add-comments",
+  UPDATE_COMMENTS: "update-comments",
+  FIND_COMMENTS: "find-comments",
+  // Assignment and collaboration tools
+  FIND_PROJECT_COLLABORATORS: "find-project-collaborators",
+  MANAGE_ASSIGNMENTS: "manage-assignments",
+  // Activity and audit tools
+  FIND_ACTIVITY: "find-activity",
+  // General tools
+  GET_OVERVIEW: "get-overview",
+  DELETE_OBJECT: "delete-object",
+  USER_INFO: "user-info",
+  // OpenAI MCP tools
+  SEARCH: "search",
+  FETCH: "fetch"
+}, xe = d.object({
+  taskId: d.string().optional().describe("The ID of the task to comment on."),
+  projectId: d.string().optional().describe(
+    'The ID of the project to comment on. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  ),
+  content: d.string().min(1).describe("The content of the comment.")
+}), Ae = {
+  comments: d.array(xe).min(1).describe("The array of comments to add.")
+}, Ue = {
+  name: I.ADD_COMMENTS,
+  description: "Add multiple comments to tasks or projects. Each comment must specify either taskId or projectId.",
+  parameters: Ae,
+  async execute(e, t) {
+    const { comments: s } = e;
+    for (const [c, l] of s.entries()) {
+      if (!l.taskId && !l.projectId)
+        throw new Error(
+          `Comment ${c + 1}: Either taskId or projectId must be provided.`
+        );
+      if (l.taskId && l.projectId)
+        throw new Error(
+          `Comment ${c + 1}: Cannot provide both taskId and projectId. Choose one.`
+        );
+    }
+    const n = s.some((c) => c.projectId === "inbox") ? await t.getUser() : null, r = s.map(async ({ content: c, taskId: l, projectId: u }) => {
+      const p = u === "inbox" && n ? n.inboxProjectId : u;
+      return await t.addComment({
+        content: c,
+        ...l ? { taskId: l } : { projectId: p }
+      });
+    }), i = await Promise.all(r), a = Pe({ comments: i });
+    return T({
+      textContent: a,
+      structuredContent: {
+        comments: i,
+        totalCount: i.length,
+        addedCommentIds: i.map((c) => c.id)
+      }
+    });
+  }
+};
+function Pe({ comments: e }) {
+  const t = e.filter((r) => r.taskId).length, s = e.filter((r) => r.projectId).length, o = [];
+  if (t > 0) {
+    const r = t > 1 ? "comments" : "comment";
+    o.push(`${t} task ${r}`);
+  }
+  if (s > 0) {
+    const r = s > 1 ? "comments" : "comment";
+    o.push(`${s} project ${r}`);
+  }
+  return o.length > 0 ? `Added ${o.join(" and ")}` : "No comments added";
+}
+const Ee = d.object({
+  name: d.string().min(1).describe("The name of the project."),
+  parentId: d.string().optional().describe("The ID of the parent project. If provided, creates this as a sub-project."),
+  isFavorite: d.boolean().optional().describe("Whether the project is a favorite. Defaults to false."),
+  viewStyle: d.enum(["list", "board", "calendar"]).optional().describe('The project view style. Defaults to "list".')
+}), Oe = {
+  projects: d.array(Ee).min(1).describe("The array of projects to add.")
+}, _e = {
+  name: I.ADD_PROJECTS,
+  description: "Add one or more new projects.",
+  parameters: Oe,
+  async execute({ projects: e }, t) {
+    const s = await Promise.all(e.map((n) => t.addProject(n))), o = Ne({ projects: s });
+    return T({
+      textContent: o,
+      structuredContent: {
+        projects: s,
+        totalCount: s.length
+      }
+    });
+  }
+};
+function Ne({ projects: e }) {
+  const t = e.length, s = e.map((n) => `• ${n.name} (id=${n.id})`).join(`
+`);
+  return `Added ${t} project${t === 1 ? "" : "s"}:
+${s}`;
+}
+const Me = d.object({
+  name: d.string().min(1).describe("The name of the section."),
+  projectId: d.string().min(1).describe(
+    'The ID of the project to add the section to. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  )
+}), Fe = {
+  sections: d.array(Me).min(1).describe("The array of sections to add.")
+}, Re = {
+  name: I.ADD_SECTIONS,
+  description: "Add one or more new sections to projects.",
+  parameters: Fe,
+  async execute({ sections: e }, t) {
+    const o = e.some((a) => a.projectId === "inbox") ? await t.getUser() : null, n = e.map((a) => ({
+      ...a,
+      projectId: a.projectId === "inbox" && o ? o.inboxProjectId : a.projectId
+    })), r = await Promise.all(
+      n.map((a) => t.addSection(a))
+    ), i = Le({ sections: r });
+    return T({
+      textContent: i,
+      structuredContent: {
+        sections: r,
+        totalCount: r.length
+      }
+    });
+  }
+};
+function Le({ sections: e }) {
+  const t = e.length, s = e.map((n) => `• ${n.name} (id=${n.id}, projectId=${n.projectId})`).join(`
+`);
+  return `Added ${t} section${t === 1 ? "" : "s"}:
+${s}`;
+}
+class P extends Error {
+  constructor(t, s) {
+    super(`Invalid duration format "${t}": ${s}`), this.name = "DurationParseError";
+  }
+}
+function pe(e) {
+  if (!e || typeof e != "string")
+    throw new P(e, "Duration must be a non-empty string");
+  const t = e.trim().toLowerCase().replace(/\s+/g, "");
+  if (!t)
+    throw new P(e, "Duration must be a non-empty string");
+  const s = t.match(/^(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?$/);
+  if (!s || !s[1] && !s[2])
+    throw new P(e, 'Use format like "2h", "30m", "2h30m", or "1.5h"');
+  let o = 0;
+  const [, n, r] = s;
+  if (n) {
+    const i = Number.parseFloat(n);
+    if (Number.isNaN(i) || i < 0)
+      throw new P(e, "Hours must be a positive number");
+    o += i * 60;
+  }
+  if (r) {
+    const i = Number.parseFloat(r);
+    if (Number.isNaN(i) || i < 0)
+      throw new P(e, "Minutes must be a positive number");
+    if (i % 1 !== 0)
+      throw new P(
+        e,
+        "Minutes must be a whole number (use decimal hours instead)"
+      );
+    o += i;
+  }
+  if (o = Math.round(o), o === 0)
+    throw new P(e, "Duration must be greater than 0 minutes");
+  if (o > 1440)
+    throw new P(e, "Duration cannot exceed 24 hours (1440 minutes)");
+  return { minutes: o };
+}
+function Be(e) {
+  if (e <= 0) return "0m";
+  const t = Math.floor(e / 60), s = e % 60;
+  return t === 0 ? `${s}m` : s === 0 ? `${t}h` : `${t}h${s}m`;
+}
+const U = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map(), W = 300 * 1e3;
+class Ke {
+  /**
+   * Resolve a user name or ID to a user ID by looking up collaborators across all shared projects.
+   * Supports exact name matches, partial matches, and email matches.
+   */
+  async resolveUser(t, s) {
+    if (!s || s.trim().length === 0)
+      return null;
+    const o = s.trim(), n = U.get(o);
+    if (n && Date.now() - n.timestamp < W)
+      return n.result;
+    if (/^[0-9]+$/.test(o) || /^[a-f0-9-]{8,}$/i.test(o) && o.includes("-") || /^[a-z0-9_]{6,}$/i.test(o) && !/^[a-z]+[\s-]/.test(o) && /[0-9_]/.test(o)) {
+      const r = { userId: o, displayName: o, email: o };
+      return U.set(o, { result: r, timestamp: Date.now() }), r;
+    }
+    try {
+      const r = await this.getAllCollaborators(t);
+      if (r.length === 0)
+        return U.set(o, { result: null, timestamp: Date.now() }), null;
+      const i = s.toLowerCase().trim();
+      let a = r.find((l) => l.name.toLowerCase() === i);
+      if (a) {
+        const l = { userId: a.id, displayName: a.name, email: a.email };
+        return U.set(o, { result: l, timestamp: Date.now() }), l;
+      }
+      if (a = r.find((l) => l.email.toLowerCase() === i), a) {
+        const l = { userId: a.id, displayName: a.name, email: a.email };
+        return U.set(o, { result: l, timestamp: Date.now() }), l;
+      }
+      if (a = r.find((l) => l.name.toLowerCase().includes(i)), a) {
+        const l = { userId: a.id, displayName: a.name, email: a.email };
+        return U.set(o, { result: l, timestamp: Date.now() }), l;
+      }
+      if (a = r.find((l) => l.email.toLowerCase().includes(i)), a) {
+        const l = { userId: a.id, displayName: a.name, email: a.email };
+        return U.set(o, { result: l, timestamp: Date.now() }), l;
+      }
+      const c = null;
+      return U.set(o, { result: c, timestamp: Date.now() }), c;
+    } catch {
+      return U.set(o, { result: null, timestamp: Date.now() }), null;
+    }
+  }
+  /**
+   * Validate that a user is a collaborator on a specific project
+   */
+  async validateProjectCollaborator(t, s, o) {
+    try {
+      return (await this.getProjectCollaborators(t, s)).some((r) => r.id === o);
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Get collaborators for a specific project
+   */
+  async getProjectCollaborators(t, s) {
+    const o = `project_${s}`, n = R.get(o);
+    if (n && Date.now() - n.timestamp < W)
+      return n.result;
+    try {
+      const r = await t.getProjectCollaborators(s), a = (Array.isArray(r) ? r : r.results || []).filter((c) => c?.id && c.name && c.email);
+      return R.set(o, {
+        result: a,
+        timestamp: Date.now()
+      }), a;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get all collaborators from all shared projects
+   */
+  async getAllCollaborators(t) {
+    const s = "all_collaborators", o = R.get(s);
+    if (o && Date.now() - o.timestamp < W)
+      return o.result;
+    try {
+      const { results: n } = await t.getProjects({}), r = n.filter((u) => u.isShared);
+      if (r.length === 0) {
+        const u = [];
+        return R.set(s, { result: u, timestamp: Date.now() }), u;
+      }
+      const i = [], a = /* @__PURE__ */ new Set(), c = r.map(
+        (u) => this.getProjectCollaborators(t, u.id)
+      ), l = await Promise.allSettled(c);
+      for (const u of l)
+        if (u.status === "fulfilled")
+          for (const p of u.value)
+            p && !a.has(p.id) && (i.push(p), a.add(p.id));
+      return R.set(s, {
+        result: i,
+        timestamp: Date.now()
+      }), i;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Clear all caches - useful for testing
+   */
+  clearCache() {
+    U.clear(), R.clear();
+  }
+}
+const _ = new Ke();
+async function Ye(e, t) {
+  return _.resolveUser(e, t);
+}
+const me = ["assigned", "unassignedOrMe", "all"];
+async function Q(e, t) {
+  if (!t)
+    return;
+  const s = await Ye(e, t);
+  if (!s)
+    throw new Error(
+      `Could not find user: "${t}". Make sure the user is a collaborator on a shared project.`
+    );
+  return { userId: s.userId, email: s.email };
+}
+function V(e, t) {
+  return t.length === 0 ? e : e.length === 0 ? t : `${e} & ${t}`;
+}
+function Ve({
+  resolvedAssigneeId: e,
+  assigneeEmail: t,
+  responsibleUserFiltering: s = "unassignedOrMe"
+}) {
+  return e && t ? `assigned to: ${t}` : s === "unassignedOrMe" ? "!assigned to: others" : s === "assigned" ? "assigned to: others" : "";
+}
+function ne({
+  tasks: e,
+  resolvedAssigneeId: t,
+  currentUserId: s,
+  responsibleUserFiltering: o = "unassignedOrMe"
+}) {
+  return t ? e.filter((n) => n.responsibleUid === t) : o === "unassignedOrMe" ? e.filter((n) => !n.responsibleUid || n.responsibleUid === s) : e;
+}
+function B(e) {
+  return "inboxProject" in e;
+}
+function ze(e, t, s, o) {
+  const n = [t, s, o].filter(Boolean);
+  if (n.length > 1)
+    throw new Error(
+      `Task ${e}: Only one of projectId, sectionId, or parentId can be specified at a time. The Todoist API requires exactly one destination for move operations.`
+    );
+  if (n.length === 0)
+    throw new Error(
+      `Task ${e}: At least one of projectId, sectionId, or parentId must be provided for move operations.`
+    );
+  if (t) return { projectId: t };
+  if (s) return { sectionId: s };
+  if (o) return { parentId: o };
+  throw new Error("Unexpected error: No valid move parameter found");
+}
+function O(e) {
+  return {
+    id: e.id,
+    content: e.content,
+    description: e.description,
+    dueDate: e.due?.date,
+    recurring: e.due?.isRecurring && e.due.string ? e.due.string : !1,
+    deadlineDate: e.deadline?.date,
+    priority: e.priority,
+    projectId: e.projectId,
+    sectionId: e.sectionId,
+    parentId: e.parentId,
+    labels: e.labels,
+    duration: e.duration ? Be(e.duration.amount) : null,
+    responsibleUid: e.responsibleUid,
+    assignedByUid: e.assignedByUid,
+    checked: e.checked,
+    completedAt: e.completedAt
+  };
+}
+function he(e) {
+  return {
+    id: e.id,
+    name: e.name,
+    color: e.color,
+    isFavorite: e.isFavorite,
+    isShared: e.isShared,
+    parentId: B(e) ? e.parentId ?? null : null,
+    inboxProject: B(e) ? e.inboxProject ?? !1 : !1,
+    viewStyle: e.viewStyle
+  };
+}
+function He(e) {
+  return {
+    id: e.id,
+    objectType: e.objectType,
+    objectId: e.objectId,
+    eventType: e.eventType,
+    eventDate: e.eventDate,
+    parentProjectId: e.parentProjectId,
+    parentItemId: e.parentItemId,
+    initiatorId: e.initiatorId,
+    extraData: e.extraData
+  };
+}
+const We = F.object({
+  httpStatusCode: F.number(),
+  responseData: F.object({
+    error: F.string(),
+    errorCode: F.number(),
+    errorTag: F.string()
+  })
+});
+async function ee({
+  client: e,
+  query: t,
+  limit: s,
+  cursor: o
+}) {
+  try {
+    const { results: n, nextCursor: r } = await e.getTasksByFilter({ query: t, cursor: o, limit: s });
+    return { tasks: n.map(O), nextCursor: r };
+  } catch (n) {
+    const r = We.safeParse(n);
+    if (!r.success)
+      throw n;
+    const { responseData: i } = r.data;
+    throw i.errorTag === "INVALID_SEARCH_QUERY" ? new Error(`Invalid filter query: ${t}`) : new Error(
+      `${i.error} (tag: ${i.errorTag}, code: ${i.errorCode})`
+    );
+  }
+}
+const L = {
+  USER_NOT_FOUND: "USER_NOT_FOUND",
+  USER_NOT_COLLABORATOR: "USER_NOT_COLLABORATOR",
+  PROJECT_NOT_SHARED: "PROJECT_NOT_SHARED",
+  TASK_NOT_ACCESSIBLE: "TASK_NOT_ACCESSIBLE",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND",
+  TASK_NOT_FOUND: "TASK_NOT_FOUND"
+};
+class Ge {
+  /**
+   * Validate a single assignment operation
+   */
+  async validateAssignment(t, s) {
+    const { taskId: o, projectId: n, responsibleUid: r } = s, i = await _.resolveUser(t, r);
+    if (!i)
+      return {
+        isValid: !1,
+        taskId: o,
+        projectId: n,
+        error: {
+          type: L.USER_NOT_FOUND,
+          message: `User "${r}" not found`,
+          suggestions: [
+            "Check the spelling of the user name or email",
+            "Ensure the user is a collaborator on at least one shared project",
+            "Try using the user's full email address"
+          ]
+        }
+      };
+    try {
+      const a = await t.getProject(n);
+      if (!a.isShared)
+        return {
+          isValid: !1,
+          taskId: o,
+          projectId: n,
+          resolvedUser: i,
+          error: {
+            type: L.PROJECT_NOT_SHARED,
+            message: `Project "${a.name}" is not shared`,
+            suggestions: [
+              "Share the project with collaborators before assigning tasks",
+              "Only shared projects support task assignments"
+            ]
+          }
+        };
+      if (!await _.validateProjectCollaborator(
+        t,
+        n,
+        i.userId
+      ))
+        return {
+          isValid: !1,
+          taskId: o,
+          projectId: n,
+          resolvedUser: i,
+          error: {
+            type: L.USER_NOT_COLLABORATOR,
+            message: `User "${i.displayName}" is not a collaborator on project "${a.name}"`,
+            suggestions: [
+              "Invite the user to collaborate on this project first",
+              "Check if the user has been removed from the project",
+              "Verify you have permission to see project collaborators"
+            ]
+          }
+        };
+      if (o)
+        try {
+          await t.getTask(o);
+        } catch {
+          return {
+            isValid: !1,
+            taskId: o,
+            projectId: n,
+            resolvedUser: i,
+            error: {
+              type: L.TASK_NOT_FOUND,
+              message: `Task "${o}" not found or not accessible`,
+              suggestions: [
+                "Verify the task ID is correct",
+                "Check if the task has been deleted",
+                "Ensure you have access to the task"
+              ]
+            }
+          };
+        }
+      return {
+        isValid: !0,
+        taskId: o,
+        projectId: n,
+        resolvedUser: i
+      };
+    } catch {
+      return {
+        isValid: !1,
+        taskId: o,
+        projectId: n,
+        resolvedUser: i,
+        error: {
+          type: L.PERMISSION_DENIED,
+          message: "Permission denied or API error occurred",
+          suggestions: [
+            "Check your API permissions",
+            "Verify you have access to the project",
+            "Try again later if this is a temporary API issue"
+          ]
+        }
+      };
+    }
+  }
+  /**
+   * Validate multiple assignment operations in bulk
+   */
+  async validateBulkAssignment(t, s) {
+    const o = s.map(
+      (n) => this.validateAssignment(t, n)
+    );
+    return Promise.all(o);
+  }
+  /**
+   * Validate assignment for task creation (no taskId required)
+   */
+  async validateTaskCreationAssignment(t, s, o) {
+    return this.validateAssignment(t, {
+      projectId: s,
+      responsibleUid: o
+    });
+  }
+  /**
+   * Validate assignment for task update
+   */
+  async validateTaskUpdateAssignment(t, s, o) {
+    if (o === null)
+      return {
+        isValid: !0,
+        taskId: s
+      };
+    try {
+      const n = await t.getTask(s);
+      return this.validateAssignment(t, {
+        taskId: s,
+        projectId: n.projectId,
+        responsibleUid: o
+      });
+    } catch {
+      return {
+        isValid: !1,
+        taskId: s,
+        error: {
+          type: L.TASK_NOT_FOUND,
+          message: `Task "${s}" not found or not accessible`,
+          suggestions: [
+            "Verify the task ID is correct",
+            "Check if the task has been deleted",
+            "Ensure you have access to the task"
+          ]
+        }
+      };
+    }
+  }
+  /**
+   * Get detailed assignment eligibility information for troubleshooting
+   */
+  async getAssignmentEligibility(t, s, o, n) {
+    const r = [];
+    let i = !1, a;
+    try {
+      a = await t.getProject(s);
+    } catch {
+      return {
+        canAssign: !1,
+        projectInfo: {
+          name: "Unknown",
+          isShared: !1,
+          collaboratorCount: 0
+        },
+        recommendations: ["Project not found or not accessible"]
+      };
+    }
+    const c = await _.getProjectCollaborators(t, s), l = {
+      name: a.name,
+      isShared: a.isShared,
+      collaboratorCount: c.length
+    };
+    if (!a.isShared)
+      return r.push("Share this project to enable task assignments"), { canAssign: !1, projectInfo: l, recommendations: r };
+    const u = await _.resolveUser(t, o);
+    if (!u)
+      return r.push("User not found - check spelling or invite to a shared project"), { canAssign: !1, projectInfo: l, recommendations: r };
+    const p = c.some((k) => k.id === u.userId), g = {
+      resolvedName: u.displayName,
+      isCollaborator: p
+    };
+    if (!p)
+      return r.push(
+        `Invite ${u.displayName} to collaborate on project "${a.name}"`
+      ), { canAssign: !1, projectInfo: l, userInfo: g, recommendations: r };
+    let h;
+    if (n && n.length > 0) {
+      let k = 0, j = 0;
+      for (const C of n)
+        try {
+          await t.getTask(C), k++;
+        } catch {
+          j++;
+        }
+      h = { accessibleTasks: k, inaccessibleTasks: j }, j > 0 && r.push(`${j} task(s) are not accessible`);
+    }
+    return i = !0, r.push(`Ready to assign tasks to ${u.displayName}`), {
+      canAssign: i,
+      projectInfo: l,
+      userInfo: g,
+      taskInfo: h,
+      recommendations: r
+    };
+  }
+}
+const te = new Ge(), Je = ["p1", "p2", "p3", "p4"], fe = d.enum(Je, {
+  description: "Task priority: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default)"
+});
+function ge(e) {
+  return { p1: 4, p2: 3, p3: 2, p4: 1 }[e];
+}
+function qe(e) {
+  return { 4: "P1", 3: "P2", 2: "P3", 1: "P4" }[e] || "";
+}
+const S = {
+  /** Default limit for task listings */
+  TASKS_DEFAULT: 10,
+  /** Maximum limit for task search and list operations */
+  TASKS_MAX: 100,
+  /** Default limit for completed tasks */
+  COMPLETED_TASKS_DEFAULT: 50,
+  /** Maximum limit for completed tasks */
+  COMPLETED_TASKS_MAX: 200,
+  /** Default limit for project listings */
+  PROJECTS_DEFAULT: 50,
+  /** Maximum limit for project listings */
+  PROJECTS_MAX: 100,
+  /** Batch size for fetching all tasks in a project */
+  TASKS_BATCH_SIZE: 50,
+  /** Default limit for comment listings */
+  COMMENTS_DEFAULT: 10,
+  /** Maximum limit for comment search and list operations */
+  COMMENTS_MAX: 10,
+  /** Default limit for activity log listings */
+  ACTIVITY_DEFAULT: 20,
+  /** Maximum limit for activity log search and list operations */
+  ACTIVITY_MAX: 100
+}, G = {
+  /** Maximum number of failures to show in detailed error messages */
+  MAX_FAILURES_SHOWN: 3
+};
+function Xe(e = /* @__PURE__ */ new Date()) {
+  return e.toISOString().split("T")[0] ?? "";
+}
+function be(e, t, s = {}) {
+  const { context: o, showDetails: n = !1 } = s, r = t.length, i = [], c = `${e} ${r} ${r === 1 ? "task" : "tasks"}${o ? ` ${o}` : ""}.`;
+  i.push(c);
+  const l = 5;
+  if (n || r <= l) {
+    const u = z(t, l);
+    if (u.length > 0) {
+      const p = r > l ? `, +${r - l} more` : "";
+      i.push(`Tasks:
+${u}${p}.`);
+    }
+  }
+  return i.join(`
+`);
+}
+function Ze(e) {
+  const { action: t, success: s, total: o, successItems: n, failures: r } = e, i = [], a = `${t}: ${s}/${o} successful.`;
+  if (i.push(a), n?.length && n.length <= 5 && i.push(`Completed:
+${n.map((c) => `    ${c}`).join(`
+`)}.`), r?.length) {
+    const c = r.length, l = `Failed (${c}):
+${r.slice(0, G.MAX_FAILURES_SHOWN).map((u) => `    ${u.item} (Error: ${u.error}${u.code ? ` [${u.code}]` : ""})`).join(
+      `
+`
+    )}${c > G.MAX_FAILURES_SHOWN ? `, +${c - G.MAX_FAILURES_SHOWN} more` : ""}.`;
+    i.push(l);
+  }
+  return i.join(`
+`);
+}
+function Qe(e) {
+  const t = e.content || e.title || "Untitled", s = e.dueDate ? ` • due ${e.dueDate}` : "", o = e.priority ? ` • ${qe(e.priority)}` : "", n = e.projectName ? ` • ${e.projectName}` : "", r = e.id ? ` • id=${e.id}` : "";
+  return `    ${t}${s}${o}${n}${r}`;
+}
+function et(e) {
+  const t = e.inboxProject ? " • Inbox" : "", s = e.isFavorite ? " • ⭐" : "", o = e.isShared ? " • Shared" : "", n = e.viewStyle && e.viewStyle !== "list" ? ` • ${e.viewStyle}` : "", r = ` • id=${e.id}`;
+  return `    ${e.name}${t}${s}${o}${n}${r}`;
+}
+function z(e, t = 5) {
+  const o = e.slice(0, t).map(Qe).join(`
+`);
+  if (e.length > t) {
+    const n = e.length - t;
+    return `${o}
+    ... and ${n} more task${n === 1 ? "" : "s"}`;
+  }
+  return o;
+}
+function N({
+  subject: e,
+  count: t,
+  limit: s,
+  nextCursor: o,
+  filterHints: n,
+  previewLines: r,
+  zeroReasonHints: i,
+  nextSteps: a
+}) {
+  const c = [], l = `${e}: ${t}${typeof s == "number" ? ` (limit ${s})` : ""}${o ? ", more available" : ""}.`;
+  return c.push(l), n?.length && c.push(`Filter: ${n.join("; ")}.`), r?.length && c.push(`Preview:
+${r}`), !t && i?.length && c.push(`No results. ${i.join("; ")}.`), (a?.length || o) && c.push(Te(a || [], o)), c.join(`
+`);
+}
+function Te(e, t) {
+  const s = [...e];
+  return t && s.push(`Pass cursor '${t}' to fetch more results.`), `${s.length === 1 ? "Possible suggested next step:" : "Possible suggested next steps:"}
+${s.map((n) => `- ${n}`).join(`
+`)}`;
+}
+const tt = d.object({
+  content: d.string().min(1).describe(
+    'The task name/title. Should be concise and actionable (e.g., "Review PR #123", "Call dentist"). For longer content, use the description field instead. Supports Markdown.'
+  ),
+  description: d.string().optional().describe(
+    "Additional details, notes, or context for the task. Use this for longer content rather than putting it in the task name. Supports Markdown."
+  ),
+  priority: fe.optional().describe(
+    "The priority of the task: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default)."
+  ),
+  dueString: d.string().optional().describe("The due date for the task, in natural language."),
+  deadlineDate: d.string().optional().describe(
+    'The deadline date for the task in ISO 8601 format (YYYY-MM-DD, e.g., "2025-12-31"). Deadlines are immovable constraints shown with a different indicator than due dates.'
+  ),
+  duration: d.string().optional().describe(
+    'The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'
+  ),
+  labels: d.array(d.string()).optional().describe("The labels to attach to the task."),
+  projectId: d.string().optional().describe(
+    'The project ID to add this task to. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  ),
+  sectionId: d.string().optional().describe("The section ID to add this task to."),
+  parentId: d.string().optional().describe("The parent task ID (for subtasks)."),
+  responsibleUser: d.string().optional().describe(
+    "Assign task to this user. Can be a user ID, name, or email address. User must be a collaborator on the target project."
+  )
+}), st = {
+  tasks: d.array(tt).min(1).describe("The array of tasks to add.")
+}, ot = {
+  name: I.ADD_TASKS,
+  description: "Add one or more tasks to a project, section, or parent. Supports assignment to project collaborators.",
+  parameters: st,
+  async execute({ tasks: e }, t) {
+    const s = e.map((i) => nt(i, t)), n = (await Promise.all(s)).map(O), r = rt({
+      tasks: n,
+      args: { tasks: e }
+    });
+    return T({
+      textContent: r,
+      structuredContent: {
+        tasks: n,
+        totalCount: n.length
+      }
+    });
+  }
+};
+async function nt(e, t) {
+  const {
+    duration: s,
+    projectId: o,
+    sectionId: n,
+    parentId: r,
+    responsibleUser: i,
+    priority: a,
+    labels: c,
+    deadlineDate: l,
+    ...u
+  } = e;
+  let p = o;
+  o === "inbox" && (p = (await t.getUser()).inboxProjectId);
+  let g = {
+    ...u,
+    projectId: p,
+    sectionId: n,
+    parentId: r,
+    labels: c,
+    deadlineDate: l
+  };
+  if (a && (g.priority = ge(a)), i && !p && !n && !r)
+    throw new Error(
+      `Task "${e.content}": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or parentId.`
+    );
+  if (s)
+    try {
+      const { minutes: h } = pe(s);
+      g = {
+        ...g,
+        duration: h,
+        durationUnit: "minute"
+      };
+    } catch (h) {
+      throw h instanceof P ? new Error(`Task "${e.content}": ${h.message}`) : h;
+    }
+  if (i) {
+    let h = p;
+    if (!h && r)
+      try {
+        h = (await t.getTask(r)).projectId;
+      } catch {
+        throw new Error(`Task "${e.content}": Parent task "${r}" not found`);
+      }
+    else if (!h && n)
+      throw new Error(
+        `Task "${e.content}": When assigning tasks to sections, please also specify projectId`
+      );
+    if (!h)
+      throw new Error(
+        `Task "${e.content}": Cannot determine target project for assignment validation`
+      );
+    const k = await te.validateTaskCreationAssignment(
+      t,
+      h,
+      i
+    );
+    if (!k.isValid) {
+      const j = k.error?.message || "Assignment validation failed", C = k.error?.suggestions?.join(". ") || "";
+      throw new Error(
+        `Task "${e.content}": ${j}${C ? `. ${C}` : ""}`
+      );
+    }
+    g.assigneeId = k.resolvedUser?.userId;
+  }
+  return await t.addTask(g);
+}
+function rt({
+  tasks: e,
+  args: t
+}) {
+  const s = /* @__PURE__ */ new Set();
+  for (const n of t.tasks)
+    n.projectId ? s.add("projects") : n.sectionId ? s.add("sections") : n.parentId ? s.add("subtasks") : s.add("inbox");
+  let o = "";
+  if (s.size === 1) {
+    const n = Array.from(s)[0];
+    o = n === "inbox" ? "" : `to ${n}`;
+  } else s.size > 1 && (o = "to multiple contexts");
+  return be("Added", e, {
+    context: o,
+    showDetails: !0
+  });
+}
+const it = {
+  ids: d.array(d.string().min(1)).min(1).describe("The IDs of the tasks to complete.")
+}, at = {
+  name: I.COMPLETE_TASKS,
+  description: "Complete one or more tasks by their IDs.",
+  parameters: it,
+  async execute(e, t) {
+    const s = [], o = [];
+    for (const r of e.ids)
+      try {
+        await t.closeTask(r), s.push(r);
+      } catch (i) {
+        const a = i instanceof Error ? i.message : "Unknown error";
+        o.push({
+          item: r,
+          error: a
+        });
+      }
+    const n = ct({
+      completed: s,
+      failures: o,
+      args: e
+    });
+    return T({
+      textContent: n,
+      structuredContent: {
+        completed: s,
+        failures: o,
+        totalRequested: e.ids.length,
+        successCount: s.length,
+        failureCount: o.length
+      }
+    });
+  }
+};
+function ct({
+  completed: e,
+  failures: t,
+  args: s
+}) {
+  return Ze({
+    action: "Completed tasks",
+    success: e.length,
+    total: s.ids.length,
+    successItems: e,
+    failures: t
+  });
+}
+const lt = {
+  type: d.enum(["project", "section", "task", "comment"]).describe("The type of entity to delete."),
+  id: d.string().min(1).describe("The ID of the entity to delete.")
+}, dt = {
+  name: I.DELETE_OBJECT,
+  description: "Delete a project, section, task, or comment by its ID.",
+  parameters: lt,
+  async execute(e, t) {
+    switch (e.type) {
+      case "project":
+        await t.deleteProject(e.id);
+        break;
+      case "section":
+        await t.deleteSection(e.id);
+        break;
+      case "task":
+        await t.deleteTask(e.id);
+        break;
+      case "comment":
+        await t.deleteComment(e.id);
+        break;
+    }
+    const s = ut({
+      type: e.type,
+      id: e.id
+    });
+    return T({
+      textContent: s,
+      structuredContent: {
+        deletedEntity: {
+          type: e.type,
+          id: e.id
+        },
+        success: !0
+      }
+    });
+  }
+};
+function ut({
+  type: e,
+  id: t
+}) {
+  return `Deleted ${e}: id=${t}`;
+}
+const pt = {
+  id: d.string().min(1).describe(
+    'A unique identifier for the document in the format "task:{id}" or "project:{id}".'
+  )
+}, mt = {
+  name: I.FETCH,
+  description: 'Fetch the full contents of a task or project by its ID. The ID should be in the format "task:{id}" or "project:{id}".',
+  parameters: pt,
+  async execute(e, t) {
+    try {
+      const { id: s } = e, [o, n] = s.split(":", 2);
+      if (!n || o !== "task" && o !== "project")
+        throw new Error(
+          'Invalid ID format. Expected "task:{id}" or "project:{id}". Example: "task:8485093748" or "project:6cfCcrrCFg2xP94Q"'
+        );
+      let r;
+      if (o === "task") {
+        const a = await t.getTask(n), c = O(a), l = [c.content];
+        c.description && l.push(`
+
+Description: ${c.description}`), c.dueDate && l.push(`
+Due: ${c.dueDate}`), c.labels.length > 0 && l.push(`
+Labels: ${c.labels.join(", ")}`), r = {
+          id: `task:${c.id}`,
+          title: c.content,
+          text: l.join(""),
+          url: le(c.id),
+          metadata: {
+            priority: c.priority,
+            projectId: c.projectId,
+            sectionId: c.sectionId,
+            parentId: c.parentId,
+            recurring: c.recurring,
+            duration: c.duration,
+            responsibleUid: c.responsibleUid,
+            assignedByUid: c.assignedByUid,
+            checked: c.checked,
+            completedAt: c.completedAt
+          }
+        };
+      } else {
+        const a = await t.getProject(n), c = he(a), l = [c.name];
+        c.isShared && l.push(`
+
+Shared project`), c.isFavorite && l.push(`
+Favorite: Yes`), r = {
+          id: `project:${c.id}`,
+          title: c.name,
+          text: l.join(""),
+          url: de(c.id),
+          metadata: {
+            color: c.color,
+            isFavorite: c.isFavorite,
+            isShared: c.isShared,
+            parentId: c.parentId,
+            inboxProject: c.inboxProject,
+            viewStyle: c.viewStyle
+          }
+        };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(r) }] };
+    } catch (s) {
+      const o = s instanceof Error ? s.message : "An unknown error occurred";
+      return Z(o);
+    }
+  }
+}, ht = {
+  objectType: d.enum(["task", "project", "comment"]).optional().describe("Type of object to filter by."),
+  objectId: d.string().optional().describe("Filter by specific object ID (task, project, or comment)."),
+  eventType: d.enum([
+    "added",
+    "updated",
+    "deleted",
+    "completed",
+    "uncompleted",
+    "archived",
+    "unarchived",
+    "shared",
+    "left"
+  ]).optional().describe("Type of event to filter by."),
+  projectId: d.string().optional().describe("Filter events by parent project ID."),
+  taskId: d.string().optional().describe("Filter events by parent task ID (for subtask events)."),
+  initiatorId: d.string().optional().describe("Filter by the user ID who initiated the event."),
+  limit: d.number().int().min(1).max(S.ACTIVITY_MAX).default(S.ACTIVITY_DEFAULT).describe("Maximum number of activity events to return."),
+  cursor: d.string().optional().describe("Pagination cursor for retrieving the next page of results.")
+}, ft = {
+  name: I.FIND_ACTIVITY,
+  description: "Retrieve recent activity logs to monitor and audit changes in Todoist. Shows events from all users by default (use initiatorId to filter by specific user). Track task completions, updates, deletions, project changes, and more with flexible filtering. Note: Date-based filtering is not supported by the Todoist API.",
+  parameters: ht,
+  async execute(e, t) {
+    const { objectType: s, objectId: o, eventType: n, projectId: r, taskId: i, initiatorId: a, limit: c, cursor: l } = e, u = {
+      limit: c,
+      cursor: l ?? null
+    };
+    s && (u.objectType = s), o && o !== "remove" && (u.objectId = o), n && (u.eventType = n), r && (u.parentProjectId = r), i && (u.parentItemId = i), a && (u.initiatorId = a);
+    const { results: p, nextCursor: g } = await t.getActivityLogs(u), h = p.map(He), k = gt({
+      events: h,
+      args: e,
+      nextCursor: g
+    });
+    return T({
+      textContent: k,
+      structuredContent: {
+        events: h,
+        nextCursor: g,
+        totalCount: h.length,
+        hasMore: !!g,
+        appliedFilters: e
+      }
+    });
+  }
+};
+function gt({
+  events: e,
+  args: t,
+  nextCursor: s
+}) {
+  let o = "Activity events";
+  const n = [];
+  if (t.eventType && n.push(`${t.eventType}`), t.objectType) {
+    const a = t.objectType === "task" ? "tasks" : `${t.objectType}s`;
+    n.push(a);
+  }
+  n.length > 0 && (o = `Activity: ${n.join(" ")}`);
+  const r = [];
+  t.objectId && r.push(`object ID: ${t.objectId}`), t.projectId && r.push(`project: ${t.projectId}`), t.taskId && r.push(`task: ${t.taskId}`), t.initiatorId && r.push(`initiator: ${t.initiatorId}`);
+  const i = [];
+  return e.length === 0 && (i.push("No activity events match the specified filters"), i.push("Note: Activity logs only show recent events"), t.eventType && i.push(`Try removing the eventType filter (${t.eventType})`), t.objectType && i.push(`Try removing the objectType filter (${t.objectType})`), (t.objectId || t.projectId || t.taskId) && i.push("Verify the object ID is correct")), N({
+    subject: o,
+    count: e.length,
+    limit: t.limit,
+    nextCursor: s ?? void 0,
+    filterHints: r,
+    previewLines: bt(e, Math.min(e.length, t.limit)),
+    zeroReasonHints: i
+  });
+}
+function bt(e, t = 10) {
+  const o = e.slice(0, t).map(Tt).join(`
+`);
+  if (e.length > t) {
+    const n = e.length - t;
+    return `${o}
+    ... and ${n} more event${n === 1 ? "" : "s"}`;
+  }
+  return o;
+}
+function Tt(e) {
+  const t = It(e.eventDate), s = `${e.eventType} ${e.objectType}`;
+  let o = "";
+  if (e.extraData) {
+    const a = e.extraData.content || e.extraData.name || e.extraData.last_content;
+    a && typeof a == "string" && (o = ` • "${a.length > 50 ? `${a.substring(0, 47)}...` : a}"`);
+  }
+  const n = e.objectId ? ` • id=${e.objectId}` : "", r = e.initiatorId ? ` • by=${e.initiatorId}` : " • system", i = e.parentProjectId ? ` • project=${e.parentProjectId}` : "";
+  return `    [${t}] ${s}${o}${n}${r}${i}`;
+}
+function It(e) {
+  try {
+    const t = new Date(e), s = t.toLocaleDateString("en-US", { month: "short", timeZone: "UTC" }), o = t.toLocaleDateString("en-US", { day: "numeric", timeZone: "UTC" }), n = t.toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: !1,
+      timeZone: "UTC"
+    });
+    return `${s} ${o}, ${n}`;
+  } catch {
+    return e;
+  }
+}
+const yt = {
+  taskId: d.string().optional().describe("Find comments for a specific task."),
+  projectId: d.string().optional().describe(
+    'Find comments for a specific project. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  ),
+  commentId: d.string().optional().describe("Get a specific comment by ID."),
+  cursor: d.string().optional().describe("Pagination cursor for retrieving more results."),
+  limit: d.number().int().min(1).max(S.COMMENTS_MAX).optional().describe("Maximum number of comments to return")
+}, kt = {
+  name: I.FIND_COMMENTS,
+  description: "Find comments by task, project, or get a specific comment by ID. Exactly one of taskId, projectId, or commentId must be provided.",
+  parameters: yt,
+  async execute(e, t) {
+    const s = [e.taskId, e.projectId, e.commentId].filter(Boolean);
+    if (s.length === 0)
+      throw new Error("Must provide exactly one of: taskId, projectId, or commentId.");
+    if (s.length > 1)
+      throw new Error(
+        "Cannot provide multiple search parameters. Choose one of: taskId, projectId, or commentId."
+      );
+    const o = e.projectId === "inbox" ? (await t.getUser()).inboxProjectId : e.projectId;
+    let n, r = !1, i = null;
+    if (e.commentId)
+      n = [await t.getComment(e.commentId)];
+    else if (e.taskId) {
+      const c = await t.getComments({
+        taskId: e.taskId,
+        cursor: e.cursor || null,
+        limit: e.limit || S.COMMENTS_DEFAULT
+      });
+      n = c.results, r = c.nextCursor !== null, i = c.nextCursor;
+    } else if (o) {
+      const c = await t.getComments({
+        projectId: o,
+        cursor: e.cursor || null,
+        limit: e.limit || S.COMMENTS_DEFAULT
+      });
+      n = c.results, r = c.nextCursor !== null, i = c.nextCursor;
+    } else
+      throw new Error("Invalid state: no search parameter provided");
+    const a = wt({
+      comments: n,
+      searchType: e.commentId ? "single" : e.taskId ? "task" : "project",
+      searchId: e.commentId || e.taskId || e.projectId || "",
+      hasMore: r,
+      nextCursor: i
+    });
+    return T({
+      textContent: a,
+      structuredContent: {
+        comments: n,
+        searchType: e.commentId ? "single" : e.taskId ? "task" : "project",
+        searchId: e.commentId || e.taskId || e.projectId || "",
+        hasMore: r,
+        nextCursor: i,
+        totalCount: n.length
+      }
+    });
+  }
+};
+function wt({
+  comments: e,
+  searchType: t,
+  searchId: s,
+  hasMore: o,
+  nextCursor: n
+}) {
+  if (e.length === 0)
+    return `No comments found for ${t}${t !== "single" ? ` ${s}` : ""}`;
+  let r;
+  if (t === "single") {
+    const i = e[0];
+    if (!i)
+      return "Comment not found";
+    r = `Found comment${i.fileAttachment !== null ? ` • Has attachment: ${i.fileAttachment?.fileName || "file"}` : ""} • id=${i.id}`;
+  } else {
+    const i = e.filter((l) => l.fileAttachment !== null).length, a = i > 0 ? ` (${i} with attachments)` : "", c = e.length === 1 ? "comment" : "comments";
+    r = `Found ${e.length} ${c} for ${t} ${s}${a}`, o && (r += " • More available");
+  }
+  if (n) {
+    const i = Te([], n);
+    return `${r}
+${i}`;
+  }
+  return r;
+}
+const jt = ["and", "or"], se = {
+  labels: d.string().array().optional().describe("The labels to filter the tasks by"),
+  labelsOperator: d.enum(jt).optional().describe(
+    'The operator to use when filtering by labels. This will dictate whether a task has all labels, or some of them. Default is "or".'
+  )
+};
+function oe(e = [], t = "or") {
+  if (e.length === 0) return "";
+  const s = t === "and" ? " & " : " | ";
+  return `(${e.map((r) => r.startsWith("@") ? r : `@${r}`).join(` ${s} `)})`;
+}
+const $t = {
+  getBy: d.enum(["completion", "due"]).default("completion").describe(
+    'The method to use to get the tasks: "completion" to get tasks by completion date (ie, when the task was actually completed), "due" to get tasks by due date (ie, when the task was due to be completed by).'
+  ),
+  since: d.string().date().regex(/^\d{4}-\d{2}-\d{2}$/).describe("The start date to get the tasks for. Format: YYYY-MM-DD."),
+  until: d.string().date().regex(/^\d{4}-\d{2}-\d{2}$/).describe("The start date to get the tasks for. Format: YYYY-MM-DD."),
+  workspaceId: d.string().optional().describe("The ID of the workspace to get the tasks for."),
+  projectId: d.string().optional().describe(
+    'The ID of the project to get the tasks for. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  ),
+  sectionId: d.string().optional().describe("The ID of the section to get the tasks for."),
+  parentId: d.string().optional().describe("The ID of the parent task to get the tasks for."),
+  responsibleUser: d.string().optional().describe(
+    "Find tasks assigned to this user. Can be a user ID, name, or email address. Defaults to all collaborators when omitted."
+  ),
+  limit: d.number().int().min(1).max(S.COMPLETED_TASKS_MAX).default(S.COMPLETED_TASKS_DEFAULT).describe("The maximum number of tasks to return."),
+  cursor: d.string().optional().describe(
+    "The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters)."
+  ),
+  ...se
+}, Ct = {
+  name: I.FIND_COMPLETED_TASKS,
+  description: "Get completed tasks (includes all collaborators by default—use responsibleUser to narrow).",
+  parameters: $t,
+  async execute(e, t) {
+    const { getBy: s, labels: o, labelsOperator: n, since: r, until: i, responsibleUser: a, projectId: c, ...l } = e, u = await Q(t, a), p = u?.email;
+    let h = oe(o, n);
+    u && p && (h = V(h, `assigned to: ${p}`));
+    const k = await t.getUser(), j = k.tzInfo?.gmtString || "+00:00", C = c === "inbox" ? k.inboxProjectId : c, x = `${r}T00:00:00${j}`, E = `${i}T23:59:59${j}`, m = new Date(x).toISOString(), y = new Date(E).toISOString(), { items: v, nextCursor: b } = s === "completion" ? await t.getCompletedTasksByCompletionDate({
+      ...l,
+      projectId: C,
+      since: m,
+      until: y,
+      ...h ? { filterQuery: h, filterLang: "en" } : {}
+    }) : await t.getCompletedTasksByDueDate({
+      ...l,
+      projectId: C,
+      since: m,
+      until: y,
+      ...h ? { filterQuery: h, filterLang: "en" } : {}
+    }), f = v.map(O), $ = vt({
+      tasks: f,
+      args: e,
+      nextCursor: b,
+      assigneeEmail: p
+    });
+    return T({
+      textContent: $,
+      structuredContent: {
+        tasks: f,
+        nextCursor: b,
+        totalCount: f.length,
+        hasMore: !!b,
+        appliedFilters: e
+      }
+    });
+  }
+};
+function vt({
+  tasks: e,
+  args: t,
+  nextCursor: s,
+  assigneeEmail: o
+}) {
+  const n = t.getBy === "completion" ? "completed" : "due", r = `Completed tasks (by ${n} date)`, i = [];
+  if (i.push(`${n} date: ${t.since} to ${t.until}`), t.projectId && i.push(`project: ${t.projectId}`), t.sectionId && i.push(`section: ${t.sectionId}`), t.parentId && i.push(`parent: ${t.parentId}`), t.workspaceId && i.push(`workspace: ${t.workspaceId}`), t.labels && t.labels.length > 0) {
+    const c = t.labels.map((l) => `@${l}`).join(t.labelsOperator === "and" ? " & " : " | ");
+    i.push(`labels: ${c}`);
+  }
+  if (t.responsibleUser) {
+    const c = o || t.responsibleUser;
+    i.push(`assigned to: ${c}`);
+  }
+  const a = [];
+  return e.length === 0 && (a.push("No tasks completed in this date range"), a.push("Try expanding the date range"), (t.projectId || t.sectionId || t.parentId) && a.push("Try removing project/section/parent filters"), t.getBy === "due" && a.push('Try switching to "completion" date instead')), N({
+    subject: r,
+    count: e.length,
+    limit: t.limit,
+    nextCursor: s ?? void 0,
+    filterHints: i,
+    previewLines: z(e, Math.min(e.length, t.limit)),
+    zeroReasonHints: a
+  });
+}
+const { FIND_PROJECTS: St, ADD_TASKS: Ie, UPDATE_TASKS: ye } = I, Dt = {
+  projectId: d.string().min(1).describe("The ID of the project to search for collaborators in."),
+  searchTerm: d.string().optional().describe(
+    "Search for a collaborator by name or email (partial and case insensitive match). If omitted, all collaborators in the project are returned."
+  )
+}, xt = {
+  name: I.FIND_PROJECT_COLLABORATORS,
+  description: "Search for collaborators by name or other criteria in a project.",
+  parameters: Dt,
+  async execute(e, t) {
+    const { projectId: s, searchTerm: o } = e;
+    let n = s, r;
+    try {
+      if (r = await t.getProject(s), !r)
+        throw new Error(`Project with ID "${s}" not found or not accessible`);
+      if (n = r.name, !r.isShared) {
+        const l = `Project "${n}" is not shared and has no collaborators.
+
+**Next steps:**
+• Share the project to enable collaboration
+• Use ${Ie} and ${ye} for assignment features once shared`;
+        return T({
+          textContent: l,
+          structuredContent: {
+            collaborators: [],
+            projectInfo: {
+              id: s,
+              name: n,
+              isShared: !1
+            },
+            totalCount: 0,
+            appliedFilters: e
+          }
+        });
+      }
+    } catch (l) {
+      throw new Error(
+        `Failed to access project "${s}": ${l instanceof Error ? l.message : "Unknown error"}`
+      );
+    }
+    const i = await _.getProjectCollaborators(t, s);
+    if (i.length === 0) {
+      const l = `Project "${n}" has no collaborators or collaborator data is not accessible.
+
+**Next steps:**
+• Check project sharing settings
+• Ensure you have permission to view collaborators
+• Try refreshing or re-sharing the project`;
+      return T({
+        textContent: l,
+        structuredContent: {
+          collaborators: [],
+          projectInfo: {
+            id: s,
+            name: n,
+            isShared: !0
+          },
+          totalCount: 0,
+          appliedFilters: e
+        }
+      });
+    }
+    let a = i;
+    if (o) {
+      const l = o.toLowerCase().trim();
+      a = i.filter(
+        (u) => u.name.toLowerCase().includes(l) || u.email.toLowerCase().includes(l)
+      );
+    }
+    const c = At({
+      collaborators: a,
+      projectName: n,
+      searchTerm: o,
+      totalAvailable: i.length
+    });
+    return T({
+      textContent: c,
+      structuredContent: {
+        collaborators: a,
+        projectInfo: {
+          id: s,
+          name: n,
+          isShared: !0
+        },
+        totalCount: a.length,
+        totalAvailable: i.length,
+        appliedFilters: e
+      }
+    });
+  }
+};
+function At({
+  collaborators: e,
+  projectName: t,
+  searchTerm: s,
+  totalAvailable: o
+}) {
+  const n = s ? `Project collaborators matching "${s}"` : "Project collaborators", r = [];
+  s && r.push(`matching "${s}"`), r.push(`in project "${t}"`);
+  let i = [];
+  e.length > 0 && (i = e.slice(0, 10).map((l) => {
+    const u = l.name || "Unknown Name", p = l.email || "No email";
+    return `• ${u} (${p}) - ID: ${l.id}`;
+  }), e.length > 10 && i.push(`... and ${e.length - 10} more`));
+  const a = [];
+  e.length === 0 && (s ? (a.push(`No collaborators match "${s}"`), a.push("Try a broader search term or check spelling"), o > 0 && a.push(`${o} collaborators available without filter`)) : (a.push("Project has no collaborators"), a.push("Share the project to add collaborators")));
+  const c = [];
+  return e.length > 0 ? (c.push(`Use ${Ie} with responsibleUser to assign new tasks`), c.push(`Use ${ye} with responsibleUser to reassign existing tasks`), c.push("Use collaborator names, emails, or IDs for assignments")) : (c.push(`Use ${St} to find other projects`), s && o > 0 && c.push("Try searching without filters to see all collaborators")), N({
+    subject: n,
+    count: e.length,
+    filterHints: r,
+    previewLines: i.join(`
+`),
+    zeroReasonHints: a,
+    nextSteps: c
+  });
+}
+const { ADD_PROJECTS: Ut } = I, Pt = {
+  search: d.string().optional().describe(
+    "Search for a project by name (partial and case insensitive match). If omitted, all projects are returned."
+  ),
+  limit: d.number().int().min(1).max(S.PROJECTS_MAX).default(S.PROJECTS_DEFAULT).describe("The maximum number of projects to return."),
+  cursor: d.string().optional().describe(
+    "The cursor to get the next page of projects (cursor is obtained from the previous call to this tool, with the same parameters)."
+  )
+}, Et = {
+  name: I.FIND_PROJECTS,
+  description: "List all projects or search for projects by name. If search parameter is omitted, all projects are returned.",
+  parameters: Pt,
+  async execute(e, t) {
+    const { results: s, nextCursor: o } = await t.getProjects({
+      limit: e.limit,
+      cursor: e.cursor ?? null
+    }), n = e.search ? e.search.toLowerCase() : void 0, i = (n ? s.filter((a) => a.name.toLowerCase().includes(n)) : s).map(he);
+    return T({
+      textContent: Ot({
+        projects: i,
+        args: e,
+        nextCursor: o
+      }),
+      structuredContent: {
+        projects: i,
+        nextCursor: o,
+        totalCount: i.length,
+        hasMore: !!o,
+        appliedFilters: e
+      }
+    });
+  }
+};
+function Ot({
+  projects: e,
+  args: t,
+  nextCursor: s
+}) {
+  const o = t.search ? `Projects matching "${t.search}"` : "Projects", n = [];
+  t.search && n.push(`search: "${t.search}"`);
+  const r = 10, a = e.slice(0, r).map(et).join(`
+`), c = e.length - r, l = c > 0 ? `${a}
+    …and ${c} more` : a, u = [];
+  return e.length === 0 && (t.search ? (u.push("Try broader search terms"), u.push("Check spelling"), u.push("Remove search to see all projects")) : (u.push("No projects created yet"), u.push(`Use ${Ut} to create a project`))), N({
+    subject: o,
+    count: e.length,
+    limit: t.limit,
+    nextCursor: s ?? void 0,
+    filterHints: n,
+    previewLines: l,
+    zeroReasonHints: u
+  });
+}
+const { ADD_SECTIONS: _t } = I, Nt = {
+  projectId: d.string().min(1).describe(
+    'The ID of the project to search sections in. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  ),
+  search: d.string().optional().describe(
+    "Search for a section by name (partial and case insensitive match). If omitted, all sections in the project are returned."
+  )
+}, Mt = {
+  name: I.FIND_SECTIONS,
+  description: "Search for sections by name or other criteria in a project.",
+  parameters: Nt,
+  async execute(e, t) {
+    const s = e.projectId === "inbox" ? (await t.getUser()).inboxProjectId : e.projectId, { results: o } = await t.getSections({
+      projectId: s
+    }), n = e.search ? e.search.toLowerCase() : void 0, i = (n ? o.filter((c) => c.name.toLowerCase().includes(n)) : o).map((c) => ({
+      id: c.id,
+      name: c.name
+    })), a = Ft({
+      sections: i,
+      projectId: e.projectId,
+      search: e.search
+    });
+    return T({
+      textContent: a,
+      structuredContent: {
+        sections: i,
+        totalCount: i.length,
+        appliedFilters: e
+      }
+    });
+  }
+};
+function Ft({
+  sections: e,
+  projectId: t,
+  search: s
+}) {
+  const o = [];
+  s ? (o.push("Try broader search terms"), o.push("Check spelling"), o.push("Remove search to see all sections")) : (o.push("Project has no sections yet"), o.push(`Use ${_t} to create sections`));
+  const n = s ? `Sections in project ${t} matching "${s}"` : `Sections in project ${t}`, r = e.length > 0 ? e.map((i) => `    ${i.name} • id=${i.id}`).join(`
+`) : void 0;
+  return N({
+    subject: n,
+    count: e.length,
+    previewLines: r,
+    zeroReasonHints: o
+  });
+}
+const { FIND_COMPLETED_TASKS: re, ADD_TASKS: ie } = I, Rt = {
+  searchText: d.string().optional().describe("The text to search for in tasks."),
+  projectId: d.string().optional().describe(
+    'Find tasks in this project. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  ),
+  sectionId: d.string().optional().describe("Find tasks in this section."),
+  parentId: d.string().optional().describe("Find subtasks of this parent task."),
+  responsibleUser: d.string().optional().describe("Find tasks assigned to this user. Can be a user ID, name, or email address."),
+  responsibleUserFiltering: d.enum(me).optional().describe(
+    'How to filter by responsible user when responsibleUser is not provided. "assigned" = only tasks assigned to others; "unassignedOrMe" = only unassigned tasks or tasks assigned to me; "all" = all tasks regardless of assignment. Default value will be `unassignedOrMe`.'
+  ),
+  limit: d.number().int().min(1).max(S.TASKS_MAX).default(S.TASKS_DEFAULT).describe("The maximum number of tasks to return."),
+  cursor: d.string().optional().describe(
+    "The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters)."
+  ),
+  ...se
+}, Lt = {
+  name: I.FIND_TASKS,
+  description: "Find tasks by text search, or by project/section/parent container/responsible user. At least one filter must be provided.",
+  parameters: Rt,
+  async execute(e, t) {
+    const {
+      searchText: s,
+      projectId: o,
+      sectionId: n,
+      parentId: r,
+      responsibleUser: i,
+      responsibleUserFiltering: a,
+      limit: c,
+      cursor: l,
+      labels: u,
+      labelsOperator: p
+    } = e, g = await t.getUser(), h = u && u.length > 0;
+    if (!s && !o && !n && !r && !i && !h)
+      throw new Error(
+        "At least one filter must be provided: searchText, projectId, sectionId, parentId, responsibleUser, or labels"
+      );
+    const k = await Q(t, i), j = k?.userId, C = k?.email;
+    if (o || n || r) {
+      const b = {
+        limit: c,
+        cursor: l ?? null
+      };
+      o && (b.projectId = o === "inbox" ? g.inboxProjectId : o), n && (b.sectionId = n), r && (b.parentId = r);
+      const { results: f, nextCursor: $ } = await t.getTasks(b), A = f.map(O);
+      let D = s ? A.filter(
+        (M) => M.content.toLowerCase().includes(s.toLowerCase()) || M.description?.toLowerCase().includes(s.toLowerCase())
+      ) : A;
+      D = ne({
+        tasks: D,
+        resolvedAssigneeId: j,
+        currentUserId: g.id,
+        responsibleUserFiltering: a
+      }), u && u.length > 0 && (D = p === "and" ? D.filter(
+        (M) => u.every((H) => M.labels.includes(H))
+      ) : D.filter(
+        (M) => u.some((H) => M.labels.includes(H))
+      ));
+      const $e = J({
+        tasks: D,
+        args: e,
+        nextCursor: $,
+        isContainerSearch: !0,
+        assigneeEmail: C
+      });
+      return T({
+        textContent: $e,
+        structuredContent: {
+          tasks: D,
+          nextCursor: $,
+          totalCount: D.length,
+          hasMore: !!$,
+          appliedFilters: e
+        }
+      });
+    }
+    if (j && !s && !h) {
+      const b = await t.getTasksByFilter({
+        query: `assigned to: ${C}`,
+        lang: "en",
+        limit: c,
+        cursor: l ?? null
+      }), f = b.results.map(O), $ = J({
+        tasks: f,
+        args: e,
+        nextCursor: b.nextCursor,
+        isContainerSearch: !1,
+        assigneeEmail: C
+      });
+      return T({
+        textContent: $,
+        structuredContent: {
+          tasks: f,
+          nextCursor: b.nextCursor,
+          totalCount: f.length,
+          hasMore: !!b.nextCursor,
+          appliedFilters: e
+        }
+      });
+    }
+    let x = "";
+    s && (x = `search: ${s}`);
+    const E = oe(u, p);
+    x = V(x, E);
+    const m = await ee({
+      client: t,
+      query: x,
+      cursor: e.cursor,
+      limit: e.limit
+    }), y = ne({
+      tasks: m.tasks,
+      resolvedAssigneeId: j,
+      currentUserId: g.id,
+      responsibleUserFiltering: a
+    }), v = J({
+      tasks: y,
+      args: e,
+      nextCursor: m.nextCursor,
+      isContainerSearch: !1,
+      assigneeEmail: C
+    });
+    return T({
+      textContent: v,
+      structuredContent: {
+        tasks: y,
+        nextCursor: m.nextCursor,
+        totalCount: y.length,
+        hasMore: !!m.nextCursor,
+        appliedFilters: e
+      }
+    });
+  }
+};
+function Bt(e) {
+  if (e.projectId) {
+    const t = [
+      e.searchText ? "No tasks in project match search" : "Project has no tasks yet"
+    ];
+    return e.searchText || t.push(`Use ${ie} to create tasks`), t;
+  }
+  if (e.sectionId) {
+    const t = [e.searchText ? "No tasks in section match search" : "Section is empty"];
+    return e.searchText || t.push("Tasks may be in other sections of the project"), t;
+  }
+  if (e.parentId) {
+    const t = [e.searchText ? "No subtasks match search" : "No subtasks created yet"];
+    return e.searchText || t.push(`Use ${ie} with parentId to add subtasks`), t;
+  }
+  return [];
+}
+function J({
+  tasks: e,
+  args: t,
+  nextCursor: s,
+  isContainerSearch: o,
+  assigneeEmail: n
+}) {
+  let r = "Tasks";
+  const i = [], a = [];
+  if (o) {
+    if (t.projectId ? (r = "Tasks in project", i.push(`in project ${t.projectId}`)) : t.sectionId ? (r = "Tasks in section", i.push(`in section ${t.sectionId}`)) : t.parentId ? (r = "Subtasks", i.push(`subtasks of ${t.parentId}`)) : r = "Tasks", t.searchText && (r += ` matching "${t.searchText}"`, i.push(`containing "${t.searchText}"`)), t.responsibleUser) {
+      const c = n || t.responsibleUser;
+      r += ` assigned to ${c}`, i.push(`assigned to ${c}`);
+    }
+    if (t.labels && t.labels.length > 0) {
+      const c = t.labels.map((l) => `@${l}`).join(t.labelsOperator === "and" ? " & " : " | ");
+      i.push(`labels: ${c}`);
+    }
+    e.length === 0 && a.push(...Bt(t));
+  } else {
+    const c = n || t.responsibleUser, l = [];
+    if (t.searchText && l.push(`"${t.searchText}"`), t.responsibleUser && l.push(`assigned to ${c}`), t.labels && t.labels.length > 0) {
+      const u = t.labels.map((p) => `@${p}`).join(t.labelsOperator === "and" ? " & " : " | ");
+      l.push(`with labels: ${u}`);
+    }
+    if (t.searchText ? (r = `Search results for ${l.join(" ")}`, i.push(`matching "${t.searchText}"`)) : t.responsibleUser && (!t.labels || t.labels.length === 0) ? r = `Tasks assigned to ${c}` : t.labels && t.labels.length > 0 && !t.responsibleUser ? r = `Tasks with labels: ${t.labels.map((p) => `@${p}`).join(t.labelsOperator === "and" ? " & " : " | ")}` : r = `Tasks ${l.join(" ")}`, t.responsibleUser && i.push(`assigned to ${c}`), t.labels && t.labels.length > 0) {
+      const u = t.labels.map((p) => `@${p}`).join(t.labelsOperator === "and" ? " & " : " | ");
+      i.push(`labels: ${u}`);
+    }
+    if (e.length === 0) {
+      if (t.responsibleUser) {
+        const u = n || t.responsibleUser;
+        a.push(`No tasks assigned to ${u}`), a.push("Check if the user name is correct"), a.push(`Check completed tasks with ${re}`);
+      }
+      t.searchText && (a.push("Try broader search terms"), a.push("Verify spelling and try partial words"), t.responsibleUser || a.push(`Check completed tasks with ${re}`));
+    }
+  }
+  return N({
+    subject: r,
+    count: e.length,
+    limit: t.limit,
+    nextCursor: s ?? void 0,
+    filterHints: i,
+    previewLines: z(e, Math.min(e.length, t.limit)),
+    zeroReasonHints: a
+  });
+}
+const Kt = {
+  startDate: d.string().regex(/^(\d{4}-\d{2}-\d{2}|today)$/).optional().describe("The start date to get the tasks for. Format: YYYY-MM-DD or 'today'."),
+  overdueOption: d.enum(["overdue-only", "include-overdue", "exclude-overdue"]).optional().describe(
+    "How to handle overdue tasks. 'overdue-only' to get only overdue tasks, 'include-overdue' to include overdue tasks along with tasks for the specified date(s), and 'exclude-overdue' to exclude overdue tasks. Default is 'include-overdue'."
+  ),
+  daysCount: d.number().int().min(1).max(30).default(1).describe(
+    "The number of days to get the tasks for, starting from the start date. Default is 1 which means only tasks for the start date."
+  ),
+  limit: d.number().int().min(1).max(S.TASKS_MAX).default(S.TASKS_DEFAULT).describe("The maximum number of tasks to return."),
+  cursor: d.string().optional().describe(
+    "The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters)."
+  ),
+  responsibleUser: d.string().optional().describe("Find tasks assigned to this user. Can be a user ID, name, or email address."),
+  responsibleUserFiltering: d.enum(me).optional().describe(
+    'How to filter by responsible user when responsibleUser is not provided. "assigned" = only tasks assigned to others; "unassignedOrMe" = only unassigned tasks or tasks assigned to me; "all" = all tasks regardless of assignment. Default is "unassignedOrMe".'
+  ),
+  ...se
+}, Yt = {
+  name: I.FIND_TASKS_BY_DATE,
+  description: "Get tasks by date range. Use startDate 'today' to get today's tasks including overdue items, or provide a specific date/date range.",
+  parameters: Kt,
+  async execute(e, t) {
+    if (!e.startDate && e.overdueOption !== "overdue-only")
+      throw new Error(
+        "Either startDate must be provided or overdueOption must be set to overdue-only"
+      );
+    const s = await Q(t, e.responsibleUser), o = s?.userId, n = s?.email;
+    let r = "";
+    if (e.overdueOption === "overdue-only")
+      r = "overdue";
+    else if (e.startDate === "today")
+      r = e.overdueOption === "exclude-overdue" ? "today" : "(today | overdue)";
+    else if (e.startDate) {
+      const p = e.startDate, g = ue(p, e.daysCount), h = Se(g, { representation: "date" });
+      r = `(due after: ${p} | due: ${p}) & due before: ${h}`;
+    }
+    const i = oe(e.labels, e.labelsOperator);
+    i.length > 0 && (r = V(r, `(${i})`));
+    const a = Ve({
+      resolvedAssigneeId: o,
+      assigneeEmail: n,
+      responsibleUserFiltering: e.responsibleUserFiltering
+    });
+    r = V(r, a);
+    const c = await ee({
+      client: t,
+      query: r,
+      cursor: e.cursor,
+      limit: e.limit
+    }), l = c.tasks, u = Vt({
+      tasks: l,
+      args: e,
+      nextCursor: c.nextCursor,
+      assigneeEmail: n
+    });
+    return T({
+      textContent: u,
+      structuredContent: {
+        tasks: l,
+        nextCursor: c.nextCursor,
+        totalCount: l.length,
+        hasMore: !!c.nextCursor,
+        appliedFilters: e
+      }
+    });
+  }
+};
+function Vt({
+  tasks: e,
+  args: t,
+  nextCursor: s,
+  assigneeEmail: o
+}) {
+  const n = [];
+  if (t.overdueOption === "overdue-only")
+    n.push("overdue tasks only");
+  else if (t.startDate === "today") {
+    const a = t.overdueOption === "exclude-overdue" ? "" : " + overdue tasks";
+    n.push(
+      `today${a}${t.daysCount > 1 ? ` + ${t.daysCount - 1} more days` : ""}`
+    );
+  } else if (t.startDate) {
+    const a = t.daysCount > 1 ? ` to ${Xe(ue(t.startDate, t.daysCount))}` : "";
+    n.push(`${t.startDate}${a}`);
+  }
+  if (t.labels && t.labels.length > 0) {
+    const a = t.labels.map((c) => `@${c}`).join(t.labelsOperator === "and" ? " & " : " | ");
+    n.push(`labels: ${a}`);
+  }
+  if (t.responsibleUser) {
+    const a = o || t.responsibleUser;
+    n.push(`assigned to: ${a}`);
+  }
+  let r = "";
+  if (t.overdueOption === "overdue-only" ? r = "Overdue tasks" : t.startDate === "today" ? r = t.overdueOption === "exclude-overdue" ? "Today's tasks" : "Today's tasks + overdue" : t.startDate ? r = `Tasks for ${t.startDate}` : r = "Tasks", t.responsibleUser) {
+    const a = o || t.responsibleUser;
+    r += ` assigned to ${a}`;
+  }
+  const i = [];
+  if (e.length === 0)
+    if (t.overdueOption === "overdue-only")
+      i.push("Great job! No overdue tasks");
+    else if (t.startDate === "today") {
+      const a = t.overdueOption === "exclude-overdue" ? "" : " or overdue";
+      i.push(`Great job! No tasks for today${a}`);
+    } else
+      i.push("Expand date range with larger 'daysCount'"), i.push("Check today's tasks with startDate='today'");
+  return N({
+    subject: r,
+    count: e.length,
+    limit: t.limit,
+    nextCursor: s ?? void 0,
+    filterHints: n,
+    previewLines: z(e, Math.min(e.length, t.limit)),
+    zeroReasonHints: i
+  });
+}
+const zt = {
+  projectId: d.string().min(1).optional().describe(
+    "Optional project ID. If provided, shows detailed overview of that project. If omitted, shows overview of all projects."
+  )
+};
+function Ht(e) {
+  const t = {};
+  for (const n of e)
+    t[n.id] = {
+      ...n,
+      children: [],
+      childOrder: n.childOrder ?? 0
+    };
+  const s = [];
+  for (const n of e) {
+    const r = t[n.id];
+    if (r)
+      if (B(n) && n.parentId) {
+        const i = t[n.parentId];
+        i ? i.children.push(r) : s.push(r);
+      } else
+        s.push(r);
+  }
+  function o(n) {
+    n.sort((r, i) => r.childOrder - i.childOrder);
+    for (const r of n)
+      o(r.children);
+  }
+  return o(s), s;
+}
+async function Wt(e, t) {
+  const s = {};
+  return await Promise.all(
+    t.map(async (o) => {
+      const { results: n } = await e.getSections({ projectId: o });
+      s[o] = n;
+    })
+  ), s;
+}
+function ke(e, t, s = "") {
+  const o = [];
+  o.push(`${s}- Project: ${e.name} (id=${e.id})`);
+  const n = t[e.id] || [];
+  for (const r of n)
+    o.push(`${s}  - Section: ${r.name} (id=${r.id})`);
+  for (const r of e.children)
+    o.push(...ke(r, t, `${s}  `));
+  return o;
+}
+function ae(e) {
+  const t = {};
+  for (const o of e)
+    t[o.id] = { ...o, children: [] };
+  const s = [];
+  for (const o of e) {
+    const n = t[o.id];
+    if (!n) continue;
+    if (!o.parentId) {
+      s.push(n);
+      continue;
+    }
+    const r = t[o.parentId];
+    r ? r.children.push(n) : s.push(n);
+  }
+  return s;
+}
+function X(e, t = "") {
+  const s = [];
+  for (const o of e) {
+    const n = `id=${o.id}`, r = o.dueDate ? `; due=${o.dueDate}` : "", i = `; content=${o.content}`;
+    s.push(`${t}- ${n}${r}${i}`), o.children.length > 0 && s.push(...X(o.children, `${t}  `));
+  }
+  return s;
+}
+function we(e, t) {
+  return {
+    id: e.id,
+    name: e.name,
+    parentId: B(e) ? e.parentId ?? null : null,
+    sections: t[e.id] || [],
+    children: e.children.map((s) => we(s, t))
+  };
+}
+async function Gt(e, t) {
+  let s = [], o;
+  do {
+    const { results: n, nextCursor: r } = await e.getTasks({
+      projectId: t,
+      limit: S.TASKS_BATCH_SIZE,
+      cursor: o ?? void 0
+    });
+    s = s.concat(n.map(O)), o = r ?? void 0;
+  } while (o);
+  return s;
+}
+async function Jt(e, t) {
+  const { results: s } = await e.getSections({ projectId: t });
+  return s;
+}
+async function qt(e) {
+  const { results: t } = await e.getProjects({}), s = t.find((p) => B(p) && p.inboxProject === !0), o = t.filter((p) => !B(p) || p.inboxProject !== !0), n = Ht(o), r = t.map((p) => p.id), i = await Wt(e, r), a = ["# Personal Projects", ""];
+  if (s) {
+    a.push(`- Inbox Project: ${s.name} (id=${s.id})`);
+    for (const p of i[s.id] || [])
+      a.push(`  - Section: ${p.name} (id=${p.id})`);
+  }
+  if (n.length)
+    for (const p of n)
+      a.push(...ke(p, i));
+  else
+    a.push("_No projects found._");
+  a.push("");
+  const c = n.some((p) => p.children.length > 0);
+  c && a.push(
+    "_Note: Indentation indicates that a project is a sub-project of the one above it. This allows for organizing projects hierarchically, with parent projects containing related sub-projects._",
+    ""
+  );
+  const l = a.join(`
+`), u = {
+    type: "account_overview",
+    inbox: s ? {
+      id: s.id,
+      name: s.name,
+      sections: i[s.id] || []
+    } : null,
+    projects: n.map(
+      (p) => we(p, i)
+    ),
+    totalProjects: t.length,
+    totalSections: r.reduce(
+      (p, g) => p + (i[g]?.length || 0),
+      0
+    ),
+    hasNestedProjects: c
+  };
+  return { textContent: l, structuredContent: u };
+}
+async function Xt(e, t) {
+  const s = await e.getProject(t), o = await Jt(e, t), n = await Gt(e, t), r = {};
+  for (const u of o)
+    r[u.id] = [];
+  const i = [];
+  for (const u of n)
+    (u.sectionId ? r[u.sectionId] ?? i : i).push(u);
+  const a = [`# ${s.name}`];
+  if (i.length > 0) {
+    a.push("");
+    const u = ae(i);
+    a.push(...X(u));
+  }
+  for (const u of o) {
+    a.push(""), a.push(`## ${u.name}`);
+    const p = r[u.id];
+    if (!p?.length)
+      continue;
+    const g = ae(p);
+    a.push(...X(g));
+  }
+  const c = a.join(`
+`), l = {
+    type: "project_overview",
+    project: {
+      id: s.id,
+      name: s.name
+    },
+    sections: o,
+    tasks: n.map((u) => ({
+      ...u,
+      children: []
+      // Tasks already include hierarchical info via parentId
+    })),
+    stats: {
+      totalTasks: n.length,
+      totalSections: o.length,
+      tasksWithoutSection: i.length
+    }
+  };
+  return { textContent: c, structuredContent: l };
+}
+const Zt = {
+  name: I.GET_OVERVIEW,
+  description: "Get a Markdown overview. If no projectId is provided, shows all projects with hierarchy and sections (useful for navigation). If projectId is provided, shows detailed overview of that specific project including all tasks grouped by sections.",
+  parameters: zt,
+  async execute(e, t) {
+    const s = e.projectId ? await Xt(t, e.projectId) : await qt(t);
+    return T({
+      textContent: s.textContent,
+      structuredContent: s.structuredContent
+    });
+  }
+}, { FIND_TASKS: Qt, FIND_PROJECT_COLLABORATORS: ce, UPDATE_TASKS: es } = I, ts = 50, ss = {
+  operation: d.enum(["assign", "unassign", "reassign"]).describe("The assignment operation to perform."),
+  taskIds: d.array(d.string()).min(1).max(ts).describe("The IDs of the tasks to operate on (max 50)."),
+  responsibleUser: d.string().optional().describe(
+    "The user to assign tasks to. Can be user ID, name, or email. Required for assign and reassign operations."
+  ),
+  fromAssigneeUser: d.string().optional().describe(
+    "For reassign operations: the current assignee to reassign from. Can be user ID, name, or email. Optional - if not provided, reassigns from any current assignee."
+  ),
+  dryRun: d.boolean().optional().default(!1).describe("If true, validates operations without executing them.")
+}, os = {
+  name: I.MANAGE_ASSIGNMENTS,
+  description: "Bulk assignment operations for multiple tasks. Supports assign, unassign, and reassign operations with atomic rollback on failures.",
+  parameters: ss,
+  async execute(e, t) {
+    const { operation: s, taskIds: o, responsibleUser: n, fromAssigneeUser: r, dryRun: i } = e;
+    if ((s === "assign" || s === "reassign") && !n)
+      throw new Error(`${s} operation requires responsibleUser parameter`);
+    const a = await Promise.allSettled(
+      o.map(async (m) => {
+        try {
+          return await t.getTask(m);
+        } catch {
+          throw new Error(`Task ${m} not found or not accessible`);
+        }
+      })
+    ), c = [], l = [];
+    for (let m = 0; m < a.length; m++) {
+      const y = a[m];
+      y && y.status === "fulfilled" ? c.push(y.value) : y && y.status === "rejected" ? l.push({
+        taskId: o[m] || "invalid-task-id",
+        success: !1,
+        error: y.reason?.message || "Task not accessible"
+      }) : l.push({
+        taskId: o[m] || "invalid-task-id",
+        success: !1,
+        error: "Task not accessible"
+      });
+    }
+    if (c.length === 0) {
+      const m = K({
+        operation: s,
+        results: l,
+        dryRun: i
+      });
+      return T({
+        textContent: m,
+        structuredContent: {
+          operation: s,
+          results: l,
+          totalRequested: o.length,
+          successful: 0,
+          failed: l.length,
+          dryRun: i
+        }
+      });
+    }
+    let u;
+    s === "reassign" && r && (u = (await _.resolveUser(t, r))?.userId || r);
+    const p = [];
+    for (const m of c)
+      s === "reassign" && u && m.responsibleUid !== u || p.push({
+        taskId: m.id,
+        projectId: m.projectId,
+        responsibleUid: n || ""
+        // Will be validated appropriately
+      });
+    if (s === "unassign") {
+      if (i) {
+        const f = c.map((A) => ({
+          taskId: A.id,
+          success: !0,
+          originalAssigneeId: A.responsibleUid,
+          newAssigneeId: null
+        })), $ = K({
+          operation: s,
+          results: f,
+          dryRun: !0
+        });
+        return T({
+          textContent: $,
+          structuredContent: {
+            operation: s,
+            results: f,
+            totalRequested: o.length,
+            successful: f.length,
+            failed: l.length,
+            dryRun: !0
+          }
+        });
+      }
+      const m = c.map(async (f) => {
+        try {
+          return await t.updateTask(f.id, { assigneeId: null }), {
+            taskId: f.id,
+            success: !0,
+            originalAssigneeId: f.responsibleUid,
+            newAssigneeId: null
+          };
+        } catch ($) {
+          return {
+            taskId: f.id,
+            success: !1,
+            error: $ instanceof Error ? $.message : "Update failed",
+            originalAssigneeId: f.responsibleUid
+          };
+        }
+      }), y = await Promise.all(m), v = [...y, ...l], b = K({
+        operation: s,
+        results: v,
+        dryRun: !1
+      });
+      return T({
+        textContent: b,
+        structuredContent: {
+          operation: s,
+          results: v,
+          totalRequested: o.length,
+          successful: y.filter((f) => f.success).length,
+          failed: v.filter((f) => !f.success).length,
+          dryRun: !1
+        }
+      });
+    }
+    const g = await te.validateBulkAssignment(
+      t,
+      p
+    ), h = [], k = [];
+    for (let m = 0; m < p.length; m++) {
+      const y = p[m], v = g[m];
+      y && v && v.isValid ? h.push({ assignment: y, validation: v }) : y?.taskId && k.push({
+        taskId: y.taskId,
+        success: !1,
+        error: v?.error?.message || "Validation failed"
+      });
+    }
+    async function j(m, y) {
+      const v = m.filter(
+        (f) => f.assignment != null && f.validation != null
+      );
+      if (!y)
+        return v.map(({ assignment: f, validation: $ }) => {
+          const A = c.find((D) => D.id === f.taskId);
+          if (!f.taskId || !$.resolvedUser?.userId)
+            throw new Error(
+              "Invalid assignment or validation data - this should not happen"
+            );
+          return {
+            taskId: f.taskId,
+            success: !0,
+            originalAssigneeId: A?.responsibleUid || null,
+            newAssigneeId: $.resolvedUser.userId
+          };
+        });
+      const b = v.map(
+        async ({ assignment: f, validation: $ }) => {
+          const A = c.find((D) => D.id === f.taskId);
+          if (!f.taskId || !$.resolvedUser?.userId)
+            return {
+              taskId: f.taskId || "unknown-task",
+              success: !1,
+              error: "Invalid assignment data - missing task ID or resolved user",
+              originalAssigneeId: A?.responsibleUid || null
+            };
+          try {
+            return await t.updateTask(f.taskId, {
+              assigneeId: $.resolvedUser.userId
+            }), {
+              taskId: f.taskId,
+              success: !0,
+              originalAssigneeId: A?.responsibleUid || null,
+              newAssigneeId: $.resolvedUser.userId
+            };
+          } catch (D) {
+            return {
+              taskId: f.taskId,
+              success: !1,
+              error: D instanceof Error ? D.message : "Update failed",
+              originalAssigneeId: A?.responsibleUid || null
+            };
+          }
+        }
+      );
+      return Promise.all(b);
+    }
+    const C = await j(h, !i), x = [...C, ...k, ...l], E = K({
+      operation: s,
+      results: x,
+      dryRun: i
+    });
+    return T({
+      textContent: E,
+      structuredContent: {
+        operation: s,
+        results: x,
+        totalRequested: o.length,
+        successful: C.filter((m) => m.success).length,
+        failed: x.filter((m) => !m.success).length,
+        dryRun: i
+      }
+    });
+  }
+};
+function K({
+  operation: e,
+  results: t,
+  dryRun: s
+}) {
+  const o = t.filter((c) => c.success), n = t.filter((c) => !c.success), r = s ? "would be" : "were", i = {
+    assign: "assigned",
+    unassign: "unassigned",
+    reassign: "reassigned"
+  }[e];
+  let a = `**${s ? "Dry Run: " : ""}Bulk ${e} operation**
+
+`;
+  if (o.length > 0) {
+    a += `**${o.length} task${o.length === 1 ? "" : "s"} ${r} successfully ${i}**
+`;
+    const c = o.slice(0, 5);
+    for (const l of c) {
+      let u = "";
+      e === "unassign" ? u = " (unassigned from previous assignee)" : l.newAssigneeId && (u = ` → ${l.newAssigneeId}`), a += `  • Task ${l.taskId}${u}
+`;
+    }
+    o.length > 5 && (a += `  • ... and ${o.length - 5} more
+`), a += `
+`;
+  }
+  if (n.length > 0) {
+    a += `**${n.length} task${n.length === 1 ? "" : "s"} failed**
+`;
+    const c = n.slice(0, 5);
+    for (const l of c)
+      a += `  • Task ${l.taskId}: ${l.error}
+`;
+    n.length > 5 && (a += `  • ... and ${n.length - 5} more failures
+`), a += `
+`;
+  }
+  return !s && o.length > 0 ? (a += `**Next steps:**
+`, a += `• Use ${Qt} with responsibleUser to see ${e === "unassign" ? "unassigned" : "newly assigned"} tasks
+`, a += `• Use ${es} for individual assignment changes
+`, n.length > 0 && (a += `• Check failed tasks and use ${ce} to verify collaborator access
+`)) : s ? (a += `**To execute:**
+`, a += `• Remove dryRun parameter and run again to execute changes
+`, o.length > 0 && (a += `• ${o.length} task${o.length === 1 ? "" : "s"} ready for ${e} operation
+`), n.length > 0 && (a += `• Fix ${n.length} validation error${n.length === 1 ? "" : "s"} before executing
+`)) : o.length === 0 && (a += `**Suggestions:**
+`, a += `• Use ${ce} to find valid assignees
+`, a += `• Check task IDs and assignee permissions
+`, a += `• Use dryRun=true to validate before executing
+`), a;
+}
+const ns = {
+  query: d.string().min(1).describe("The search query string to find tasks and projects.")
+}, rs = {
+  name: I.SEARCH,
+  description: "Search across tasks and projects in Todoist. Returns a list of relevant results with IDs, titles, and URLs.",
+  parameters: ns,
+  async execute(e, t) {
+    try {
+      const { query: s } = e, [o, n] = await Promise.all([
+        ee({
+          client: t,
+          query: `search: ${s}`,
+          limit: S.TASKS_MAX,
+          cursor: void 0
+        }),
+        t.getProjects({ limit: S.PROJECTS_MAX })
+      ]), r = s.toLowerCase(), i = n.results.filter(
+        (l) => l.name.toLowerCase().includes(r)
+      ), a = [];
+      for (const l of o.tasks)
+        a.push({
+          id: `task:${l.id}`,
+          title: l.content,
+          url: le(l.id)
+        });
+      for (const l of i)
+        a.push({
+          id: `project:${l.id}`,
+          title: l.name,
+          url: de(l.id)
+        });
+      return { content: [{ type: "text", text: JSON.stringify({ results: a }) }] };
+    } catch (s) {
+      const o = s instanceof Error ? s.message : "An unknown error occurred";
+      return Z(o);
+    }
+  }
+}, is = d.object({
+  id: d.string().min(1).describe("The ID of the comment to update."),
+  content: d.string().min(1).describe("The new content for the comment.")
+}), as = {
+  comments: d.array(is).min(1).describe("The comments to update.")
+}, cs = {
+  name: I.UPDATE_COMMENTS,
+  description: "Update multiple existing comments with new content.",
+  parameters: as,
+  async execute(e, t) {
+    const { comments: s } = e, o = s.map(async (i) => await t.updateComment(i.id, { content: i.content })), n = await Promise.all(o), r = ls({
+      comments: n
+    });
+    return T({
+      textContent: r,
+      structuredContent: {
+        comments: n,
+        totalCount: n.length,
+        updatedCommentIds: n.map((i) => i.id),
+        appliedOperations: {
+          updateCount: n.length
+        }
+      }
+    });
+  }
+};
+function ls({ comments: e }) {
+  const t = e.filter((r) => r.taskId).length, s = e.filter((r) => r.projectId).length, o = [];
+  if (t > 0) {
+    const r = t > 1 ? "comments" : "comment";
+    o.push(`${t} task ${r}`);
+  }
+  if (s > 0) {
+    const r = s > 1 ? "comments" : "comment";
+    o.push(`${s} project ${r}`);
+  }
+  return o.length > 0 ? `Updated ${o.join(" and ")}` : "No comments updated";
+}
+const ds = d.object({
+  id: d.string().min(1).describe("The ID of the project to update."),
+  name: d.string().min(1).optional().describe("The new name of the project."),
+  isFavorite: d.boolean().optional().describe("Whether the project is a favorite."),
+  viewStyle: d.enum(["list", "board", "calendar"]).optional().describe("The project view style.")
+}), us = {
+  projects: d.array(ds).min(1).describe("The projects to update.")
+}, ps = {
+  name: I.UPDATE_PROJECTS,
+  description: "Update multiple existing projects with new values.",
+  parameters: us,
+  async execute(e, t) {
+    const { projects: s } = e, o = s.map(async (i) => {
+      if (!hs(i))
+        return;
+      const { id: a, ...c } = i;
+      return await t.updateProject(a, c);
+    }), n = (await Promise.all(o)).filter(
+      (i) => i !== void 0
+    ), r = ms({
+      projects: n,
+      args: e
+    });
+    return T({
+      textContent: r,
+      structuredContent: {
+        projects: n,
+        totalCount: n.length,
+        updatedProjectIds: n.map((i) => i.id),
+        appliedOperations: {
+          updateCount: n.length,
+          skippedCount: s.length - n.length
+        }
+      }
+    });
+  }
+};
+function ms({
+  projects: e,
+  args: t
+}) {
+  const s = t.projects.length, o = e.length, n = s - o, r = e.length, i = e.map((c) => `• ${c.name} (id=${c.id})`).join(`
+`);
+  let a = `Updated ${r} project${r === 1 ? "" : "s"}`;
+  return n > 0 && (a += ` (${n} skipped - no changes)`), r > 0 && (a += `:
+${i}`), a;
+}
+function hs({ id: e, ...t }) {
+  return Object.keys(t).length > 0;
+}
+const fs = d.object({
+  id: d.string().min(1).describe("The ID of the section to update."),
+  name: d.string().min(1).describe("The new name of the section.")
+}), gs = {
+  sections: d.array(fs).min(1).describe("The sections to update.")
+}, bs = {
+  name: I.UPDATE_SECTIONS,
+  description: "Update multiple existing sections with new values.",
+  parameters: gs,
+  async execute({ sections: e }, t) {
+    const s = await Promise.all(
+      e.map((n) => t.updateSection(n.id, { name: n.name }))
+    ), o = Ts({
+      sections: s
+    });
+    return T({
+      textContent: o,
+      structuredContent: {
+        sections: s,
+        totalCount: s.length,
+        updatedSectionIds: s.map((n) => n.id)
+      }
+    });
+  }
+};
+function Ts({ sections: e }) {
+  const t = e.length, s = e.map((n) => `• ${n.name} (id=${n.id}, projectId=${n.projectId})`).join(`
+`);
+  return `Updated ${t} section${t === 1 ? "" : "s"}:
+${s}`;
+}
+const Is = d.object({
+  id: d.string().min(1).describe("The ID of the task to update."),
+  content: d.string().optional().describe(
+    'The new task name/title. Should be concise and actionable (e.g., "Review PR #123", "Call dentist"). For longer content, use the description field instead. Supports Markdown.'
+  ),
+  description: d.string().optional().describe(
+    "New additional details, notes, or context for the task. Use this for longer content rather than putting it in the task name. Supports Markdown."
+  ),
+  projectId: d.string().optional().describe(
+    'The new project ID for the task. Project ID should be an ID string, or the text "inbox", for inbox tasks.'
+  ),
+  sectionId: d.string().optional().describe("The new section ID for the task."),
+  parentId: d.string().optional().describe("The new parent task ID (for subtasks)."),
+  order: d.number().optional().describe("The new order of the task within its parent/section."),
+  priority: fe.optional().describe(
+    "The new priority of the task: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default)."
+  ),
+  dueString: d.string().optional().describe("The new due date for the task, in natural language (e.g., 'tomorrow at 5pm')."),
+  deadlineDate: d.string().optional().describe(
+    'The new deadline date for the task in ISO 8601 format (YYYY-MM-DD, e.g., "2025-12-31"). Deadlines are immovable constraints shown with a different indicator than due dates. Use "remove" to clear the deadline.'
+  ),
+  duration: d.string().optional().describe(
+    'The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'
+  ),
+  responsibleUser: d.string().optional().describe(
+    'Change task assignment. Use "unassign" to remove assignment. Can be user ID, name, or email. User must be a project collaborator.'
+  ),
+  labels: d.array(d.string()).optional().describe("The new labels for the task. Replaces all existing labels.")
+}), ys = {
+  tasks: d.array(Is).min(1).describe("The tasks to update.")
+}, ks = {
+  name: I.UPDATE_TASKS,
+  description: "Update existing tasks including content, dates, priorities, and assignments.",
+  parameters: ys,
+  async execute(e, t) {
+    const { tasks: s } = e, o = s.map(async (a) => {
+      if (!js(a))
+        return;
+      const {
+        id: c,
+        projectId: l,
+        sectionId: u,
+        parentId: p,
+        duration: g,
+        responsibleUser: h,
+        priority: k,
+        labels: j,
+        deadlineDate: C,
+        ...x
+      } = a;
+      let E = l;
+      l === "inbox" && (E = (await t.getUser()).inboxProjectId);
+      let m = {
+        ...x,
+        ...j !== void 0 && { labels: j }
+      };
+      if (k && (m.priority = ge(k)), C !== void 0 && (C === null || C === "remove" ? m = { ...m, deadlineDate: null } : m = { ...m, deadlineDate: C }), g)
+        try {
+          const { minutes: b } = pe(g);
+          m = {
+            ...m,
+            duration: b,
+            durationUnit: "minute"
+          };
+        } catch (b) {
+          throw b instanceof P ? new Error(`Task ${c}: ${b.message}`) : b;
+        }
+      if (h !== void 0)
+        if (h === null || h === "unassign")
+          m = { ...m, assigneeId: null };
+        else {
+          const b = await te.validateTaskUpdateAssignment(
+            t,
+            c,
+            h
+          );
+          if (!b.isValid) {
+            const f = b.error?.message || "Assignment validation failed", $ = b.error?.suggestions?.join(". ") || "";
+            throw new Error(
+              `Task ${c}: ${f}${$ ? `. ${$}` : ""}`
+            );
+          }
+          m = { ...m, assigneeId: b.resolvedUser?.userId };
+        }
+      if (!E && !u && !p)
+        return await t.updateTask(c, m);
+      const y = ze(c, E, u, p), v = await t.moveTask(c, y);
+      return Object.keys(m).length > 0 ? await t.updateTask(c, m) : v;
+    }), n = (await Promise.all(o)).filter(
+      (a) => a !== void 0
+    ), r = n.map(O), i = ws({
+      tasks: r,
+      args: e
+    });
+    return T({
+      textContent: i,
+      structuredContent: {
+        tasks: r,
+        totalCount: r.length,
+        updatedTaskIds: n.map((a) => a.id),
+        appliedOperations: {
+          updateCount: r.length,
+          skippedCount: s.length - r.length
+        }
+      }
+    });
+  }
+};
+function ws({
+  tasks: e,
+  args: t
+}) {
+  const s = t.tasks.length, o = e.length, n = s - o;
+  let r = "";
+  return n > 0 && (r = ` (${n} skipped - no changes)`), be("Updated", e, {
+    context: r,
+    showDetails: e.length <= 5
+  });
+}
+function js({ id: e, ...t }) {
+  return Object.keys(t).length > 0;
+}
+const $s = {};
+function Cs(e) {
+  return e.businessAccountId ? "Todoist Business" : e.isPremium ? "Todoist Pro" : "Todoist Free";
+}
+function vs(e, t) {
+  const o = ((e.getDay() || 7) - t + 7) % 7, n = new Date(e);
+  return n.setDate(e.getDate() - o), n;
+}
+function Ss(e) {
+  const t = new Date(e);
+  return t.setDate(e.getDate() + 6), t;
+}
+function Ds(e) {
+  const t = new Date(e.getFullYear(), 0, 1), s = (e.getTime() - t.getTime()) / 864e5;
+  return Math.ceil((s + t.getDay() + 1) / 7);
+}
+function xs(e) {
+  return ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][e === 7 ? 0 : e] ?? "Unknown";
+}
+function Y(e) {
+  return e.toISOString().split("T")[0] ?? "";
+}
+function As(e) {
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: e }), !0;
+  } catch {
+    return !1;
+  }
+}
+function je(e) {
+  return As(e) ? e : "UTC";
+}
+function Us(e, t) {
+  const s = je(t);
+  return e.toLocaleString("en-US", {
+    timeZone: s,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: !1
+  });
+}
+async function Ps(e) {
+  const t = await e.getUser(), s = t.tzInfo?.timezone ?? "UTC", o = je(s), n = /* @__PURE__ */ new Date(), r = Us(n, o), i = t.startDay ?? 1, a = xs(i), c = Cs(t), l = new Date(n.toLocaleString("en-US", { timeZone: o })), u = vs(l, i), p = Ss(u), g = Ds(l), k = [
+    "# User Information",
+    "",
+    `**User ID:** ${t.id}`,
+    `**Full Name:** ${t.fullName}`,
+    `**Email:** ${t.email}`,
+    `**Timezone:** ${o}`,
+    `**Current Local Time:** ${r}`,
+    "",
+    "## Week Settings",
+    `**Week Start Day:** ${a} (${i})`,
+    `**Current Week:** Week ${g}`,
+    `**Week Start Date:** ${Y(u)}`,
+    `**Week End Date:** ${Y(p)}`,
+    "",
+    "## Daily Progress",
+    `**Completed Today:** ${t.completedToday}`,
+    `**Daily Goal:** ${t.dailyGoal}`,
+    `**Weekly Goal:** ${t.weeklyGoal}`,
+    "",
+    "## Account Info",
+    `**Plan:** ${c}`
+  ].join(`
+`), j = {
+    type: "user_info",
+    userId: t.id,
+    fullName: t.fullName,
+    timezone: o,
+    currentLocalTime: r,
+    startDay: i,
+    startDayName: a,
+    weekStartDate: Y(u),
+    weekEndDate: Y(p),
+    currentWeekNumber: g,
+    completedToday: t.completedToday,
+    dailyGoal: t.dailyGoal,
+    weeklyGoal: t.weeklyGoal,
+    email: t.email,
+    plan: c
+  };
+  return { textContent: k, structuredContent: j };
+}
+const Es = {
+  name: I.USER_INFO,
+  description: "Get comprehensive user information including user ID, full name, email, timezone with current local time, week start day preferences, current week dates, daily/weekly goal progress, and user plan (Free/Pro/Business).",
+  parameters: $s,
+  async execute(e, t) {
+    const s = await Ps(t);
+    return T({
+      textContent: s.textContent,
+      structuredContent: s.structuredContent
+    });
+  }
+}, Os = `
+## Todoist Task and Project Management Tools
+
+You have access to comprehensive Todoist management tools for personal productivity and team collaboration. Use these tools to help users manage tasks, projects, sections, comments, and assignments effectively.
+
+### Core Capabilities:
+- Create, update, complete, and search tasks with rich metadata (priorities, due dates, durations, assignments)
+- Manage projects and sections with flexible organization
+- Handle comments and collaboration features
+- Bulk assignment operations for team workflows
+- Get overviews and insights about workload and progress
+
+### Tool Usage Guidelines:
+
+**Task Management:**
+- **add-tasks**: Create tasks with content, description, priority (p1=highest, p2=high, p3=medium, p4=lowest/default), dueString (natural language like "tomorrow", "next Friday", "2024-12-25"), deadlineDate (ISO 8601 format like "2025-12-31" for immovable constraints), duration (formats like "2h", "90m", "2h30m"), and assignments to project collaborators
+- **update-tasks**: Modify existing tasks - get task IDs from search results first, only include fields that need changes. Supports deadlineDate (ISO 8601 format like "2025-12-31") updates and removals (use "remove" to clear)
+- **complete-tasks**: Mark tasks as done using task IDs
+- **find-tasks**: Search by text, project/section/parent container, responsible user, or labels. Requires at least one search parameter
+- **find-tasks-by-date**: Get tasks by date range (startDate: YYYY-MM-DD or 'today' which includes overdue tasks) or specific day counts
+- **find-completed-tasks**: View completed tasks by completion date or original due date (returns all collaborators unless filtered)
+
+**Project & Organization:**
+- **add-projects/update-projects/find-projects**: Manage project lifecycle with names, favorites, and view styles (list/board/calendar)
+- **add-sections/update-sections/find-sections**: Organize tasks within projects using sections
+- **get-overview**: Get comprehensive Markdown overview of entire account or specific project with task hierarchies
+
+**Collaboration & Comments:**
+- **add-comments/update-comments/find-comments**: Manage task and project discussions
+- **find-project-collaborators**: Find team members by name or email for assignments
+- **manage-assignments**: Bulk assign/unassign/reassign up to 50 tasks with atomic operations and dry-run validation
+
+**Activity & Audit:**
+- **find-activity**: Retrieve recent activity logs to monitor and audit changes. Shows events from all users by default; use initiatorId to filter by specific user. Filter by object type (task/project/comment), event type (added/updated/deleted/completed/uncompleted/archived/unarchived/shared/left), and specific objects (objectId, projectId, taskId). Useful for tracking who did what and when. Note: Date-based filtering is not supported.
+
+**General Operations:**
+- **delete-object**: Remove projects, sections, tasks, or comments by type and ID
+- **user-info**: Get user details including timezone, goals, and plan information
+
+### Best Practices:
+
+1. **Task Creation**: Write clear, actionable task titles. Use natural language for due dates ("tomorrow", "next Monday"). Set appropriate priorities and include detailed descriptions when needed.
+
+2. **Search Strategy**: Use specific search queries combining multiple filters for precise results. When searching for tasks, start with broader queries and narrow down as needed.
+
+3. **Assignments**: Always validate project collaborators exist before assigning tasks. Use find-project-collaborators to verify user access.
+
+4. **Bulk Operations**: When working with multiple items, prefer bulk tools (complete-tasks, manage-assignments) over individual operations for better performance.
+
+5. **Date Handling**: All dates respect user timezone settings. Use 'today' keyword for dynamic date filtering (includes overdue tasks).
+
+6. **Labels**: Use label filtering with AND/OR operators for advanced task organization. Most search tools support labels parameter.
+
+7. **Pagination**: Large result sets use cursor-based pagination. Use limit parameter to control result size (default varies by tool).
+
+8. **Error Handling**: All tools provide detailed error messages and next-step suggestions. Pay attention to validation feedback for corrective actions.
+
+### Common Workflows:
+
+- **Daily Planning**: Use find-tasks-by-date with 'today' and get-overview for project status
+- **Team Assignment**: find-project-collaborators → add-tasks with responsibleUser → manage-assignments for bulk changes  
+- **Task Search**: find-tasks with multiple filters → update-tasks or complete-tasks based on results
+- **Project Organization**: add-projects → add-sections → add-tasks with projectId and sectionId
+- **Progress Reviews**: find-completed-tasks with date ranges → get-overview for project summaries
+- **Activity Auditing**: find-activity with event/object filters to track changes, monitor team activity, or investigate specific actions
+
+Always provide clear, actionable task titles and descriptions. Use the overview tools to give users context about their workload and project status.
+`;
+function Rs({ todoistApiKey: e, baseUrl: t }) {
+  const s = new ve(
+    { name: "todoist-mcp-server", version: "0.1.0" },
+    {
+      capabilities: {
+        tools: { listChanged: !0 }
+      },
+      instructions: Os
+    }
+  ), o = new Ce(e, t);
+  return w(ot, s, o), w(at, s, o), w(ks, s, o), w(Lt, s, o), w(Yt, s, o), w(Ct, s, o), w(_e, s, o), w(ps, s, o), w(Et, s, o), w(Re, s, o), w(bs, s, o), w(Mt, s, o), w(Ue, s, o), w(kt, s, o), w(cs, s, o), w(ft, s, o), w(Zt, s, o), w(dt, s, o), w(Es, s, o), w(xt, s, o), w(os, s, o), w(rs, s, o), w(mt, s, o), s;
+}
+export {
+  xt as a,
+  Zt as b,
+  ft as c,
+  dt as d,
+  kt as e,
+  mt as f,
+  Rs as g,
+  cs as h,
+  Ue as i,
+  Mt as j,
+  bs as k,
+  Re as l,
+  os as m,
+  Et as n,
+  ps as o,
+  _e as p,
+  Ct as q,
+  Yt as r,
+  rs as s,
+  Lt as t,
+  Es as u,
+  ks as v,
+  at as w,
+  ot as x
+};