@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tools/manage-assignments.js

@@ -1,337 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { assignmentValidator, } from '../utils/assignment-validator.js';
-import { ToolNames } from '../utils/tool-names.js';
-import { userResolver } from '../utils/user-resolver.js';
-const { FIND_TASKS, FIND_PROJECT_COLLABORATORS, UPDATE_TASKS } = ToolNames;
-// Maximum tasks per operation to prevent abuse and timeouts
-const MAX_TASKS_PER_OPERATION = 50;
-const ArgsSchema = {
-    operation: z
-        .enum(['assign', 'unassign', 'reassign'])
-        .describe('The assignment operation to perform.'),
-    taskIds: z
-        .array(z.string())
-        .min(1)
-        .max(MAX_TASKS_PER_OPERATION)
-        .describe('The IDs of the tasks to operate on (max 50).'),
-    responsibleUser: z
-        .string()
-        .optional()
-        .describe('The user to assign tasks to. Can be user ID, name, or email. Required for assign and reassign operations.'),
-    fromAssigneeUser: z
-        .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: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('If true, validates operations without executing them.'),
-};
-const manageAssignments = {
-    name: ToolNames.MANAGE_ASSIGNMENTS,
-    description: 'Bulk assignment operations for multiple tasks. Supports assign, unassign, and reassign operations with atomic rollback on failures.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { operation, taskIds, responsibleUser, fromAssigneeUser, dryRun } = args;
-        // Validate required parameters based on operation
-        if ((operation === 'assign' || operation === 'reassign') && !responsibleUser) {
-            throw new Error(`${operation} operation requires responsibleUser parameter`);
-        }
-        // Fetch all tasks first to validate they exist and get project information
-        const tasks = await Promise.allSettled(taskIds.map(async (taskId) => {
-            try {
-                return await client.getTask(taskId);
-            }
-            catch (_error) {
-                throw new Error(`Task ${taskId} not found or not accessible`);
-            }
-        }));
-        const validTasks = [];
-        const taskErrors = [];
-        for (let i = 0; i < tasks.length; i++) {
-            const result = tasks[i];
-            if (result && result.status === 'fulfilled') {
-                validTasks.push(result.value);
-            }
-            else if (result && result.status === 'rejected') {
-                taskErrors.push({
-                    taskId: taskIds[i] || 'invalid-task-id',
-                    success: false,
-                    error: result.reason?.message || 'Task not accessible',
-                });
-            }
-            else {
-                taskErrors.push({
-                    taskId: taskIds[i] || 'invalid-task-id',
-                    success: false,
-                    error: 'Task not accessible',
-                });
-            }
-        }
-        if (validTasks.length === 0) {
-            const textContent = generateTextContent({
-                operation,
-                results: taskErrors,
-                dryRun,
-            });
-            return getToolOutput({
-                textContent,
-                structuredContent: {
-                    operation,
-                    results: taskErrors,
-                    totalRequested: taskIds.length,
-                    successful: 0,
-                    failed: taskErrors.length,
-                    dryRun,
-                },
-            });
-        }
-        // Pre-resolve fromAssigneeUser once for reassign operations
-        let resolvedFromUserId;
-        if (operation === 'reassign' && fromAssigneeUser) {
-            const fromUser = await userResolver.resolveUser(client, fromAssigneeUser);
-            resolvedFromUserId = fromUser?.userId || fromAssigneeUser;
-        }
-        // Build assignments for validation
-        const assignments = [];
-        for (const task of validTasks) {
-            // For reassign operations, check if we need to filter by current assignee
-            if (operation === 'reassign' && resolvedFromUserId) {
-                // Skip tasks not assigned to the specified user
-                if (task.responsibleUid !== resolvedFromUserId) {
-                    continue;
-                }
-            }
-            assignments.push({
-                taskId: task.id,
-                projectId: task.projectId,
-                responsibleUid: responsibleUser || '', // Will be validated appropriately
-            });
-        }
-        // Handle unassign operations (no validation needed for unassignment)
-        if (operation === 'unassign') {
-            if (dryRun) {
-                const results = validTasks.map((task) => ({
-                    taskId: task.id,
-                    success: true,
-                    originalAssigneeId: task.responsibleUid,
-                    newAssigneeId: null,
-                }));
-                const textContent = generateTextContent({
-                    operation,
-                    results,
-                    dryRun: true,
-                });
-                return getToolOutput({
-                    textContent,
-                    structuredContent: {
-                        operation,
-                        results,
-                        totalRequested: taskIds.length,
-                        successful: results.length,
-                        failed: taskErrors.length,
-                        dryRun: true,
-                    },
-                });
-            }
-            // Execute unassign operations
-            const unassignPromises = validTasks.map(async (task) => {
-                try {
-                    await client.updateTask(task.id, { assigneeId: null });
-                    return {
-                        taskId: task.id,
-                        success: true,
-                        originalAssigneeId: task.responsibleUid,
-                        newAssigneeId: null,
-                    };
-                }
-                catch (error) {
-                    return {
-                        taskId: task.id,
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Update failed',
-                        originalAssigneeId: task.responsibleUid,
-                    };
-                }
-            });
-            const unassignResults = await Promise.all(unassignPromises);
-            const allResults = [...unassignResults, ...taskErrors];
-            const textContent = generateTextContent({
-                operation,
-                results: allResults,
-                dryRun: false,
-            });
-            return getToolOutput({
-                textContent,
-                structuredContent: {
-                    operation,
-                    results: allResults,
-                    totalRequested: taskIds.length,
-                    successful: unassignResults.filter((r) => r.success).length,
-                    failed: allResults.filter((r) => !r.success).length,
-                    dryRun: false,
-                },
-            });
-        }
-        // Validate all assignments
-        const validationResults = await assignmentValidator.validateBulkAssignment(client, assignments);
-        // Process validation results
-        const validAssignments = [];
-        const validationErrors = [];
-        for (let i = 0; i < assignments.length; i++) {
-            const assignment = assignments[i];
-            const validation = validationResults[i];
-            if (assignment && validation && validation.isValid) {
-                validAssignments.push({ assignment, validation });
-            }
-            else if (assignment?.taskId) {
-                validationErrors.push({
-                    taskId: assignment.taskId,
-                    success: false,
-                    error: validation?.error?.message || 'Validation failed',
-                });
-            }
-        }
-        // Helper function to process assignments for both dry run and execution
-        async function processAssignments(assignments, execute) {
-            const filteredAssignments = assignments.filter((item) => item.assignment != null && item.validation != null);
-            if (!execute) {
-                // Dry run: just map to successful results
-                return filteredAssignments.map(({ assignment, validation }) => {
-                    const task = validTasks.find((t) => t.id === assignment.taskId);
-                    if (!assignment.taskId || !validation.resolvedUser?.userId) {
-                        throw new Error('Invalid assignment or validation data - this should not happen');
-                    }
-                    return {
-                        taskId: assignment.taskId,
-                        success: true,
-                        originalAssigneeId: task?.responsibleUid || null,
-                        newAssigneeId: validation.resolvedUser.userId,
-                    };
-                });
-            }
-            // Execute: perform actual updates
-            const executePromises = filteredAssignments.map(async ({ assignment, validation }) => {
-                const task = validTasks.find((t) => t.id === assignment.taskId);
-                if (!assignment.taskId || !validation.resolvedUser?.userId) {
-                    return {
-                        taskId: assignment.taskId || 'unknown-task',
-                        success: false,
-                        error: 'Invalid assignment data - missing task ID or resolved user',
-                        originalAssigneeId: task?.responsibleUid || null,
-                    };
-                }
-                try {
-                    await client.updateTask(assignment.taskId, {
-                        assigneeId: validation.resolvedUser.userId,
-                    });
-                    return {
-                        taskId: assignment.taskId,
-                        success: true,
-                        originalAssigneeId: task?.responsibleUid || null,
-                        newAssigneeId: validation.resolvedUser.userId,
-                    };
-                }
-                catch (error) {
-                    return {
-                        taskId: assignment.taskId,
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Update failed',
-                        originalAssigneeId: task?.responsibleUid || null,
-                    };
-                }
-            });
-            return Promise.all(executePromises);
-        }
-        // Handle assign/reassign operations - validate then execute
-        const assignmentResults = await processAssignments(validAssignments, !dryRun);
-        const allResults = [...assignmentResults, ...validationErrors, ...taskErrors];
-        const textContent = generateTextContent({
-            operation,
-            results: allResults,
-            dryRun,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                operation,
-                results: allResults,
-                totalRequested: taskIds.length,
-                successful: assignmentResults.filter((r) => r.success).length,
-                failed: allResults.filter((r) => !r.success).length,
-                dryRun,
-            },
-        });
-    },
-};
-function generateTextContent({ operation, results, dryRun, }) {
-    const successful = results.filter((r) => r.success);
-    const failed = results.filter((r) => !r.success);
-    const operationVerb = dryRun ? 'would be' : 'were';
-    const operationPastTense = {
-        assign: 'assigned',
-        unassign: 'unassigned',
-        reassign: 'reassigned',
-    }[operation];
-    let summary = `**${dryRun ? 'Dry Run: ' : ''}Bulk ${operation} operation**\n\n`;
-    if (successful.length > 0) {
-        summary += `**${successful.length} task${successful.length === 1 ? '' : 's'} ${operationVerb} successfully ${operationPastTense}**\n`;
-        // Show first few successful operations
-        const preview = successful.slice(0, 5);
-        for (const result of preview) {
-            let changeDesc = '';
-            if (operation === 'unassign') {
-                changeDesc = ' (unassigned from previous assignee)';
-            }
-            else if (result.newAssigneeId) {
-                changeDesc = ` → ${result.newAssigneeId}`;
-            }
-            summary += `  • Task ${result.taskId}${changeDesc}\n`;
-        }
-        if (successful.length > 5) {
-            summary += `  • ... and ${successful.length - 5} more\n`;
-        }
-        summary += '\n';
-    }
-    if (failed.length > 0) {
-        summary += `**${failed.length} task${failed.length === 1 ? '' : 's'} failed**\n`;
-        // Show first few failures with reasons
-        const preview = failed.slice(0, 5);
-        for (const result of preview) {
-            summary += `  • Task ${result.taskId}: ${result.error}\n`;
-        }
-        if (failed.length > 5) {
-            summary += `  • ... and ${failed.length - 5} more failures\n`;
-        }
-        summary += '\n';
-    }
-    // Add operational info
-    if (!dryRun && successful.length > 0) {
-        summary += '**Next steps:**\n';
-        summary += `• Use ${FIND_TASKS} with responsibleUser to see ${operation === 'unassign' ? 'unassigned' : 'newly assigned'} tasks\n`;
-        summary += `• Use ${UPDATE_TASKS} for individual assignment changes\n`;
-        if (failed.length > 0) {
-            summary += `• Check failed tasks and use ${FIND_PROJECT_COLLABORATORS} to verify collaborator access\n`;
-        }
-    }
-    else if (dryRun) {
-        summary += '**To execute:**\n';
-        summary += '• Remove dryRun parameter and run again to execute changes\n';
-        if (successful.length > 0) {
-            summary += `• ${successful.length} task${successful.length === 1 ? '' : 's'} ready for ${operation} operation\n`;
-        }
-        if (failed.length > 0) {
-            summary += `• Fix ${failed.length} validation error${failed.length === 1 ? '' : 's'} before executing\n`;
-        }
-    }
-    else if (successful.length === 0) {
-        summary += '**Suggestions:**\n';
-        summary += `• Use ${FIND_PROJECT_COLLABORATORS} to find valid assignees\n`;
-        summary += '• Check task IDs and assignee permissions\n';
-        summary += '• Use dryRun=true to validate before executing\n';
-    }
-    return summary;
-}
-export { manageAssignments };

