@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tools/update-tasks.js

@@ -1,170 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { createMoveTaskArgs, mapTask } from '../tool-helpers.js';
-import { assignmentValidator } from '../utils/assignment-validator.js';
-import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
-import { convertPriorityToNumber, PrioritySchema } from '../utils/priorities.js';
-import { summarizeTaskOperation } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
-const TasksUpdateSchema = z.object({
-    id: z.string().min(1).describe('The ID of the task to update.'),
-    content: z
-        .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: z
-        .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: z.string().optional().describe('The new project ID for the task.'),
-    sectionId: z.string().optional().describe('The new section ID for the task.'),
-    parentId: z.string().optional().describe('The new parent task ID (for subtasks).'),
-    order: z.number().optional().describe('The new order of the task within its parent/section.'),
-    priority: PrioritySchema.optional().describe('The new priority of the task: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default).'),
-    dueString: z
-        .string()
-        .optional()
-        .describe("The new due date for the task, in natural language (e.g., 'tomorrow at 5pm')."),
-    deadlineDate: z
-        .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: z
-        .string()
-        .optional()
-        .describe('The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'),
-    responsibleUser: z
-        .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: z
-        .array(z.string())
-        .optional()
-        .describe('The new labels for the task. Replaces all existing labels.'),
-});
-const ArgsSchema = {
-    tasks: z.array(TasksUpdateSchema).min(1).describe('The tasks to update.'),
-};
-const updateTasks = {
-    name: ToolNames.UPDATE_TASKS,
-    description: 'Update existing tasks including content, dates, priorities, and assignments.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { tasks } = args;
-        const updateTasksPromises = tasks.map(async (task) => {
-            if (!hasUpdatesToMake(task)) {
-                return undefined;
-            }
-            const { id, projectId, sectionId, parentId, duration: durationStr, responsibleUser, priority, labels, deadlineDate, ...otherUpdateArgs } = task;
-            let updateArgs = {
-                ...otherUpdateArgs,
-                ...(labels !== undefined && { labels }),
-            };
-            // Handle priority conversion if provided
-            if (priority) {
-                updateArgs.priority = convertPriorityToNumber(priority);
-            }
-            // Handle deadline changes if provided
-            if (deadlineDate !== undefined) {
-                if (deadlineDate === null || deadlineDate === 'remove') {
-                    // Remove deadline - support both legacy null and new "remove" string
-                    updateArgs = { ...updateArgs, deadlineDate: null };
-                }
-                else {
-                    // Set new deadline
-                    updateArgs = { ...updateArgs, deadlineDate };
-                }
-            }
-            // Parse duration if provided
-            if (durationStr) {
-                try {
-                    const { minutes } = parseDuration(durationStr);
-                    updateArgs = {
-                        ...updateArgs,
-                        duration: minutes,
-                        durationUnit: 'minute',
-                    };
-                }
-                catch (error) {
-                    if (error instanceof DurationParseError) {
-                        throw new Error(`Task ${id}: ${error.message}`);
-                    }
-                    throw error;
-                }
-            }
-            // Handle assignment changes if provided
-            if (responsibleUser !== undefined) {
-                if (responsibleUser === null || responsibleUser === 'unassign') {
-                    // Unassign task - no validation needed
-                    updateArgs = { ...updateArgs, assigneeId: null };
-                }
-                else {
-                    // Validate assignment using comprehensive validator
-                    const validation = await assignmentValidator.validateTaskUpdateAssignment(client, id, responsibleUser);
-                    if (!validation.isValid) {
-                        const errorMsg = validation.error?.message || 'Assignment validation failed';
-                        const suggestions = validation.error?.suggestions?.join('. ') || '';
-                        throw new Error(`Task ${id}: ${errorMsg}${suggestions ? `. ${suggestions}` : ''}`);
-                    }
-                    // Use the validated assignee ID
-                    updateArgs = { ...updateArgs, assigneeId: validation.resolvedUser?.userId };
-                }
-            }
-            // If no move parameters are provided, use updateTask without moveTask
-            if (!projectId && !sectionId && !parentId) {
-                return await client.updateTask(id, updateArgs);
-            }
-            const moveArgs = createMoveTaskArgs(id, projectId, sectionId, parentId);
-            const movedTask = await client.moveTask(id, moveArgs);
-            if (Object.keys(updateArgs).length > 0) {
-                return await client.updateTask(id, updateArgs);
-            }
-            return movedTask;
-        });
-        const updatedTasks = (await Promise.all(updateTasksPromises)).filter((task) => task !== undefined);
-        const mappedTasks = updatedTasks.map(mapTask);
-        const textContent = generateTextContent({
-            tasks: mappedTasks,
-            args,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                tasks: mappedTasks,
-                totalCount: mappedTasks.length,
-                updatedTaskIds: updatedTasks.map((task) => task.id),
-                appliedOperations: {
-                    updateCount: mappedTasks.length,
-                    skippedCount: tasks.length - mappedTasks.length,
-                },
-            },
-        });
-    },
-};
-function generateTextContent({ tasks, args, }) {
-    const totalRequested = args.tasks.length;
-    const actuallyUpdated = tasks.length;
-    const skipped = totalRequested - actuallyUpdated;
-    let context = '';
-    if (skipped > 0) {
-        context = ` (${skipped} skipped - no changes)`;
-    }
-    const nextSteps = [];
-    if (tasks.length > 0) {
-        nextSteps.push(`Use ${FIND_TASKS_BY_DATE} to see your updated schedule`);
-        nextSteps.push(`Use ${GET_OVERVIEW} to see updated project organization`);
-    }
-    else {
-        nextSteps.push(`Use ${FIND_TASKS_BY_DATE} to see current tasks`);
-    }
-    return summarizeTaskOperation('Updated', tasks, {
-        context,
-        nextSteps,
-        showDetails: tasks.length <= 5,
-    });
-}
-function hasUpdatesToMake({ id, ...otherUpdateArgs }) {
-    return Object.keys(otherUpdateArgs).length > 0;
-}
-export { updateTasks };

