@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tools/find-project-collaborators.js

@@ -1,151 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { summarizeList } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-import { userResolver } from '../utils/user-resolver.js';
-const { FIND_PROJECTS, ADD_TASKS, UPDATE_TASKS } = ToolNames;
-const ArgsSchema = {
-    projectId: z.string().min(1).describe('The ID of the project to search for collaborators in.'),
-    searchTerm: z
-        .string()
-        .optional()
-        .describe('Search for a collaborator by name or email (partial and case insensitive match). If omitted, all collaborators in the project are returned.'),
-};
-const findProjectCollaborators = {
-    name: ToolNames.FIND_PROJECT_COLLABORATORS,
-    description: 'Search for collaborators by name or other criteria in a project.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { projectId, searchTerm } = args;
-        // First, validate that the project exists and get basic info
-        let projectName = projectId;
-        let project;
-        try {
-            project = await client.getProject(projectId);
-            if (!project) {
-                throw new Error(`Project with ID "${projectId}" not found or not accessible`);
-            }
-            projectName = project.name;
-            if (!project.isShared) {
-                const textContent = `Project "${projectName}" is not shared and has no collaborators.\n\n**Next steps:**\n• Share the project to enable collaboration\n• Use ${ADD_TASKS} and ${UPDATE_TASKS} for assignment features once shared`;
-                return getToolOutput({
-                    textContent,
-                    structuredContent: {
-                        collaborators: [],
-                        projectInfo: {
-                            id: projectId,
-                            name: projectName,
-                            isShared: false,
-                        },
-                        totalCount: 0,
-                        appliedFilters: args,
-                    },
-                });
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to access project "${projectId}": ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-        // Get collaborators for the project
-        const allCollaborators = await userResolver.getProjectCollaborators(client, projectId);
-        if (allCollaborators.length === 0) {
-            const textContent = `Project "${projectName}" has no collaborators or collaborator data is not accessible.\n\n**Next steps:**\n• Check project sharing settings\n• Ensure you have permission to view collaborators\n• Try refreshing or re-sharing the project`;
-            return getToolOutput({
-                textContent,
-                structuredContent: {
-                    collaborators: [],
-                    projectInfo: {
-                        id: projectId,
-                        name: projectName,
-                        isShared: true,
-                    },
-                    totalCount: 0,
-                    appliedFilters: args,
-                },
-            });
-        }
-        // Filter collaborators if search term provided
-        let filteredCollaborators = allCollaborators;
-        if (searchTerm) {
-            const searchLower = searchTerm.toLowerCase().trim();
-            filteredCollaborators = allCollaborators.filter((collaborator) => collaborator.name.toLowerCase().includes(searchLower) ||
-                collaborator.email.toLowerCase().includes(searchLower));
-        }
-        const textContent = generateTextContent({
-            collaborators: filteredCollaborators,
-            projectName,
-            searchTerm,
-            totalAvailable: allCollaborators.length,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                collaborators: filteredCollaborators,
-                projectInfo: {
-                    id: projectId,
-                    name: projectName,
-                    isShared: true,
-                },
-                totalCount: filteredCollaborators.length,
-                totalAvailable: allCollaborators.length,
-                appliedFilters: args,
-            },
-        });
-    },
-};
-function generateTextContent({ collaborators, projectName, searchTerm, totalAvailable, }) {
-    const subject = searchTerm
-        ? `Project collaborators matching "${searchTerm}"`
-        : 'Project collaborators';
-    const filterHints = [];
-    if (searchTerm) {
-        filterHints.push(`matching "${searchTerm}"`);
-    }
-    filterHints.push(`in project "${projectName}"`);
-    let previewLines = [];
-    if (collaborators.length > 0) {
-        previewLines = collaborators.slice(0, 10).map((collaborator) => {
-            const displayName = collaborator.name || 'Unknown Name';
-            const email = collaborator.email || 'No email';
-            return `• ${displayName} (${email}) - ID: ${collaborator.id}`;
-        });
-        if (collaborators.length > 10) {
-            previewLines.push(`... and ${collaborators.length - 10} more`);
-        }
-    }
-    const zeroReasonHints = [];
-    if (collaborators.length === 0) {
-        if (searchTerm) {
-            zeroReasonHints.push(`No collaborators match "${searchTerm}"`);
-            zeroReasonHints.push('Try a broader search term or check spelling');
-            if (totalAvailable > 0) {
-                zeroReasonHints.push(`${totalAvailable} collaborators available without filter`);
-            }
-        }
-        else {
-            zeroReasonHints.push('Project has no collaborators');
-            zeroReasonHints.push('Share the project to add collaborators');
-        }
-    }
-    const nextSteps = [];
-    if (collaborators.length > 0) {
-        nextSteps.push(`Use ${ADD_TASKS} with responsibleUser to assign new tasks`);
-        nextSteps.push(`Use ${UPDATE_TASKS} with responsibleUser to reassign existing tasks`);
-        nextSteps.push('Use collaborator names, emails, or IDs for assignments');
-    }
-    else {
-        nextSteps.push(`Use ${FIND_PROJECTS} to find other projects`);
-        if (searchTerm && totalAvailable > 0) {
-            nextSteps.push('Try searching without filters to see all collaborators');
-        }
-    }
-    return summarizeList({
-        subject,
-        count: collaborators.length,
-        filterHints,
-        previewLines: previewLines.join('\n'),
-        zeroReasonHints,
-        nextSteps,
-    });
-}
-export { findProjectCollaborators };