package/dist/tools/search.js

@@ -1,65 +0,0 @@
-import { getProjectUrl, getTaskUrl } from '@doist/todoist-api-typescript';
-import { z } from 'zod';
-import { getErrorOutput } from '../mcp-helpers.js';
-import { getTasksByFilter } from '../tool-helpers.js';
-import { ApiLimits } from '../utils/constants.js';
-import { ToolNames } from '../utils/tool-names.js';
-const ArgsSchema = {
-    query: z.string().min(1).describe('The search query string to find tasks and projects.'),
-};
-/**
- * OpenAI MCP search tool - returns a list of relevant search results from Todoist.
- *
- * This tool follows the OpenAI MCP search tool specification:
- * @see https://platform.openai.com/docs/mcp#search-tool
- */
-const search = {
-    name: ToolNames.SEARCH,
-    description: 'Search across tasks and projects in Todoist. Returns a list of relevant results with IDs, titles, and URLs.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        try {
-            const { query } = args;
-            // Search both tasks and projects in parallel
-            // Use TASKS_MAX for search since this tool doesn't support pagination
-            const [tasksResult, projectsResponse] = await Promise.all([
-                getTasksByFilter({
-                    client,
-                    query: `search: ${query}`,
-                    limit: ApiLimits.TASKS_MAX,
-                    cursor: undefined,
-                }),
-                client.getProjects({ limit: ApiLimits.PROJECTS_MAX }),
-            ]);
-            // Filter projects by search query (case-insensitive)
-            const searchLower = query.toLowerCase();
-            const matchingProjects = projectsResponse.results.filter((project) => project.name.toLowerCase().includes(searchLower));
-            // Build results array
-            const results = [];
-            // Add task results with composite IDs
-            for (const task of tasksResult.tasks) {
-                results.push({
-                    id: `task:${task.id}`,
-                    title: task.content,
-                    url: getTaskUrl(task.id),
-                });
-            }
-            // Add project results with composite IDs
-            for (const project of matchingProjects) {
-                results.push({
-                    id: `project:${project.id}`,
-                    title: project.name,
-                    url: getProjectUrl(project.id),
-                });
-            }
-            // Return as JSON-encoded string in a text content item (OpenAI MCP spec)
-            const jsonText = JSON.stringify({ results });
-            return { content: [{ type: 'text', text: jsonText }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'An unknown error occurred';
-            return getErrorOutput(message);
-        }
-    },
-};
-export { search };

