@doist/todoist-ai 0.1.0 → 0.1.1

package/dist/esm/tools/sections-add-one.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+const ArgsSchema = {
+    name: z.string().min(1).describe("The name of the section to add."),
+    projectId: z
+        .string()
+        .min(1)
+        .describe("The ID of the project to add the section to."),
+};
+const sectionsAddOne = {
+    name: "sections-add-one",
+    description: "Add a new section to a project.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const section = await client.addSection({
+            name: args.name,
+            projectId: args.projectId,
+        });
+        return section;
+    },
+};
+export { sectionsAddOne };

package/dist/esm/tools/sections-delete-one.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+declare const sectionsDeleteOne: {
+    name: string;
+    description: string;
+    parameters: {
+        id: z.ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        success: boolean;
+    }>;
+};
+export { sectionsDeleteOne };
+//# sourceMappingURL=sections-delete-one.d.ts.map

package/dist/esm/tools/sections-delete-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections-delete-one.d.ts","sourceRoot":"","sources":["../../../src/tools/sections-delete-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,QAAA,MAAM,iBAAiB;;;;;;;;;;;CAQmB,CAAC;AAE3C,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/esm/tools/sections-delete-one.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+const ArgsSchema = {
+    id: z.string().min(1).describe("The ID of the section to delete."),
+};
+const sectionsDeleteOne = {
+    name: "sections-delete-one",
+    description: "Delete a section by its ID.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        await client.deleteSection(args.id);
+        return { success: true };
+    },
+};
+export { sectionsDeleteOne };

package/dist/esm/tools/sections-search.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+declare const sectionsSearch: {
+    name: string;
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        search: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        projectId: string;
+        search?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        id: string;
+        name: string;
+    }[]>;
+};
+export { sectionsSearch };
+//# sourceMappingURL=sections-search.d.ts.map

package/dist/esm/tools/sections-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections-search.d.ts","sourceRoot":"","sources":["../../../src/tools/sections-search.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;CAmBsB,CAAC;AAE3C,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/esm/tools/sections-search.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+const ArgsSchema = {
+    projectId: z
+        .string()
+        .min(1)
+        .describe("The ID of the project to search sections in."),
+    search: z
+        .string()
+        .optional()
+        .describe("Search for a section by name (partial and case insensitive match). If omitted, all sections in the project are returned."),
+};
+const sectionsSearch = {
+    name: "sections-search",
+    description: "Search for sections by name or other criteria in a project.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { results } = await client.getSections({
+            projectId: args.projectId,
+        });
+        const searchLower = args.search ? args.search.toLowerCase() : undefined;
+        const filtered = searchLower
+            ? results.filter((section) => section.name.toLowerCase().includes(searchLower))
+            : results;
+        return filtered.map((section) => ({
+            id: section.id,
+            name: section.name,
+        }));
+    },
+};
+export { sectionsSearch };

