@doist/todoist-ai 4.1.0 → 4.5.1

package/dist/tools/find-completed-tasks.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
 import { mapTask } from '../tool-helpers.js';
 import { ApiLimits } from '../utils/constants.js';
+import { generateLabelsFilter, LabelsSchema } from '../utils/labels.js';
 import { previewTasks, summarizeList } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
@@ -35,16 +36,24 @@ const ArgsSchema = {
         .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).'),
+    ...LabelsSchema,
 };
 const findCompletedTasks = {
     name: ToolNames.FIND_COMPLETED_TASKS,
     description: 'Get completed tasks.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        const { getBy, ...rest } = args;
+        const { getBy, labels, labelsOperator, ...rest } = args;
+        const labelsFilter = generateLabelsFilter(labels, labelsOperator);
         const { items, nextCursor } = getBy === 'completion'
-            ? await client.getCompletedTasksByCompletionDate(rest)
-            : await client.getCompletedTasksByDueDate(rest);
+            ? await client.getCompletedTasksByCompletionDate({
+                ...rest,
+                ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
+            })
+            : await client.getCompletedTasksByDueDate({
+                ...rest,
+                ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
+            });
         const mappedTasks = items.map(mapTask);
         const textContent = generateTextContent({
             tasks: mappedTasks,
@@ -78,6 +87,13 @@ function generateTextContent({ tasks, args, nextCursor, }) {
         filterHints.push(`parent: ${args.parentId}`);
     if (args.workspaceId)
         filterHints.push(`workspace: ${args.workspaceId}`);
+    // 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}`);
+    }
     // Generate helpful suggestions for empty results
     const zeroReasonHints = [];
     if (tasks.length === 0) {
@@ -104,7 +120,7 @@ function generateTextContent({ tasks, args, nextCursor, }) {
         limit: args.limit,
         nextCursor: nextCursor ?? undefined,
         filterHints,
-        previewLines: previewTasks(tasks),
+        previewLines: previewTasks(tasks, Math.min(tasks.length, args.limit)),
         zeroReasonHints,
         nextSteps,
     });

package/dist/tools/find-project-collaborators.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { type ProjectCollaborator } from '../utils/user-resolver.js';
+declare const findProjectCollaborators: {
+    name: "find-project-collaborators";
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        searchTerm: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        projectId: string;
+        searchTerm?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            collaborators: never[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: boolean;
+            };
+            totalCount: number;
+            appliedFilters: {
+                projectId: string;
+                searchTerm?: string | undefined;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            collaborators: ProjectCollaborator[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: boolean;
+            };
+            totalCount: number;
+            totalAvailable: number;
+            appliedFilters: {
+                projectId: string;
+                searchTerm?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findProjectCollaborators };
+//# sourceMappingURL=find-project-collaborators.d.ts.map

package/dist/tools/find-project-collaborators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-project-collaborators.d.ts","sourceRoot":"","sources":["../../src/tools/find-project-collaborators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,2BAA2B,CAAA;AAclF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8FY,CAAA;AAwE1C,OAAO,EAAE,wBAAwB,EAAE,CAAA"}

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

@@ -0,0 +1,151 @@
+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-tasks-by-date.d.ts

@@ -3,6 +3,8 @@ declare const findTasksByDate: {
     name: "find-tasks-by-date";
     description: string;
     parameters: {
+        labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        labelsOperator: z.ZodOptional<z.ZodEnum<["and", "or"]>>;
         startDate: z.ZodString;
         daysCount: z.ZodDefault<z.ZodNumber>;
         limit: z.ZodDefault<z.ZodNumber>;
@@ -12,7 +14,9 @@ declare const findTasksByDate: {
         limit: number;
         startDate: string;
         daysCount: number;
+        labels?: string[] | undefined;
         cursor?: string | undefined;
+        labelsOperator?: "and" | "or" | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
@@ -31,6 +35,8 @@ declare const findTasksByDate: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
@@ -39,7 +45,9 @@ declare const findTasksByDate: {
                 limit: number;
                 startDate: string;
                 daysCount: number;
+                labels?: string[] | undefined;
                 cursor?: string | undefined;
+                labelsOperator?: "and" | "or" | undefined;
             };
         };
     } | {

package/dist/tools/find-tasks-by-date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-tasks-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA4CvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CqB,CAAA;AAiE1C,OAAO,EAAE,eAAe,EAAE,CAAA"}
+{"version":3,"file":"find-tasks-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA8CvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDqB,CAAA;AAyE1C,OAAO,EAAE,eAAe,EAAE,CAAA"}

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

@@ -3,6 +3,7 @@ import { z } from 'zod';
 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 = {
@@ -28,13 +29,14 @@ const ArgsSchema = {
         .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).'),
+    ...LabelsSchema,
 };
 const findTasksByDate = {
     name: ToolNames.FIND_TASKS_BY_DATE,
     description: "Get tasks by date range or overdue tasks. Use startDate 'overdue' for overdue tasks, or provide a date/date range.",
     parameters: ArgsSchema,
     async execute(args, client) {
-        let query;
+        let query = '';
         if (args.startDate === 'overdue') {
             query = 'overdue';
         }
@@ -46,6 +48,14 @@ const findTasksByDate = {
             const endDateStr = formatISO(endDate, { representation: 'date' });
             query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
         }
+        const labelsFilter = generateLabelsFilter(args.labels, args.labelsOperator);
+        if (labelsFilter.length > 0) {
+            // If there is already a query, we need to append the & operator first
+            if (query.length > 0)
+                query += ' & ';
+            // Add the labels to the filter
+            query += `(${labelsFilter})`;
+        }
         const result = await getTasksByFilter({
             client,
             query,
@@ -81,6 +91,13 @@ function generateTextContent({ tasks, args, nextCursor, }) {
     else {
         filterHints.push(`${args.startDate}${args.daysCount > 1 ? ` to ${getDateString(addDays(args.startDate, args.daysCount))}` : ''}`);
     }
+    // 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}`);
+    }
     // Generate subject description
     const subject = args.startDate === 'overdue'
         ? 'Overdue tasks'
@@ -113,7 +130,7 @@ function generateTextContent({ tasks, args, nextCursor, }) {
         limit: args.limit,
         nextCursor: nextCursor ?? undefined,
         filterHints,
-        previewLines: previewTasks(tasks),
+        previewLines: previewTasks(tasks, Math.min(tasks.length, args.limit)),
         zeroReasonHints,
         nextSteps,
     });

package/dist/tools/find-tasks.d.ts

@@ -3,19 +3,25 @@ declare const findTasks: {
     name: "find-tasks";
     description: string;
     parameters: {
+        labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        labelsOperator: z.ZodOptional<z.ZodEnum<["and", "or"]>>;
         searchText: z.ZodOptional<z.ZodString>;
         projectId: z.ZodOptional<z.ZodString>;
         sectionId: z.ZodOptional<z.ZodString>;
         parentId: z.ZodOptional<z.ZodString>;
+        responsibleUser: z.ZodOptional<z.ZodString>;
         limit: z.ZodDefault<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
         limit: number;
-        parentId?: string | undefined;
         projectId?: string | undefined;
+        parentId?: string | undefined;
         sectionId?: string | undefined;
+        labels?: string[] | undefined;
         cursor?: string | undefined;
+        responsibleUser?: string | undefined;
+        labelsOperator?: "and" | "or" | undefined;
         searchText?: string | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
@@ -35,16 +41,21 @@ declare const findTasks: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
             hasMore: boolean;
             appliedFilters: {
                 limit: number;
-                parentId?: string | undefined;
                 projectId?: string | undefined;
+                parentId?: string | undefined;
                 sectionId?: string | undefined;
+                labels?: string[] | undefined;
                 cursor?: string | undefined;
+                responsibleUser?: string | undefined;
+                labelsOperator?: "and" | "or" | undefined;
                 searchText?: string | undefined;
             };
         };

package/dist/tools/find-tasks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoCvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmF2B,CAAA;AAyG1C,OAAO,EAAE,SAAS,EAAE,CAAA"}
+{"version":3,"file":"find-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2CvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgM2B,CAAA;AA2K1C,OAAO,EAAE,SAAS,EAAE,CAAA"}