package/dist/tools/update-comments.js

@@ -1,82 +0,0 @@
-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_COMMENTS, DELETE_OBJECT } = ToolNames;
-const CommentUpdateSchema = z.object({
-    id: z.string().min(1).describe('The ID of the comment to update.'),
-    content: z.string().min(1).describe('The new content for the comment.'),
-});
-const ArgsSchema = {
-    comments: z.array(CommentUpdateSchema).min(1).describe('The comments to update.'),
-};
-const updateComments = {
-    name: ToolNames.UPDATE_COMMENTS,
-    description: 'Update multiple existing comments with new content.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { comments } = args;
-        const updateCommentPromises = comments.map(async (comment) => {
-            return await client.updateComment(comment.id, { content: comment.content });
-        });
-        const updatedComments = await Promise.all(updateCommentPromises);
-        const textContent = generateTextContent({
-            comments: updatedComments,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                comments: updatedComments,
-                totalCount: updatedComments.length,
-                updatedCommentIds: updatedComments.map((comment) => comment.id),
-                appliedOperations: {
-                    updateCount: updatedComments.length,
-                },
-            },
-        });
-    },
-};
-function generateNextSteps(comments) {
-    const nextSteps = [];
-    // Early return for empty comments
-    if (comments.length === 0) {
-        return nextSteps;
-    }
-    // Multiple comments case
-    if (comments.length > 1) {
-        nextSteps.push(`Use ${FIND_COMMENTS} to view comments by task or project`);
-        nextSteps.push(`Use ${DELETE_OBJECT} with type=comment to remove comments`);
-        return nextSteps;
-    }
-    // Single comment case
-    const comment = comments[0];
-    if (!comment)
-        return nextSteps;
-    if (comment.taskId) {
-        nextSteps.push(`Use ${FIND_COMMENTS} with taskId=${comment.taskId} to see all task comments`);
-    }
-    else if (comment.projectId) {
-        nextSteps.push(`Use ${FIND_COMMENTS} with projectId=${comment.projectId} to see all project comments`);
-    }
-    nextSteps.push(`Use ${DELETE_OBJECT} with type=comment id=${comment.id} to remove comment`);
-    return nextSteps;
-}
-function generateTextContent({ comments }) {
-    // Group comments by entity type and count
-    const taskComments = comments.filter((c) => c.taskId).length;
-    const projectComments = comments.filter((c) => c.projectId).length;
-    const parts = [];
-    if (taskComments > 0) {
-        const commentsLabel = taskComments > 1 ? 'comments' : 'comment';
-        parts.push(`${taskComments} task ${commentsLabel}`);
-    }
-    if (projectComments > 0) {
-        const commentsLabel = projectComments > 1 ? 'comments' : 'comment';
-        parts.push(`${projectComments} project ${commentsLabel}`);
-    }
-    const summary = parts.length > 0 ? `Updated ${parts.join(' and ')}` : 'No comments updated';
-    const nextSteps = generateNextSteps(comments);
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-export { updateComments };

package/dist/tools/update-projects.js

@@ -1,84 +0,0 @@
-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, FIND_TASKS, GET_OVERVIEW } = ToolNames;
-const ProjectUpdateSchema = z.object({
-    id: z.string().min(1).describe('The ID of the project to update.'),
-    name: z.string().min(1).optional().describe('The new name of the project.'),
-    isFavorite: z.boolean().optional().describe('Whether the project is a favorite.'),
-    viewStyle: z.enum(['list', 'board', 'calendar']).optional().describe('The project view style.'),
-});
-const ArgsSchema = {
-    projects: z.array(ProjectUpdateSchema).min(1).describe('The projects to update.'),
-};
-const updateProjects = {
-    name: ToolNames.UPDATE_PROJECTS,
-    description: 'Update multiple existing projects with new values.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { projects } = args;
-        const updateProjectsPromises = projects.map(async (project) => {
-            if (!hasUpdatesToMake(project)) {
-                return undefined;
-            }
-            const { id, ...updateArgs } = project;
-            return await client.updateProject(id, updateArgs);
-        });
-        const updatedProjects = (await Promise.all(updateProjectsPromises)).filter((project) => project !== undefined);
-        const textContent = generateTextContent({
-            projects: updatedProjects,
-            args,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                projects: updatedProjects,
-                totalCount: updatedProjects.length,
-                updatedProjectIds: updatedProjects.map((project) => project.id),
-                appliedOperations: {
-                    updateCount: updatedProjects.length,
-                    skippedCount: projects.length - updatedProjects.length,
-                },
-            },
-        });
-    },
-};
-function generateTextContent({ projects, args, }) {
-    const totalRequested = args.projects.length;
-    const actuallyUpdated = projects.length;
-    const skipped = totalRequested - actuallyUpdated;
-    const count = projects.length;
-    const projectList = projects.map((project) => `• ${project.name} (id=${project.id})`).join('\n');
-    let summary = `Updated ${count} project${count === 1 ? '' : 's'}`;
-    if (skipped > 0) {
-        summary += ` (${skipped} skipped - no changes)`;
-    }
-    if (count > 0) {
-        summary += `:\n${projectList}`;
-    }
-    // Context-aware next steps for updated projects
-    const nextSteps = [];
-    if (projects.length > 0) {
-        if (count === 1) {
-            const project = projects[0];
-            if (project) {
-                nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${project.id} to see project structure`);
-                nextSteps.push(`Use ${FIND_TASKS} with projectId=${project.id} to review existing tasks`);
-            }
-        }
-        else {
-            nextSteps.push(`Use ${FIND_PROJECTS} to see all projects with updated names`);
-            nextSteps.push(`Use ${GET_OVERVIEW} to see updated project hierarchy`);
-        }
-    }
-    else {
-        nextSteps.push(`Use ${FIND_PROJECTS} to see current projects`);
-    }
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-function hasUpdatesToMake({ id, ...otherUpdateArgs }) {
-    return Object.keys(otherUpdateArgs).length > 0;
-}
-export { updateProjects };

package/dist/tools/update-sections.js

@@ -1,70 +0,0 @@
-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_TASKS, GET_OVERVIEW, FIND_SECTIONS } = ToolNames;
-const SectionUpdateSchema = z.object({
-    id: z.string().min(1).describe('The ID of the section to update.'),
-    name: z.string().min(1).describe('The new name of the section.'),
-});
-const ArgsSchema = {
-    sections: z.array(SectionUpdateSchema).min(1).describe('The sections to update.'),
-};
-const updateSections = {
-    name: ToolNames.UPDATE_SECTIONS,
-    description: 'Update multiple existing sections with new values.',
-    parameters: ArgsSchema,
-    async execute({ sections }, client) {
-        const updatedSections = await Promise.all(sections.map((section) => client.updateSection(section.id, { name: section.name })));
-        const textContent = generateTextContent({
-            sections: updatedSections,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                sections: updatedSections,
-                totalCount: updatedSections.length,
-                updatedSectionIds: updatedSections.map((section) => section.id),
-            },
-        });
-    },
-};
-function generateNextSteps(sections) {
-    // Handle empty sections first (early return)
-    if (sections.length === 0) {
-        return [`Use ${FIND_SECTIONS} to see current sections`];
-    }
-    // Handle single section case
-    if (sections.length === 1) {
-        const section = sections[0];
-        if (!section)
-            return [];
-        return [
-            `Use ${FIND_TASKS} with sectionId=${section.id} to see existing tasks`,
-            `Use ${GET_OVERVIEW} with projectId=${section.projectId} to see project structure`,
-            'Consider updating task descriptions if section purpose changed',
-        ];
-    }
-    // Handle multiple sections case
-    const projectIds = [...new Set(sections.map((s) => s.projectId))];
-    const steps = [`Use ${FIND_SECTIONS} to see all sections with updated names`];
-    if (projectIds.length === 1) {
-        steps.push(`Use ${GET_OVERVIEW} with projectId=${projectIds[0]} to see updated project structure`);
-    }
-    else {
-        steps.push(`Use ${GET_OVERVIEW} to see updated project structures`);
-    }
-    steps.push('Consider updating task descriptions if section purposes changed');
-    return steps;
-}
-function generateTextContent({ sections }) {
-    const count = sections.length;
-    const sectionList = sections
-        .map((section) => `• ${section.name} (id=${section.id}, projectId=${section.projectId})`)
-        .join('\n');
-    const summary = `Updated ${count} section${count === 1 ? '' : 's'}:\n${sectionList}`;
-    const nextSteps = generateNextSteps(sections);
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-export { updateSections };