package/dist/tools/find-projects.js

@@ -1,101 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { mapProject } from '../tool-helpers.js';
-import { ApiLimits } from '../utils/constants.js';
-import { formatProjectPreview, summarizeList } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { ADD_PROJECTS, FIND_TASKS } = ToolNames;
-const ArgsSchema = {
-    search: z
-        .string()
-        .optional()
-        .describe('Search for a project by name (partial and case insensitive match). If omitted, all projects are returned.'),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(ApiLimits.PROJECTS_MAX)
-        .default(ApiLimits.PROJECTS_DEFAULT)
-        .describe('The maximum number of projects to return.'),
-    cursor: z
-        .string()
-        .optional()
-        .describe('The cursor to get the next page of projects (cursor is obtained from the previous call to this tool, with the same parameters).'),
-};
-const findProjects = {
-    name: ToolNames.FIND_PROJECTS,
-    description: 'List all projects or search for projects by name. If search parameter is omitted, all projects are returned.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { results, nextCursor } = await client.getProjects({
-            limit: args.limit,
-            cursor: args.cursor ?? null,
-        });
-        const searchLower = args.search ? args.search.toLowerCase() : undefined;
-        const filtered = searchLower
-            ? results.filter((project) => project.name.toLowerCase().includes(searchLower))
-            : results;
-        const projects = filtered.map(mapProject);
-        return getToolOutput({
-            textContent: generateTextContent({
-                projects,
-                args,
-                nextCursor,
-            }),
-            structuredContent: {
-                projects,
-                nextCursor,
-                totalCount: projects.length,
-                hasMore: Boolean(nextCursor),
-                appliedFilters: args,
-            },
-        });
-    },
-};
-function generateTextContent({ projects, args, nextCursor, }) {
-    // Generate subject description
-    const subject = args.search ? `Projects matching "${args.search}"` : 'Projects';
-    // Generate filter hints
-    const filterHints = [];
-    if (args.search) {
-        filterHints.push(`search: "${args.search}"`);
-    }
-    // Generate project preview lines
-    const previewLimit = 10;
-    const previewProjects = projects.slice(0, previewLimit);
-    const previewLines = previewProjects.map(formatProjectPreview).join('\n');
-    const remainingCount = projects.length - previewLimit;
-    const previewWithMore = remainingCount > 0 ? `${previewLines}\n    …and ${remainingCount} more` : previewLines;
-    // Generate helpful suggestions for empty results
-    const zeroReasonHints = [];
-    if (projects.length === 0) {
-        if (args.search) {
-            zeroReasonHints.push('Try broader search terms');
-            zeroReasonHints.push('Check spelling');
-            zeroReasonHints.push('Remove search to see all projects');
-        }
-        else {
-            zeroReasonHints.push('No projects created yet');
-            zeroReasonHints.push(`Use ${ADD_PROJECTS} to create a project`);
-        }
-    }
-    // Generate contextual next steps
-    const nextSteps = [];
-    if (projects.length > 0) {
-        nextSteps.push(`Use ${FIND_TASKS} with projectId to see tasks in specific projects.`);
-        if (projects.some((p) => p.isFavorite)) {
-            nextSteps.push('Favorite projects appear first in most Todoist views.');
-        }
-    }
-    return summarizeList({
-        subject,
-        count: projects.length,
-        limit: args.limit,
-        nextCursor: nextCursor ?? undefined,
-        filterHints,
-        previewLines: previewWithMore,
-        zeroReasonHints,
-        nextSteps,
-    });
-}
-export { findProjects };