package/dist/tools/user-info.js

@@ -1,142 +0,0 @@
-import { getToolOutput } from '../mcp-helpers.js';
-import { ToolNames } from '../utils/tool-names.js';
-const ArgsSchema = {};
-function getUserPlan(user) {
-    if (user.businessAccountId) {
-        return 'Todoist Business';
-    }
-    if (user.isPremium) {
-        return 'Todoist Pro';
-    }
-    return 'Todoist Free';
-}
-// Helper functions for date and time calculations
-function getWeekStartDate(date, startDay) {
-    const currentDay = date.getDay() || 7; // Convert Sunday (0) to 7 for ISO format
-    const daysFromStart = (currentDay - startDay + 7) % 7;
-    const weekStart = new Date(date);
-    weekStart.setDate(date.getDate() - daysFromStart);
-    return weekStart;
-}
-function getWeekEndDate(weekStart) {
-    const weekEnd = new Date(weekStart);
-    weekEnd.setDate(weekStart.getDate() + 6);
-    return weekEnd;
-}
-function getWeekNumber(date) {
-    const firstDayOfYear = new Date(date.getFullYear(), 0, 1);
-    const pastDaysOfYear = (date.getTime() - firstDayOfYear.getTime()) / 86400000;
-    return Math.ceil((pastDaysOfYear + firstDayOfYear.getDay() + 1) / 7);
-}
-function getDayName(dayNumber) {
-    const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-    // Convert ISO day number (1=Monday, 7=Sunday) to array index (0=Sunday, 6=Saturday)
-    const index = dayNumber === 7 ? 0 : dayNumber;
-    return days[index] ?? 'Unknown';
-}
-function formatDate(date) {
-    return date.toISOString().split('T')[0] ?? '';
-}
-function isValidTimezone(timezone) {
-    try {
-        // Test if the timezone is valid by attempting to format a date with it
-        new Intl.DateTimeFormat('en-US', { timeZone: timezone });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function getSafeTimezone(timezone) {
-    return isValidTimezone(timezone) ? timezone : 'UTC';
-}
-function formatLocalTime(date, timezone) {
-    const safeTimezone = getSafeTimezone(timezone);
-    return date.toLocaleString('en-US', {
-        timeZone: safeTimezone,
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-        hour12: false,
-    });
-}
-async function generateUserInfo(client) {
-    // Get user information from Todoist API
-    const user = await client.getUser();
-    // Parse timezone from user data and ensure it's valid
-    const rawTimezone = user.tzInfo?.timezone ?? 'UTC';
-    const timezone = getSafeTimezone(rawTimezone);
-    // Get current time in user's timezone
-    const now = new Date();
-    const localTime = formatLocalTime(now, timezone);
-    // Calculate week information based on user's start day
-    const startDay = user.startDay ?? 1; // Default to Monday if not set
-    const startDayName = getDayName(startDay);
-    // Determine user's plan
-    const plan = getUserPlan(user);
-    // Create a date object in user's timezone for accurate week calculations
-    const userDate = new Date(now.toLocaleString('en-US', { timeZone: timezone }));
-    const weekStart = getWeekStartDate(userDate, startDay);
-    const weekEnd = getWeekEndDate(weekStart);
-    const weekNumber = getWeekNumber(userDate);
-    // Generate markdown text content
-    const lines = [
-        '# User Information',
-        '',
-        `**User ID:** ${user.id}`,
-        `**Full Name:** ${user.fullName}`,
-        `**Email:** ${user.email}`,
-        `**Timezone:** ${timezone}`,
-        `**Current Local Time:** ${localTime}`,
-        '',
-        '## Week Settings',
-        `**Week Start Day:** ${startDayName} (${startDay})`,
-        `**Current Week:** Week ${weekNumber}`,
-        `**Week Start Date:** ${formatDate(weekStart)}`,
-        `**Week End Date:** ${formatDate(weekEnd)}`,
-        '',
-        '## Daily Progress',
-        `**Completed Today:** ${user.completedToday}`,
-        `**Daily Goal:** ${user.dailyGoal}`,
-        `**Weekly Goal:** ${user.weeklyGoal}`,
-        '',
-        '## Account Info',
-        `**Plan:** ${plan}`,
-    ];
-    const textContent = lines.join('\n');
-    // Generate structured content
-    const structuredContent = {
-        type: 'user_info',
-        userId: user.id,
-        fullName: user.fullName,
-        timezone: timezone,
-        currentLocalTime: localTime,
-        startDay: startDay,
-        startDayName: startDayName,
-        weekStartDate: formatDate(weekStart),
-        weekEndDate: formatDate(weekEnd),
-        currentWeekNumber: weekNumber,
-        completedToday: user.completedToday,
-        dailyGoal: user.dailyGoal,
-        weeklyGoal: user.weeklyGoal,
-        email: user.email,
-        plan: plan,
-    };
-    return { textContent, structuredContent };
-}
-const userInfo = {
-    name: ToolNames.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: ArgsSchema,
-    async execute(_args, client) {
-        const result = await generateUserInfo(client);
-        return getToolOutput({
-            textContent: result.textContent,
-            structuredContent: result.structuredContent,
-        });
-    },
-};
-export { userInfo };

package/dist/utils/assignment-validator.js

@@ -1,253 +0,0 @@
-import { userResolver } from './user-resolver.js';
-export const AssignmentErrorType = {
-    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',
-};
-export class AssignmentValidator {
-    /**
-     * Validate a single assignment operation
-     */
-    async validateAssignment(client, assignment) {
-        const { taskId, projectId, responsibleUid } = assignment;
-        // First, resolve the user
-        const resolvedUser = await userResolver.resolveUser(client, responsibleUid);
-        if (!resolvedUser) {
-            return {
-                isValid: false,
-                taskId,
-                projectId,
-                error: {
-                    type: AssignmentErrorType.USER_NOT_FOUND,
-                    message: `User "${responsibleUid}" 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",
-                    ],
-                },
-            };
-        }
-        // Validate the project exists and is accessible
-        try {
-            const targetProject = await client.getProject(projectId);
-            // Check if project is shared (required for assignments)
-            if (!targetProject.isShared) {
-                return {
-                    isValid: false,
-                    taskId,
-                    projectId,
-                    resolvedUser,
-                    error: {
-                        type: AssignmentErrorType.PROJECT_NOT_SHARED,
-                        message: `Project "${targetProject.name}" is not shared`,
-                        suggestions: [
-                            'Share the project with collaborators before assigning tasks',
-                            'Only shared projects support task assignments',
-                        ],
-                    },
-                };
-            }
-            // Validate the user is a collaborator on this specific project
-            const isCollaborator = await userResolver.validateProjectCollaborator(client, projectId, resolvedUser.userId);
-            if (!isCollaborator) {
-                return {
-                    isValid: false,
-                    taskId,
-                    projectId,
-                    resolvedUser,
-                    error: {
-                        type: AssignmentErrorType.USER_NOT_COLLABORATOR,
-                        message: `User "${resolvedUser.displayName}" is not a collaborator on project "${targetProject.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 taskId is provided, validate the task exists and is accessible
-            if (taskId) {
-                try {
-                    await client.getTask(taskId);
-                }
-                catch (_error) {
-                    return {
-                        isValid: false,
-                        taskId,
-                        projectId,
-                        resolvedUser,
-                        error: {
-                            type: AssignmentErrorType.TASK_NOT_FOUND,
-                            message: `Task "${taskId}" 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: true,
-                taskId,
-                projectId,
-                resolvedUser,
-            };
-        }
-        catch (_error) {
-            return {
-                isValid: false,
-                taskId,
-                projectId,
-                resolvedUser,
-                error: {
-                    type: AssignmentErrorType.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(client, assignments) {
-        // Process assignments in parallel for better performance
-        const validationPromises = assignments.map((assignment) => this.validateAssignment(client, assignment));
-        return Promise.all(validationPromises);
-    }
-    /**
-     * Validate assignment for task creation (no taskId required)
-     */
-    async validateTaskCreationAssignment(client, projectId, responsibleUid) {
-        return this.validateAssignment(client, {
-            projectId,
-            responsibleUid,
-        });
-    }
-    /**
-     * Validate assignment for task update
-     */
-    async validateTaskUpdateAssignment(client, taskId, responsibleUid) {
-        // If responsibleUid is null, it's an unassignment - always valid
-        if (responsibleUid === null) {
-            return {
-                isValid: true,
-                taskId,
-            };
-        }
-        // Get the task to find its project
-        try {
-            const task = await client.getTask(taskId);
-            return this.validateAssignment(client, {
-                taskId,
-                projectId: task.projectId,
-                responsibleUid,
-            });
-        }
-        catch (_error) {
-            return {
-                isValid: false,
-                taskId,
-                error: {
-                    type: AssignmentErrorType.TASK_NOT_FOUND,
-                    message: `Task "${taskId}" 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(client, projectId, responsibleUid, taskIds) {
-        const recommendations = [];
-        let canAssign = false;
-        // Get project information
-        let project;
-        try {
-            project = await client.getProject(projectId);
-        }
-        catch {
-            return {
-                canAssign: false,
-                projectInfo: {
-                    name: 'Unknown',
-                    isShared: false,
-                    collaboratorCount: 0,
-                },
-                recommendations: ['Project not found or not accessible'],
-            };
-        }
-        const collaborators = await userResolver.getProjectCollaborators(client, projectId);
-        const projectInfo = {
-            name: project.name,
-            isShared: project.isShared,
-            collaboratorCount: collaborators.length,
-        };
-        if (!project.isShared) {
-            recommendations.push('Share this project to enable task assignments');
-            return { canAssign: false, projectInfo, recommendations };
-        }
-        // Resolve user
-        const resolvedUser = await userResolver.resolveUser(client, responsibleUid);
-        if (!resolvedUser) {
-            recommendations.push('User not found - check spelling or invite to a shared project');
-            return { canAssign: false, projectInfo, recommendations };
-        }
-        const isCollaborator = collaborators.some((c) => c.id === resolvedUser.userId);
-        const userInfo = {
-            resolvedName: resolvedUser.displayName,
-            isCollaborator,
-        };
-        if (!isCollaborator) {
-            recommendations.push(`Invite ${resolvedUser.displayName} to collaborate on project "${project.name}"`);
-            return { canAssign: false, projectInfo, userInfo, recommendations };
-        }
-        // Check task accessibility if provided
-        let taskInfo;
-        if (taskIds && taskIds.length > 0) {
-            let accessible = 0;
-            let inaccessible = 0;
-            for (const taskId of taskIds) {
-                try {
-                    await client.getTask(taskId);
-                    accessible++;
-                }
-                catch {
-                    inaccessible++;
-                }
-            }
-            taskInfo = { accessibleTasks: accessible, inaccessibleTasks: inaccessible };
-            if (inaccessible > 0) {
-                recommendations.push(`${inaccessible} task(s) are not accessible`);
-            }
-        }
-        canAssign = true;
-        recommendations.push(`Ready to assign tasks to ${resolvedUser.displayName}`);
-        return {
-            canAssign,
-            projectInfo,
-            userInfo,
-            taskInfo,
-            recommendations,
-        };
-    }
-}
-// Export singleton instance
-export const assignmentValidator = new AssignmentValidator();

package/dist/utils/constants.js

@@ -1,45 +0,0 @@
-/**
- * Application-wide constants
- *
- * This module centralizes magic numbers and configuration values
- * to improve maintainability and provide a single source of truth.
- */
-// API Pagination Limits
-export const ApiLimits = {
-    /** 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,
-};
-// UI Display Limits
-export const DisplayLimits = {
-    /** Maximum number of failures to show in detailed error messages */
-    MAX_FAILURES_SHOWN: 3,
-    /** Threshold for suggesting batch operations */
-    BATCH_OPERATION_THRESHOLD: 10,
-};
-// Response Builder Configuration
-export const ResponseConfig = {
-    /** Maximum characters per line in text responses */
-    MAX_LINE_LENGTH: 100,
-    /** Indentation for nested items */
-    INDENT_SIZE: 2,
-};