package/dist/esm/tools/sections-update-one.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+declare const sectionsUpdateOne: {
+    name: string;
+    description: string;
+    parameters: {
+        id: z.ZodString;
+        name: z.ZodString;
+    };
+    execute(args: {
+        name: string;
+        id: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<import("@doist/todoist-api-typescript").Section>;
+};
+export { sectionsUpdateOne };
+//# sourceMappingURL=sections-update-one.d.ts.map

package/dist/esm/tools/sections-update-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections-update-one.d.ts","sourceRoot":"","sources":["../../../src/tools/sections-update-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,QAAA,MAAM,iBAAiB;;;;;;;;;;;CASmB,CAAC;AAE3C,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/esm/tools/sections-update-one.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+const ArgsSchema = {
+    id: z.string().min(1).describe("The ID of the section to update."),
+    name: z.string().min(1).describe("The new name for the section."),
+};
+const sectionsUpdateOne = {
+    name: "sections-update-one",
+    description: "Update a section's name by its ID.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { id, name } = args;
+        const section = await client.updateSection(id, { name });
+        return section;
+    },
+};
+export { sectionsUpdateOne };

package/dist/esm/tools/shared.d.ts

@@ -0,0 +1,55 @@
+import { type Project, type Task, type TodoistApi } from "@doist/todoist-api-typescript";
+/**
+ * Map a single Todoist task to a more structured format, for LLM consumption.
+ * @param task - The task to map.
+ * @returns The mapped task.
+ */
+declare function mapTask(task: Task): {
+    id: string;
+    content: string;
+    description: string;
+    dueDate: string | undefined;
+    recurring: string | boolean;
+    priority: number;
+    projectId: string;
+    sectionId: string | null;
+    parentId: string | null;
+    labels: string[];
+};
+/**
+ * Map a single Todoist project to a more structured format, for LLM consumption.
+ * @param project - The project to map.
+ * @returns The mapped project.
+ */
+declare function mapProject(project: Project): {
+    id: string;
+    name: string;
+    color: string;
+    isFavorite: boolean;
+    isShared: boolean;
+    parentId: string | null;
+    inboxProject: boolean;
+    viewStyle: string;
+};
+declare function getTasksByFilter({ client, query, limit, cursor, }: {
+    client: TodoistApi;
+    query: string;
+    limit: number | undefined;
+    cursor: string | undefined;
+}): Promise<{
+    tasks: {
+        id: string;
+        content: string;
+        description: string;
+        dueDate: string | undefined;
+        recurring: string | boolean;
+        priority: number;
+        projectId: string;
+        sectionId: string | null;
+        parentId: string | null;
+        labels: string[];
+    }[];
+    nextCursor: string | null;
+}>;
+export { getTasksByFilter, mapTask, mapProject };
+//# sourceMappingURL=shared.d.ts.map

package/dist/esm/tools/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/tools/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,UAAU,EAEf,MAAM,+BAA+B,CAAC;AAGvC;;;;GAIG;AACH,iBAAS,OAAO,CAAC,IAAI,EAAE,IAAI;;;;;;;;;;;EAc1B;AAED;;;;GAIG;AACH,iBAAS,UAAU,CAAC,OAAO,EAAE,OAAO;;;;;;;;;EAWnC;AAWD,iBAAe,gBAAgB,CAAC,EAC/B,MAAM,EACN,KAAK,EACL,KAAK,EACL,MAAM,GACN,EAAE;IACF,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;;;;;;;;;;;;;;GAyBA;AAED,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/esm/tools/shared.js

@@ -0,0 +1,71 @@
+import { getSanitizedContent, } from "@doist/todoist-api-typescript";
+import z from "zod";
+/**
+ * Map a single Todoist task to a more structured format, for LLM consumption.
+ * @param task - The task to map.
+ * @returns The mapped task.
+ */
+function mapTask(task) {
+    return {
+        id: task.id,
+        content: getSanitizedContent(task.content),
+        description: getSanitizedContent(task.description),
+        dueDate: task.due?.date,
+        recurring: task.due?.isRecurring && task.due.string ? task.due.string : false,
+        priority: task.priority,
+        projectId: task.projectId,
+        sectionId: task.sectionId,
+        parentId: task.parentId,
+        labels: task.labels,
+    };
+}
+/**
+ * Map a single Todoist project to a more structured format, for LLM consumption.
+ * @param project - The project to map.
+ * @returns The mapped project.
+ */
+function mapProject(project) {
+    return {
+        id: project.id,
+        name: project.name,
+        color: project.color,
+        isFavorite: project.isFavorite,
+        isShared: project.isShared,
+        parentId: project.parentId ?? null,
+        inboxProject: project.isInboxProject ?? false,
+        viewStyle: project.viewStyle,
+    };
+}
+const ErrorSchema = z.object({
+    httpStatusCode: z.number(),
+    responseData: z.object({
+        error: z.string(),
+        errorCode: z.number(),
+        errorTag: z.string(),
+    }),
+});
+async function getTasksByFilter({ client, query, limit, cursor, }) {
+    try {
+        const { results, nextCursor } = await client.getTasksByFilter({
+            query,
+            cursor,
+            limit,
+        });
+        return {
+            tasks: results.map(mapTask),
+            nextCursor,
+        };
+    }
+    catch (error) {
+        const parsedError = ErrorSchema.safeParse(error);
+        if (!parsedError.success) {
+            throw error;
+        }
+        const { responseData } = parsedError.data;
+        if (responseData.errorTag === "INVALID_SEARCH_QUERY") {
+            throw new Error(`Invalid filter query: ${query}`);
+        }
+        throw new Error(`${responseData.error} (tag: ${responseData.errorTag}, code: ${responseData.errorCode})`);
+    }
+}
+export { getTasksByFilter, mapTask, mapProject };

package/dist/esm/tools/subtasks-list-for-parent-task.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+declare const subtasksListForParentTask: {
+    name: string;
+    description: string;
+    parameters: {
+        parentId: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        parentId: string;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { subtasksListForParentTask };
+//# sourceMappingURL=subtasks-list-for-parent-task.d.ts.map

package/dist/esm/tools/subtasks-list-for-parent-task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtasks-list-for-parent-task.d.ts","sourceRoot":"","sources":["../../../src/tools/subtasks-list-for-parent-task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBW,CAAC;AAE3C,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/esm/tools/subtasks-list-for-parent-task.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { mapTask } from "./shared.js";
+const ArgsSchema = {
+    parentId: z
+        .string()
+        .min(1)
+        .describe("The ID of the parent task to get subtasks for."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of subtasks to return."),
+    cursor: z
+        .string()
+        .optional()
+        .describe("The cursor to get the next page of subtasks (from previous call)."),
+};
+const subtasksListForParentTask = {
+    name: "subtasks-list-for-parent-task",
+    description: "List subtasks for a given parent task.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { parentId, limit, cursor } = args;
+        const { results, nextCursor } = await client.getTasks({
+            parentId,
+            limit,
+            cursor: cursor ?? null,
+        });
+        return {
+            tasks: results.map(mapTask),
+            nextCursor,
+        };
+    },
+};
+export { subtasksListForParentTask };

package/dist/esm/tools/tasks-add-multiple.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+declare const tasksAddMultiple: {
+    name: string;
+    description: string;
+    parameters: {
+        projectId: z.ZodOptional<z.ZodString>;
+        sectionId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        tasks: z.ZodArray<z.ZodObject<{
+            content: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            dueString: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            description?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+        }, {
+            content: string;
+            description?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        tasks: {
+            content: string;
+            description?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+        }[];
+        projectId?: string | undefined;
+        parentId?: string | undefined;
+        sectionId?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        id: string;
+        content: string;
+        description: string;
+        dueDate: string | undefined;
+        recurring: string | boolean;
+        priority: number;
+        projectId: string;
+        sectionId: string | null;
+        parentId: string | null;
+        labels: string[];
+    }[]>;
+};
+export { tasksAddMultiple };
+//# sourceMappingURL=tasks-add-multiple.d.ts.map

package/dist/esm/tools/tasks-add-multiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-add-multiple.d.ts","sourceRoot":"","sources":["../../../src/tools/tasks-add-multiple.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaoB,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/esm/tools/tasks-add-multiple.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { mapTask } from "./shared.js";
+const TaskSchema = z.object({
+    content: z.string().min(1).describe("The content of the task to create."),
+    description: z.string().optional().describe("The description of the task."),
+    priority: z
+        .number()
+        .int()
+        .min(1)
+        .max(4)
+        .optional()
+        .describe("The priority of the task (1-4)."),
+    dueString: z
+        .string()
+        .optional()
+        .describe("The due date for the task, in natural language."),
+});
+const ArgsSchema = {
+    projectId: z
+        .string()
+        .optional()
+        .describe("The project ID to add the tasks to."),
+    sectionId: z
+        .string()
+        .optional()
+        .describe("The section ID to add the tasks to."),
+    parentId: z
+        .string()
+        .optional()
+        .describe("The parent task ID (for subtasks)."),
+    tasks: z.array(TaskSchema).min(1).describe("The array of tasks to add."),
+};
+const tasksAddMultiple = {
+    name: "tasks-add-multiple",
+    description: "Add one or more tasks to a project, section, or parent.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { projectId, sectionId, parentId, tasks } = args;
+        const newTasks = [];
+        for (const task of tasks) {
+            const taskArgs = { ...task, projectId, sectionId, parentId };
+            newTasks.push(await client.addTask(taskArgs));
+        }
+        return newTasks.map(mapTask);
+    },
+};
+export { tasksAddMultiple };

package/dist/esm/tools/tasks-by-date-range.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+declare const tasksListByDate: {
+    name: string;
+    description: string;
+    parameters: {
+        startDate: z.ZodString;
+        daysCount: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        startDate: string;
+        daysCount: number;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { tasksListByDate };
+//# sourceMappingURL=tasks-by-date-range.d.ts.map

package/dist/esm/tools/tasks-by-date-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-by-date-range.d.ts","sourceRoot":"","sources":["../../../src/tools/tasks-by-date-range.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmCxB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBqB,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/esm/tools/tasks-by-date-range.js

@@ -0,0 +1,47 @@
+import { addDays, formatISO } from "date-fns";
+import { z } from "zod";
+import { getTasksByFilter } from "./shared.js";
+const ArgsSchema = {
+    startDate: z
+        .string()
+        .regex(/^(\d{4}-\d{2}-\d{2}|today)$/)
+        .describe("The start date to get the tasks for. Format: YYYY-MM-DD or 'today'."),
+    daysCount: z
+        .number()
+        .int()
+        .min(1)
+        .max(30)
+        .default(1)
+        .describe("The number of days to get the tasks for, starting from the start date."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of tasks to return."),
+    cursor: z
+        .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)."),
+};
+const tasksListByDate = {
+    name: "tasks-list-by-date",
+    description: "Get tasks by date range.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const startDate = args.startDate === "today"
+            ? formatISO(new Date(), { representation: "date" })
+            : args.startDate;
+        const endDate = addDays(startDate, args.daysCount + 1);
+        const endDateStr = formatISO(endDate, { representation: "date" });
+        const query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
+        return await getTasksByFilter({
+            client,
+            query,
+            cursor: args.cursor,
+            limit: args.limit,
+        });
+    },
+};
+export { tasksListByDate };

package/dist/esm/tools/tasks-by-project.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+declare const tasksListForProject: {
+    name: string;
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        projectId: string;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        tasks: {
+            id: string;
+            content: string;
+            description: string;
+            dueDate: string | undefined;
+            recurring: string | boolean;
+            priority: number;
+            projectId: string;
+            sectionId: string | null;
+            parentId: string | null;
+            labels: string[];
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+export { tasksListForProject };
+//# sourceMappingURL=tasks-by-project.d.ts.map

package/dist/esm/tools/tasks-by-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-by-project.d.ts","sourceRoot":"","sources":["../../../src/tools/tasks-by-project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBiB,CAAC;AAE3C,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/esm/tools/tasks-by-project.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { mapTask } from "./shared.js";
+const ArgsSchema = {
+    projectId: z
+        .string()
+        .min(1)
+        .describe("The ID of the project to get tasks for."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("The maximum number of tasks to return."),
+    cursor: z
+        .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)."),
+};
+const tasksListForProject = {
+    name: "tasks-list-for-project",
+    description: "Get tasks by project ID.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { projectId, limit, cursor } = args;
+        const { results, nextCursor } = await client.getTasks({
+            projectId,
+            limit,
+            cursor: cursor ?? null,
+        });
+        return {
+            tasks: results.map(mapTask),
+            nextCursor,
+        };
+    },
+};
+export { tasksListForProject };

package/dist/esm/tools/tasks-complete-multiple.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+declare const tasksCompleteMultiple: {
+    name: string;
+    description: string;
+    parameters: {
+        ids: z.ZodArray<z.ZodString, "many">;
+    };
+    execute(args: {
+        ids: string[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        success: boolean;
+        completed: string[];
+    }>;
+};
+export { tasksCompleteMultiple };
+//# sourceMappingURL=tasks-complete-multiple.d.ts.map

package/dist/esm/tools/tasks-complete-multiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-complete-multiple.d.ts","sourceRoot":"","sources":["../../../src/tools/tasks-complete-multiple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,QAAA,MAAM,qBAAqB;;;;;;;;;;;;CAgBe,CAAC;AAE3C,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/esm/tools/tasks-complete-multiple.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+const ArgsSchema = {
+    ids: z
+        .array(z.string().min(1))
+        .min(1)
+        .describe("The IDs of the tasks to complete."),
+};
+const tasksCompleteMultiple = {
+    name: "tasks-complete-multiple",
+    description: "Complete one or more tasks by their IDs.",
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const completed = [];
+        for (const id of args.ids) {
+            try {
+                await client.closeTask(id);
+                completed.push(id);
+            }
+            catch {
+                // Ignore errors for individual tasks, continue with others
+            }
+        }
+        return { success: true, completed };
+    },
+};
+export { tasksCompleteMultiple };