package/dist/tools/find-sections.js

@@ -1,96 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { summarizeList } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { ADD_SECTIONS, UPDATE_SECTIONS, FIND_TASKS, UPDATE_TASKS, DELETE_OBJECT } = ToolNames;
-const ArgsSchema = {
-    projectId: z.string().min(1).describe('The ID of the project to search sections in.'),
-    search: z
-        .string()
-        .optional()
-        .describe('Search for a section by name (partial and case insensitive match). If omitted, all sections in the project are returned.'),
-};
-const findSections = {
-    name: ToolNames.FIND_SECTIONS,
-    description: 'Search for sections by name or other criteria in a project.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { results } = await client.getSections({
-            projectId: args.projectId,
-        });
-        const searchLower = args.search ? args.search.toLowerCase() : undefined;
-        const filtered = searchLower
-            ? results.filter((section) => section.name.toLowerCase().includes(searchLower))
-            : results;
-        const sections = filtered.map((section) => ({
-            id: section.id,
-            name: section.name,
-        }));
-        const textContent = generateTextContent({
-            sections,
-            projectId: args.projectId,
-            search: args.search,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                sections,
-                totalCount: sections.length,
-                appliedFilters: args,
-            },
-        });
-    },
-};
-function generateTextContent({ sections, projectId, search, }) {
-    const zeroReasonHints = [];
-    if (search) {
-        zeroReasonHints.push('Try broader search terms');
-        zeroReasonHints.push('Check spelling');
-        zeroReasonHints.push('Remove search to see all sections');
-    }
-    else {
-        zeroReasonHints.push('Project has no sections yet');
-        zeroReasonHints.push(`Use ${ADD_SECTIONS} to create sections`);
-    }
-    // Data-driven next steps based on results
-    const nextSteps = [];
-    if (sections.length > 0) {
-        // Suggestions based on number of sections found
-        if (sections.length === 1) {
-            const sectionId = sections[0]?.id;
-            nextSteps.push(`Use ${FIND_TASKS} with sectionId=${sectionId} to see tasks`);
-            nextSteps.push(`Use ${ADD_SECTIONS} to create additional sections for organization`);
-        }
-        else if (sections.length > 8) {
-            nextSteps.push('Consider consolidating sections - many small sections can reduce productivity');
-            nextSteps.push(`Use ${UPDATE_TASKS} to move tasks between sections`);
-            nextSteps.push(`Use ${DELETE_OBJECT} with type=section to delete empty sections`);
-        }
-        else {
-            nextSteps.push(`Use ${FIND_TASKS} with sectionId to see tasks in specific sections`);
-            nextSteps.push(`Use ${UPDATE_SECTIONS} to modify section names`);
-        }
-        // Search-specific suggestions
-        if (search) {
-            nextSteps.push('Remove search parameter to see all sections in this project');
-        }
-    }
-    else {
-        // Empty result suggestions are already handled in zeroReasonHints
-        // No additional nextSteps needed for empty results
-    }
-    const subject = search
-        ? `Sections in project ${projectId} matching "${search}"`
-        : `Sections in project ${projectId}`;
-    const previewLines = sections.length > 0
-        ? sections.map((section) => `    ${section.name} • id=${section.id}`).join('\n')
-        : undefined;
-    return summarizeList({
-        subject,
-        count: sections.length,
-        previewLines,
-        zeroReasonHints,
-        nextSteps,
-    });
-}
-export { findSections };

