@doist/todoist-ai 4.16.0 → 4.17.0

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 };

package/dist/tools/update-tasks.js

@@ -1,179 +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. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
-    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;
-            // Resolve "inbox" to actual inbox project ID if needed
-            let resolvedProjectId = projectId;
-            if (projectId === 'inbox') {
-                const todoistUser = await client.getUser();
-                resolvedProjectId = todoistUser.inboxProjectId;
-            }
-            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 (!resolvedProjectId && !sectionId && !parentId) {
-                return await client.updateTask(id, updateArgs);
-            }
-            const moveArgs = createMoveTaskArgs(id, resolvedProjectId, 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 };