@doist/todoist-ai 2.2.2 → 3.0.0

package/dist/tools/{tasks-add-multiple.d.ts → add-tasks.d.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-declare const tasksAddMultiple: {
-    name: string;
+declare const addTasks: {
+    name: "add-tasks";
     description: string;
     parameters: {
         projectId: z.ZodOptional<z.ZodString>;
@@ -38,18 +38,38 @@ declare const tasksAddMultiple: {
         projectId?: 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[];
-        duration: string | null;
-    }[]>;
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            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[];
+                duration: string | null;
+            }[];
+            totalCount: number;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
 };
-export { tasksAddMultiple };
-//# sourceMappingURL=tasks-add-multiple.d.ts.map
+export { addTasks };
+//# sourceMappingURL=add-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/add-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgCvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgD4B,CAAA;AA8B1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/{tasks-add-multiple.js → add-tasks.js}

@@ -1,6 +1,9 @@
 import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
 import { mapTask } from '../tool-helpers.js';
 import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
+import { generateTaskNextSteps, getDateString, summarizeTaskOperation, } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.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.'),
@@ -17,8 +20,8 @@ const ArgsSchema = {
     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',
+const addTasks = {
+    name: ToolNames.ADD_TASKS,
     description: 'Add one or more tasks to a project, section, or parent.',
     parameters: ArgsSchema,
     async execute(args, client) {
@@ -46,7 +49,39 @@ const tasksAddMultiple = {
             }
             newTasks.push(await client.addTask(taskArgs));
         }
-        return newTasks.map(mapTask);
+        const mappedTasks = newTasks.map(mapTask);
+        const textContent = generateTextContent({
+            tasks: mappedTasks,
+            args,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                tasks: mappedTasks,
+                totalCount: mappedTasks.length,
+            },
+        });
     },
 };
-export { tasksAddMultiple };
+function generateTextContent({ tasks, args, }) {
+    // Get context for smart next steps
+    const todayStr = getDateString();
+    const hasToday = tasks.some((task) => task.dueDate === todayStr);
+    // Generate context description without API calls
+    let projectContext = '';
+    if (args.projectId) {
+        projectContext = 'to specified project';
+    }
+    else if (args.sectionId) {
+        projectContext = 'to specified section';
+    }
+    else if (args.parentId) {
+        projectContext = 'as subtasks';
+    }
+    return summarizeTaskOperation('Added', tasks, {
+        context: projectContext,
+        nextSteps: generateTaskNextSteps('added', tasks, { hasToday }),
+        showDetails: true,
+    });
+}
+export { addTasks };

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+declare const completeTasks: {
+    name: "complete-tasks";
+    description: string;
+    parameters: {
+        ids: z.ZodArray<z.ZodString, "many">;
+    };
+    execute(args: {
+        ids: string[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            completed: string[];
+            failures: {
+                item: string;
+                error: string;
+                code?: string;
+            }[];
+            totalRequested: number;
+            successCount: number;
+            failureCount: number;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { completeTasks };
+//# sourceMappingURL=complete-tasks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complete-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/complete-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;sBAMmB,MAAM;uBAAS,MAAM;uBAAS,MAAM;;;;;;;;;;;;;;;;;;CAgChC,CAAA;AAsC1C,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/tools/complete-tasks.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { summarizeBatch } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    ids: z.array(z.string().min(1)).min(1).describe('The IDs of the tasks to complete.'),
+};
+const completeTasks = {
+    name: ToolNames.COMPLETE_TASKS,
+    description: 'Complete one or more tasks by their IDs.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const completed = [];
+        const failures = [];
+        for (const id of args.ids) {
+            try {
+                await client.closeTask(id);
+                completed.push(id);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                failures.push({
+                    item: id,
+                    error: errorMessage,
+                });
+            }
+        }
+        const textContent = generateTextContent({
+            completed,
+            failures,
+            args,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                completed,
+                failures,
+                totalRequested: args.ids.length,
+                successCount: completed.length,
+                failureCount: failures.length,
+            },
+        });
+    },
+};
+function generateNextSteps(completed, failures) {
+    if (completed > 0) {
+        const moveResult = failures === 0
+            ? "Use find-tasks-by-date('overdue') to tackle remaining overdue items."
+            : 'Review failed completions and retry if needed.';
+        return [moveResult];
+    }
+    if (failures > 0) {
+        return ['Check task IDs and permissions, then retry.'];
+    }
+    return ['No tasks were completed.'];
+}
+function generateTextContent({ completed, failures, args, }) {
+    const nextSteps = generateNextSteps(completed.length, failures.length);
+    return summarizeBatch({
+        action: 'Completed tasks',
+        success: completed.length,
+        total: args.ids.length,
+        successItems: completed,
+        failures,
+        nextSteps,
+    });
+}
+export { completeTasks };

package/dist/tools/delete-object.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+declare const deleteObject: {
+    name: "delete-object";
+    description: string;
+    parameters: {
+        type: z.ZodEnum<["project", "section", "task"]>;
+        id: z.ZodString;
+    };
+    execute(args: {
+        type: "task" | "project" | "section";
+        id: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            deletedEntity: {
+                type: "task" | "project" | "section";
+                id: string;
+            };
+            success: boolean;
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { deleteObject };
+//# sourceMappingURL=delete-object.d.ts.map

package/dist/tools/delete-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-object.d.ts","sourceRoot":"","sources":["../../src/tools/delete-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCwB,CAAA;AAyC1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/delete-object.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { formatNextSteps } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_PROJECTS, GET_OVERVIEW, FIND_SECTIONS, FIND_TASKS, FIND_TASKS_BY_DATE } = ToolNames;
+const ArgsSchema = {
+    type: z.enum(['project', 'section', 'task']).describe('The type of entity to delete.'),
+    id: z.string().min(1).describe('The ID of the entity to delete.'),
+};
+const deleteObject = {
+    name: ToolNames.DELETE_OBJECT,
+    description: 'Delete a project, section, or task by its ID.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        switch (args.type) {
+            case 'project':
+                await client.deleteProject(args.id);
+                break;
+            case 'section':
+                await client.deleteSection(args.id);
+                break;
+            case 'task':
+                await client.deleteTask(args.id);
+                break;
+        }
+        const textContent = generateTextContent({
+            type: args.type,
+            id: args.id,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                deletedEntity: {
+                    type: args.type,
+                    id: args.id,
+                },
+                success: true,
+            },
+        });
+    },
+};
+function generateTextContent({ type, id, }) {
+    const summary = `Deleted ${type}: id=${id}`;
+    // Recovery-focused next steps based on what was deleted
+    const nextSteps = [];
+    switch (type) {
+        case 'project':
+            // Help user understand impact and navigate remaining work
+            nextSteps.push(`Use ${FIND_PROJECTS} to see remaining projects`);
+            nextSteps.push('Note: All tasks and sections in this project were also deleted');
+            nextSteps.push(`Use ${GET_OVERVIEW} to review your updated project structure`);
+            break;
+        case 'section':
+            // Guide user to reorganize remaining sections and tasks
+            nextSteps.push(`Use ${FIND_SECTIONS} to see remaining sections in the project`);
+            nextSteps.push('Note: Tasks in this section were also deleted');
+            nextSteps.push(`Use ${FIND_TASKS} with projectId to see unorganized tasks`);
+            break;
+        case 'task':
+            // Help user stay focused on remaining work
+            nextSteps.push(`Use ${FIND_TASKS_BY_DATE} to see remaining tasks for today`);
+            nextSteps.push(`Use ${GET_OVERVIEW} to check if this affects any dependent tasks`);
+            nextSteps.push('Note: Any subtasks of this task were also deleted');
+            break;
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { deleteObject };

package/dist/tools/find-completed-tasks.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+declare const findCompletedTasks: {
+    name: "find-completed-tasks";
+    description: string;
+    parameters: {
+        getBy: z.ZodDefault<z.ZodEnum<["completion", "due"]>>;
+        since: z.ZodString;
+        until: z.ZodString;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        sectionId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        getBy: "completion" | "due";
+        since: string;
+        until: string;
+        parentId?: string | undefined;
+        workspaceId?: string | undefined;
+        projectId?: string | undefined;
+        sectionId?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            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[];
+                duration: string | null;
+            }[];
+            nextCursor: string | null;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                limit: number;
+                getBy: "completion" | "due";
+                since: string;
+                until: string;
+                parentId?: string | undefined;
+                workspaceId?: string | undefined;
+                projectId?: string | undefined;
+                sectionId?: string | undefined;
+                cursor?: string | undefined;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { findCompletedTasks };
+//# sourceMappingURL=find-completed-tasks.d.ts.map

package/dist/tools/find-completed-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-completed-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-completed-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA8CvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BkB,CAAA;AA2D1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/tools/find-completed-tasks.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { mapTask } from '../tool-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { previewTasks, summarizeList } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
+const ArgsSchema = {
+    getBy: z
+        .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: z
+        .string()
+        .date()
+        .regex(/^\d{4}-\d{2}-\d{2}$/)
+        .describe('The start date to get the tasks for. Format: YYYY-MM-DD.'),
+    until: z
+        .string()
+        .date()
+        .regex(/^\d{4}-\d{2}-\d{2}$/)
+        .describe('The start date to get the tasks for. Format: YYYY-MM-DD.'),
+    workspaceId: z.string().optional().describe('The ID of the workspace to get the tasks for.'),
+    projectId: z.string().optional().describe('The ID of the project to get the tasks for.'),
+    sectionId: z.string().optional().describe('The ID of the section to get the tasks for.'),
+    parentId: z.string().optional().describe('The ID of the parent task to get the tasks for.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(ApiLimits.COMPLETED_TASKS_MAX)
+        .default(ApiLimits.COMPLETED_TASKS_DEFAULT)
+        .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 findCompletedTasks = {
+    name: ToolNames.FIND_COMPLETED_TASKS,
+    description: 'Get completed tasks.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { getBy, ...rest } = args;
+        const { items, nextCursor } = getBy === 'completion'
+            ? await client.getCompletedTasksByCompletionDate(rest)
+            : await client.getCompletedTasksByDueDate(rest);
+        const mappedTasks = items.map(mapTask);
+        const textContent = generateTextContent({
+            tasks: mappedTasks,
+            args,
+            nextCursor,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                tasks: mappedTasks,
+                nextCursor,
+                totalCount: mappedTasks.length,
+                hasMore: Boolean(nextCursor),
+                appliedFilters: args,
+            },
+        });
+    },
+};
+function generateTextContent({ tasks, args, nextCursor, }) {
+    // Generate subject description
+    const getByText = args.getBy === 'completion' ? 'completed' : 'due';
+    const subject = `Completed tasks (by ${getByText} date)`;
+    // Generate filter hints
+    const filterHints = [];
+    filterHints.push(`${getByText} date: ${args.since} to ${args.until}`);
+    if (args.projectId)
+        filterHints.push(`project: ${args.projectId}`);
+    if (args.sectionId)
+        filterHints.push(`section: ${args.sectionId}`);
+    if (args.parentId)
+        filterHints.push(`parent: ${args.parentId}`);
+    if (args.workspaceId)
+        filterHints.push(`workspace: ${args.workspaceId}`);
+    // Generate helpful suggestions for empty results
+    const zeroReasonHints = [];
+    if (tasks.length === 0) {
+        zeroReasonHints.push('No tasks completed in this date range');
+        zeroReasonHints.push('Try expanding the date range');
+        if (args.projectId || args.sectionId || args.parentId) {
+            zeroReasonHints.push('Try removing project/section/parent filters');
+        }
+        if (args.getBy === 'due') {
+            zeroReasonHints.push('Try switching to "completion" date instead');
+        }
+    }
+    // Generate contextual next steps
+    const nextSteps = [];
+    if (tasks.length > 0) {
+        nextSteps.push(`Use ${FIND_TASKS_BY_DATE} for active tasks or ${GET_OVERVIEW} for current productivity.`);
+        if (tasks.some((task) => task.recurring)) {
+            nextSteps.push('Recurring tasks will automatically create new instances.');
+        }
+    }
+    return summarizeList({
+        subject,
+        count: tasks.length,
+        limit: args.limit,
+        nextCursor: nextCursor ?? undefined,
+        filterHints,
+        previewLines: previewTasks(tasks),
+        zeroReasonHints,
+        nextSteps,
+    });
+}
+export { findCompletedTasks };

package/dist/tools/find-projects.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+declare const findProjects: {
+    name: "find-projects";
+    description: string;
+    parameters: {
+        search: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        limit: number;
+        cursor?: string | undefined;
+        search?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            projects: {
+                id: string;
+                name: string;
+                color: string;
+                isFavorite: boolean;
+                isShared: boolean;
+                parentId: string | null;
+                inboxProject: boolean;
+                viewStyle: string;
+            }[];
+            nextCursor: string | null;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                limit: number;
+                cursor?: string | undefined;
+                search?: string | undefined;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { findProjects };
+//# sourceMappingURL=find-projects.d.ts.map

package/dist/tools/find-projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-projects.d.ts","sourceRoot":"","sources":["../../src/tools/find-projects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgCvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BwB,CAAA;AA8D1C,OAAO,EAAE,YAAY,EAAE,CAAA"}