package/dist/tools/find-tasks-by-date.js

@@ -1,198 +0,0 @@
-import { addDays, formatISO } from 'date-fns';
-import { z } from 'zod';
-import { appendToQuery, buildResponsibleUserQueryFilter, RESPONSIBLE_USER_FILTERING, resolveResponsibleUser, } from '../filter-helpers.js';
-import { getToolOutput } from '../mcp-helpers.js';
-import { getTasksByFilter } from '../tool-helpers.js';
-import { ApiLimits } from '../utils/constants.js';
-import { generateLabelsFilter, LabelsSchema } from '../utils/labels.js';
-import { generateTaskNextSteps, getDateString, previewTasks, summarizeList, } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const ArgsSchema = {
-    startDate: z
-        .string()
-        .regex(/^(\d{4}-\d{2}-\d{2}|today)$/)
-        .optional()
-        .describe("The start date to get the tasks for. Format: YYYY-MM-DD or 'today'."),
-    overdueOption: z
-        .enum(['overdue-only', 'include-overdue', 'exclude-overdue'])
-        .optional()
-        .describe("How to handle overdue tasks. 'overdue-only' to get only overdue tasks, 'include-overdue' to include overdue tasks along with tasks for the specified date(s), and 'exclude-overdue' to exclude overdue tasks. Default is 'include-overdue'."),
-    daysCount: z
-        .number()
-        .int()
-        .min(1)
-        .max(30)
-        .default(1)
-        .describe('The number of days to get the tasks for, starting from the start date. Default is 1 which means only tasks for the start date.'),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(ApiLimits.TASKS_MAX)
-        .default(ApiLimits.TASKS_DEFAULT)
-        .describe('The maximum number of tasks to return.'),
-    cursor: z
-        .string()
-        .optional()
-        .describe('The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters).'),
-    responsibleUser: z
-        .string()
-        .optional()
-        .describe('Find tasks assigned to this user. Can be a user ID, name, or email address.'),
-    responsibleUserFiltering: z
-        .enum(RESPONSIBLE_USER_FILTERING)
-        .optional()
-        .describe('How to filter by responsible user when responsibleUser is not provided. "assigned" = only tasks assigned to others; "unassignedOrMe" = only unassigned tasks or tasks assigned to me; "all" = all tasks regardless of assignment. Default is "unassignedOrMe".'),
-    ...LabelsSchema,
-};
-const findTasksByDate = {
-    name: ToolNames.FIND_TASKS_BY_DATE,
-    description: "Get tasks by date range. Use startDate 'today' to get today's tasks including overdue items, or provide a specific date/date range.",
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        if (!args.startDate && args.overdueOption !== 'overdue-only') {
-            throw new Error('Either startDate must be provided or overdueOption must be set to overdue-only');
-        }
-        // Resolve assignee name to user ID if provided
-        const resolved = await resolveResponsibleUser(client, args.responsibleUser);
-        const resolvedAssigneeId = resolved?.userId;
-        const assigneeEmail = resolved?.email;
-        let query = '';
-        if (args.overdueOption === 'overdue-only') {
-            query = 'overdue';
-        }
-        else if (args.startDate === 'today') {
-            // For 'today', include overdue unless explicitly excluded
-            // Use parentheses to ensure correct operator precedence when combining with other filters
-            query = args.overdueOption === 'exclude-overdue' ? 'today' : '(today | overdue)';
-        }
-        else if (args.startDate) {
-            // For specific dates, never include overdue tasks
-            const startDate = args.startDate;
-            const endDate = addDays(startDate, args.daysCount);
-            const endDateStr = formatISO(endDate, { representation: 'date' });
-            query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
-        }
-        // Add labels filter
-        const labelsFilter = generateLabelsFilter(args.labels, args.labelsOperator);
-        if (labelsFilter.length > 0) {
-            query = appendToQuery(query, `(${labelsFilter})`);
-        }
-        // Add responsible user filtering to the query (backend filtering)
-        const responsibleUserFilter = buildResponsibleUserQueryFilter({
-            resolvedAssigneeId,
-            assigneeEmail,
-            responsibleUserFiltering: args.responsibleUserFiltering,
-        });
-        query = appendToQuery(query, responsibleUserFilter);
-        const result = await getTasksByFilter({
-            client,
-            query,
-            cursor: args.cursor,
-            limit: args.limit,
-        });
-        // No need for post-fetch filtering since it's handled in the query
-        const filteredTasks = result.tasks;
-        const textContent = generateTextContent({
-            tasks: filteredTasks,
-            args,
-            nextCursor: result.nextCursor,
-            assigneeEmail,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                tasks: filteredTasks,
-                nextCursor: result.nextCursor,
-                totalCount: filteredTasks.length,
-                hasMore: Boolean(result.nextCursor),
-                appliedFilters: args,
-            },
-        });
-    },
-};
-function generateTextContent({ tasks, args, nextCursor, assigneeEmail, }) {
-    // Generate filter description
-    const filterHints = [];
-    if (args.overdueOption === 'overdue-only') {
-        filterHints.push('overdue tasks only');
-    }
-    else if (args.startDate === 'today') {
-        const overdueText = args.overdueOption === 'exclude-overdue' ? '' : ' + overdue tasks';
-        filterHints.push(`today${overdueText}${args.daysCount > 1 ? ` + ${args.daysCount - 1} more days` : ''}`);
-    }
-    else if (args.startDate) {
-        const dateRange = args.daysCount > 1
-            ? ` to ${getDateString(addDays(args.startDate, args.daysCount))}`
-            : '';
-        filterHints.push(`${args.startDate}${dateRange}`);
-    }
-    // Add label filter information
-    if (args.labels && args.labels.length > 0) {
-        const labelText = args.labels
-            .map((label) => `@${label}`)
-            .join(args.labelsOperator === 'and' ? ' & ' : ' | ');
-        filterHints.push(`labels: ${labelText}`);
-    }
-    // Add responsible user filter information
-    if (args.responsibleUser) {
-        const email = assigneeEmail || args.responsibleUser;
-        filterHints.push(`assigned to: ${email}`);
-    }
-    // Generate subject description
-    let subject = '';
-    if (args.overdueOption === 'overdue-only') {
-        subject = 'Overdue tasks';
-    }
-    else if (args.startDate === 'today') {
-        subject =
-            args.overdueOption === 'exclude-overdue' ? `Today's tasks` : `Today's tasks + overdue`;
-    }
-    else if (args.startDate) {
-        subject = `Tasks for ${args.startDate}`;
-    }
-    else {
-        subject = 'Tasks';
-    }
-    // Append responsible user to subject if provided
-    if (args.responsibleUser) {
-        const email = assigneeEmail || args.responsibleUser;
-        subject += ` assigned to ${email}`;
-    }
-    // Generate helpful suggestions for empty results
-    const zeroReasonHints = [];
-    if (tasks.length === 0) {
-        if (args.overdueOption === 'overdue-only') {
-            zeroReasonHints.push('Great job! No overdue tasks');
-        }
-        else if (args.startDate === 'today') {
-            const overdueNote = args.overdueOption === 'exclude-overdue' ? '' : ' or overdue';
-            zeroReasonHints.push(`Great job! No tasks for today${overdueNote}`);
-        }
-        else {
-            zeroReasonHints.push("Expand date range with larger 'daysCount'");
-            zeroReasonHints.push("Check today's tasks with startDate='today'");
-        }
-    }
-    // Generate contextual next steps
-    const now = new Date();
-    const todayStr = getDateString(now);
-    const hasOverdue = args.overdueOption === 'overdue-only' ||
-        args.startDate === 'today' ||
-        tasks.some((task) => task.dueDate && new Date(task.dueDate) < now);
-    const nextSteps = generateTaskNextSteps('listed', tasks, {
-        hasToday: args.startDate === 'today' || tasks.some((task) => task.dueDate === todayStr),
-        hasOverdue,
-    });
-    return summarizeList({
-        subject,
-        count: tasks.length,
-        limit: args.limit,
-        nextCursor: nextCursor ?? undefined,
-        filterHints,
-        previewLines: previewTasks(tasks, Math.min(tasks.length, args.limit)),
-        zeroReasonHints,
-        nextSteps,
-    });
-}
-export { findTasksByDate };