@doist/todoist-ai 4.16.0 → 4.17.0

package/dist/tools/get-overview.js

@@ -1,249 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { isPersonalProject, mapTask } from '../tool-helpers.js';
-import { ApiLimits } from '../utils/constants.js';
-import { ToolNames } from '../utils/tool-names.js';
-const ArgsSchema = {
-    projectId: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Optional project ID. If provided, shows detailed overview of that project. If omitted, shows overview of all projects.'),
-};
-function buildProjectTree(projects) {
-    // Sort projects by childOrder, then build a tree
-    const byId = {};
-    for (const p of projects) {
-        byId[p.id] = {
-            ...p,
-            children: [],
-            childOrder: p.childOrder ?? 0,
-        };
-    }
-    const roots = [];
-    for (const p of projects) {
-        const current = byId[p.id];
-        if (!current)
-            continue;
-        if (isPersonalProject(p) && p.parentId) {
-            const parent = byId[p.parentId];
-            if (parent) {
-                parent.children.push(current);
-            }
-            else {
-                roots.push(current);
-            }
-        }
-        else {
-            roots.push(current);
-        }
-    }
-    function sortTree(nodes) {
-        nodes.sort((a, b) => a.childOrder - b.childOrder);
-        for (const n of nodes) {
-            sortTree(n.children);
-        }
-    }
-    sortTree(roots);
-    return roots;
-}
-async function getSectionsByProject(client, projectIds) {
-    const result = {};
-    await Promise.all(projectIds.map(async (projectId) => {
-        const { results } = await client.getSections({ projectId });
-        result[projectId] = results;
-    }));
-    return result;
-}
-function renderProjectMarkdown(project, sectionsByProject, indent = '') {
-    const lines = [];
-    lines.push(`${indent}- Project: ${project.name} (id=${project.id})`);
-    const sections = sectionsByProject[project.id] || [];
-    for (const section of sections) {
-        lines.push(`${indent}  - Section: ${section.name} (id=${section.id})`);
-    }
-    for (const child of project.children) {
-        lines.push(...renderProjectMarkdown(child, sectionsByProject, `${indent}  `));
-    }
-    return lines;
-}
-function buildTaskTree(tasks) {
-    const byId = {};
-    for (const task of tasks) {
-        byId[task.id] = { ...task, children: [] };
-    }
-    const roots = [];
-    for (const task of tasks) {
-        const node = byId[task.id];
-        if (!node)
-            continue;
-        if (!task.parentId) {
-            roots.push(node);
-            continue;
-        }
-        const parent = byId[task.parentId];
-        if (parent) {
-            parent.children.push(node);
-        }
-        else {
-            roots.push(node);
-        }
-    }
-    return roots;
-}
-function renderTaskTreeMarkdown(tasks, indent = '') {
-    const lines = [];
-    for (const task of tasks) {
-        const idPart = `id=${task.id}`;
-        const duePart = task.dueDate ? `; due=${task.dueDate}` : '';
-        const contentPart = `; content=${task.content}`;
-        lines.push(`${indent}- ${idPart}${duePart}${contentPart}`);
-        if (task.children.length > 0) {
-            lines.push(...renderTaskTreeMarkdown(task.children, `${indent}  `));
-        }
-    }
-    return lines;
-}
-function buildProjectStructure(project, sectionsByProject) {
-    return {
-        id: project.id,
-        name: project.name,
-        parentId: isPersonalProject(project) ? (project.parentId ?? null) : null,
-        sections: sectionsByProject[project.id] || [],
-        children: project.children.map((child) => buildProjectStructure(child, sectionsByProject)),
-    };
-}
-async function getAllTasksForProject(client, projectId) {
-    let allTasks = [];
-    let cursor;
-    do {
-        const { results, nextCursor } = await client.getTasks({
-            projectId,
-            limit: ApiLimits.TASKS_BATCH_SIZE,
-            cursor: cursor ?? undefined,
-        });
-        allTasks = allTasks.concat(results.map(mapTask));
-        cursor = nextCursor ?? undefined;
-    } while (cursor);
-    return allTasks;
-}
-async function getProjectSections(client, projectId) {
-    const { results } = await client.getSections({ projectId });
-    return results;
-}
-async function generateAccountOverview(client) {
-    const { results: projects } = await client.getProjects({});
-    const inbox = projects.find((p) => isPersonalProject(p) && p.inboxProject === true);
-    const nonInbox = projects.filter((p) => !isPersonalProject(p) || p.inboxProject !== true);
-    const tree = buildProjectTree(nonInbox);
-    const allProjectIds = projects.map((p) => p.id);
-    const sectionsByProject = await getSectionsByProject(client, allProjectIds);
-    // Generate markdown text content
-    const lines = ['# Personal Projects', ''];
-    if (inbox) {
-        lines.push(`- Inbox Project: ${inbox.name} (id=${inbox.id})`);
-        for (const section of sectionsByProject[inbox.id] || []) {
-            lines.push(`  - Section: ${section.name} (id=${section.id})`);
-        }
-    }
-    if (tree.length) {
-        for (const project of tree) {
-            lines.push(...renderProjectMarkdown(project, sectionsByProject));
-        }
-    }
-    else {
-        lines.push('_No projects found._');
-    }
-    lines.push('');
-    // Add explanation about nesting if there are nested projects
-    const hasNested = tree.some((p) => p.children.length > 0);
-    if (hasNested) {
-        lines.push('_Note: Indentation indicates that a project is a sub-project of the one above it. This allows for organizing projects hierarchically, with parent projects containing related sub-projects._', '');
-    }
-    const textContent = lines.join('\n');
-    // Generate structured content
-    const structuredContent = {
-        type: 'account_overview',
-        inbox: inbox
-            ? {
-                id: inbox.id,
-                name: inbox.name,
-                sections: sectionsByProject[inbox.id] || [],
-            }
-            : null,
-        projects: tree.map((project) => buildProjectStructure(project, sectionsByProject)),
-        totalProjects: projects.length,
-        totalSections: allProjectIds.reduce((total, id) => total + (sectionsByProject[id]?.length || 0), 0),
-        hasNestedProjects: hasNested,
-    };
-    return { textContent, structuredContent };
-}
-async function generateProjectOverview(client, projectId) {
-    const project = await client.getProject(projectId);
-    const sections = await getProjectSections(client, projectId);
-    const allTasks = await getAllTasksForProject(client, projectId);
-    // Group tasks by sectionId
-    const tasksBySection = {};
-    for (const section of sections) {
-        tasksBySection[section.id] = [];
-    }
-    const tasksWithoutSection = [];
-    for (const task of allTasks) {
-        const sectionTasks = task.sectionId
-            ? (tasksBySection[task.sectionId] ?? tasksWithoutSection)
-            : tasksWithoutSection;
-        sectionTasks.push(task);
-    }
-    // Generate markdown text content
-    const lines = [`# ${project.name}`];
-    if (tasksWithoutSection.length > 0) {
-        lines.push('');
-        const tree = buildTaskTree(tasksWithoutSection);
-        lines.push(...renderTaskTreeMarkdown(tree));
-    }
-    for (const section of sections) {
-        lines.push('');
-        lines.push(`## ${section.name}`);
-        const sectionTasks = tasksBySection[section.id];
-        if (!sectionTasks?.length) {
-            continue;
-        }
-        const tree = buildTaskTree(sectionTasks);
-        lines.push(...renderTaskTreeMarkdown(tree));
-    }
-    const textContent = lines.join('\n');
-    // Generate structured content
-    const structuredContent = {
-        type: 'project_overview',
-        project: {
-            id: project.id,
-            name: project.name,
-        },
-        sections: sections,
-        tasks: allTasks.map((task) => ({
-            ...task,
-            children: [], // Tasks already include hierarchical info via parentId
-        })),
-        stats: {
-            totalTasks: allTasks.length,
-            totalSections: sections.length,
-            tasksWithoutSection: tasksWithoutSection.length,
-        },
-    };
-    return { textContent, structuredContent };
-}
-const getOverview = {
-    name: ToolNames.GET_OVERVIEW,
-    description: 'Get a Markdown overview. If no projectId is provided, shows all projects with hierarchy and sections (useful for navigation). If projectId is provided, shows detailed overview of that specific project including all tasks grouped by sections.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const result = args.projectId
-            ? await generateProjectOverview(client, args.projectId)
-            : await generateAccountOverview(client);
-        return getToolOutput({
-            textContent: result.textContent,
-            structuredContent: result.structuredContent,
-        });
-    },
-};
-export { getOverview };

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