@doist/todoist-ai 4.11.0 → 4.13.0

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

@@ -2,16 +2,22 @@ import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
 import { createMappedTask, createMockUser, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
+import { resolveUserNameToId } from '../../utils/user-resolver.js';
 import { findTasksByDate } from '../find-tasks-by-date.js';
-// Mock the tool helpers
+// Mock only getTasksByFilter, use actual implementations for everything else
 jest.mock('../../tool-helpers', () => {
     const actual = jest.requireActual('../../tool-helpers');
     return {
+        ...actual,
         getTasksByFilter: jest.fn(),
-        filterTasksByResponsibleUser: actual.filterTasksByResponsibleUser,
     };
 });
+// Mock user resolver
+jest.mock('../../utils/user-resolver', () => ({
+    resolveUserNameToId: jest.fn(),
+}));
 const mockGetTasksByFilter = getTasksByFilter;
+const mockResolveUserNameToId = resolveUserNameToId;
 // Mock the Todoist API (not directly used by find-tasks-by-date, but needed for type)
 const mockTodoistApi = {
     getUser: jest.fn(),
@@ -57,7 +63,7 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             // Verify the query uses daysCount=1 by checking the end date calculation
             expect(mockGetTasksByFilter).toHaveBeenCalledWith({
                 client: mockTodoistApi,
-                query: '(due after: 2025-08-20 | due: 2025-08-20) & due before: 2025-08-21',
+                query: '(due after: 2025-08-20 | due: 2025-08-20) & due before: 2025-08-21 & !assigned to: others',
                 cursor: undefined,
                 limit: 50,
             });
@@ -71,7 +77,7 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             const result = await findTasksByDate.execute({ startDate: 'today', limit: 50, daysCount: 7 }, mockTodoistApi);
             expect(mockGetTasksByFilter).toHaveBeenCalledWith({
                 client: mockTodoistApi,
-                query: 'today | overdue',
+                query: '(today | overdue) & !assigned to: others',
                 cursor: undefined,
                 limit: 50,
             });
@@ -236,7 +242,7 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
                     limit: 50,
                     labels: ['work'],
                 },
-                expectedQueryPattern: 'today | overdue & ((@work))', // Will be combined with date query
+                expectedQueryPattern: '(today | overdue) & ((@work)) & !assigned to: others', // Will be combined with date query
             },
             {
                 name: 'multiple labels with AND operator',
@@ -247,7 +253,7 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
                     labels: ['work', 'urgent'],
                     labelsOperator: 'and',
                 },
-                expectedQueryPattern: 'today | overdue & ((@work  &  @urgent))',
+                expectedQueryPattern: '(today | overdue) & ((@work  &  @urgent)) & !assigned to: others',
             },
             {
                 name: 'multiple labels with OR operator',
@@ -339,6 +345,7 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
     });
     describe('responsible user filtering', () => {
         it('should filter results to show only unassigned tasks or tasks assigned to current user', async () => {
+            // Backend filtering: API should only return unassigned + assigned to me
             const mockTasks = [
                 createMappedTask({
                     id: TEST_IDS.TASK_1,
@@ -352,16 +359,22 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
                     dueDate: '2025-08-15',
                     responsibleUid: null, // Unassigned
                 }),
-                createMappedTask({
-                    id: TEST_IDS.TASK_3,
-                    content: 'Someone else task',
-                    dueDate: '2025-08-15',
-                    responsibleUid: 'other-user-id', // Assigned to someone else
-                }),
             ];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasksByDate.execute({ startDate: 'today', daysCount: 1, limit: 50 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({
+                startDate: 'today',
+                daysCount: 1,
+                limit: 50,
+                responsibleUserFiltering: 'unassignedOrMe',
+            }, mockTodoistApi);
+            // Verify the query includes the assignment filter
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: '(today | overdue) & !assigned to: others',
+                cursor: undefined,
+                limit: 50,
+            });
             const structuredContent = extractStructuredContent(result);
             // Should only return tasks 1 and 2, not task 3
             expect(structuredContent.tasks).toHaveLength(2);
@@ -371,6 +384,7 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             ]);
         });
         it('should filter overdue results to show only unassigned tasks or tasks assigned to current user', async () => {
+            // Backend filtering: API should only return unassigned + assigned to me
             const mockTasks = [
                 createMappedTask({
                     id: TEST_IDS.TASK_1,
@@ -384,16 +398,22 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
                     dueDate: '2025-08-10',
                     responsibleUid: null, // Unassigned
                 }),
-                createMappedTask({
-                    id: TEST_IDS.TASK_3,
-                    content: 'Someone else overdue task',
-                    dueDate: '2025-08-10',
-                    responsibleUid: 'other-user-id', // Assigned to someone else
-                }),
             ];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasksByDate.execute({ overdueOption: 'overdue-only', daysCount: 1, limit: 50 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({
+                overdueOption: 'overdue-only',
+                daysCount: 1,
+                limit: 50,
+                responsibleUserFiltering: 'unassignedOrMe',
+            }, mockTodoistApi);
+            // Verify the query includes the assignment filter
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: 'overdue & !assigned to: others',
+                cursor: undefined,
+                limit: 50,
+            });
             const structuredContent = extractStructuredContent(result);
             // Should only return tasks 1 and 2, not task 3
             expect(structuredContent.tasks).toHaveLength(2);
@@ -403,6 +423,84 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             ]);
         });
     });
+    describe('responsibleUser parameter', () => {
+        it('should filter tasks by specific user email', async () => {
+            mockResolveUserNameToId.mockResolvedValue({
+                userId: 'user-123',
+                displayName: 'John Doe',
+                email: 'john@example.com',
+            });
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task assigned to John',
+                    dueDate: '2025-08-15',
+                    responsibleUid: 'user-123',
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute({
+                startDate: 'today',
+                daysCount: 1,
+                limit: 50,
+                responsibleUser: 'john@example.com',
+            }, mockTodoistApi);
+            expect(mockResolveUserNameToId).toHaveBeenCalledWith(mockTodoistApi, 'john@example.com');
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: '(today | overdue) & assigned to: john@example.com',
+                cursor: undefined,
+                limit: 50,
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toContain('assigned to john@example.com');
+            expect(textContent).toMatchSnapshot();
+        });
+        it('should throw error when user cannot be resolved', async () => {
+            mockResolveUserNameToId.mockResolvedValue(null);
+            await expect(findTasksByDate.execute({
+                startDate: 'today',
+                daysCount: 1,
+                limit: 50,
+                responsibleUser: 'nonexistent@example.com',
+            }, mockTodoistApi)).rejects.toThrow('Could not find user: "nonexistent@example.com". Make sure the user is a collaborator on a shared project.');
+        });
+        it('should combine responsibleUser with labels and date filters', async () => {
+            mockResolveUserNameToId.mockResolvedValue({
+                userId: 'user-789',
+                displayName: 'Bob Wilson',
+                email: 'bob@example.com',
+            });
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Important task for Bob',
+                    dueDate: '2025-08-20',
+                    responsibleUid: 'user-789',
+                    labels: ['urgent'],
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            await findTasksByDate.execute({
+                startDate: '2025-08-20',
+                daysCount: 1,
+                limit: 50,
+                responsibleUser: 'bob@example.com',
+                labels: ['urgent'],
+            }, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.stringContaining('2025-08-20'),
+                cursor: undefined,
+                limit: 50,
+            });
+            const call = mockGetTasksByFilter.mock.calls[0]?.[0];
+            expect(call?.query).toContain('(@urgent)');
+            expect(call?.query).toContain('assigned to: bob@example.com');
+        });
+    });
     describe('error handling', () => {
         it.each([
             {

package/dist/tools/__tests__/find-tasks.test.js

@@ -697,6 +697,7 @@ End of test content.`;
                 mockResolveUserNameToId.mockResolvedValue({
                     userId: 'specific-user-id',
                     displayName: 'John Doe',
+                    email: 'john@example.com',
                 });
                 const result = await findTasks.execute({ searchText: 'task', responsibleUser: 'John Doe', limit: 10 }, mockTodoistApi);
                 const structuredContent = extractStructuredContent(result);
@@ -726,6 +727,7 @@ End of test content.`;
                 mockResolveUserNameToId.mockResolvedValue({
                     userId: 'specific-user-id',
                     displayName: 'John Doe',
+                    email: 'john@example.com',
                 });
                 const result = await findTasks.execute({ projectId: TEST_IDS.PROJECT_WORK, responsibleUser: 'John Doe', limit: 10 }, mockTodoistApi);
                 const structuredContent = extractStructuredContent(result);

package/dist/tools/add-projects.d.ts

@@ -10,22 +10,22 @@ declare const addProjects: {
             viewStyle: z.ZodOptional<z.ZodEnum<["list", "board", "calendar"]>>;
         }, "strip", z.ZodTypeAny, {
             name: string;
-            parentId?: string | undefined;
             isFavorite?: boolean | undefined;
             viewStyle?: "list" | "board" | "calendar" | undefined;
+            parentId?: string | undefined;
         }, {
             name: string;
-            parentId?: string | undefined;
             isFavorite?: boolean | undefined;
             viewStyle?: "list" | "board" | "calendar" | undefined;
+            parentId?: string | undefined;
         }>, "many">;
     };
     execute({ projects }: {
         projects: {
             name: string;
-            parentId?: string | undefined;
             isFavorite?: boolean | undefined;
             viewStyle?: "list" | "board" | "calendar" | undefined;
+            parentId?: string | undefined;
         }[];
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {

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

@@ -18,8 +18,8 @@ declare const addTasks: {
         }, "strip", z.ZodTypeAny, {
             content: string;
             description?: string | undefined;
-            projectId?: string | undefined;
             parentId?: string | undefined;
+            projectId?: string | undefined;
             sectionId?: string | undefined;
             labels?: string[] | undefined;
             duration?: string | undefined;
@@ -29,8 +29,8 @@ declare const addTasks: {
         }, {
             content: string;
             description?: string | undefined;
-            projectId?: string | undefined;
             parentId?: string | undefined;
+            projectId?: string | undefined;
             sectionId?: string | undefined;
             labels?: string[] | undefined;
             duration?: string | undefined;
@@ -43,8 +43,8 @@ declare const addTasks: {
         tasks: {
             content: string;
             description?: string | undefined;
-            projectId?: string | undefined;
             parentId?: string | undefined;
+            projectId?: string | undefined;
             sectionId?: string | undefined;
             labels?: string[] | undefined;
             duration?: string | undefined;
@@ -72,6 +72,9 @@ declare const addTasks: {
                 duration: string | null;
                 responsibleUid: string | null;
                 assignedByUid: string | null;
+                checked: boolean;
+                completedAt: string | null;
+                updatedAt: string | null;
             }[];
             totalCount: number;
         };

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

@@ -1 +1 @@
-{"version":3,"file":"add-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/add-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAClF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqDvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAA;AAgI1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"add-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/add-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAClF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqDvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAA;AAgI1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/delete-object.d.ts

@@ -7,8 +7,8 @@ declare const deleteObject: {
         id: z.ZodString;
     };
     execute(args: {
-        type: "task" | "comment" | "project" | "section";
         id: string;
+        type: "task" | "comment" | "project" | "section";
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";

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

@@ -12,21 +12,23 @@ declare const findCompletedTasks: {
         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: {
-        getBy: "completion" | "due";
+        limit: number;
+        getBy: "due" | "completion";
         since: string;
         until: string;
-        limit: number;
-        labels?: string[] | undefined;
-        labelsOperator?: "and" | "or" | undefined;
+        parentId?: string | undefined;
         workspaceId?: string | undefined;
         projectId?: string | undefined;
         sectionId?: string | undefined;
-        parentId?: string | undefined;
+        labels?: string[] | undefined;
         cursor?: string | undefined;
+        responsibleUser?: string | undefined;
+        labelsOperator?: "and" | "or" | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
@@ -47,22 +49,26 @@ declare const findCompletedTasks: {
                 duration: string | null;
                 responsibleUid: string | null;
                 assignedByUid: string | null;
+                checked: boolean;
+                completedAt: string | null;
+                updatedAt: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
             hasMore: boolean;
             appliedFilters: {
-                getBy: "completion" | "due";
+                limit: number;
+                getBy: "due" | "completion";
                 since: string;
                 until: string;
-                limit: number;
-                labels?: string[] | undefined;
-                labelsOperator?: "and" | "or" | undefined;
+                parentId?: string | undefined;
                 workspaceId?: string | undefined;
                 projectId?: string | undefined;
                 sectionId?: string | undefined;
-                parentId?: string | undefined;
+                labels?: string[] | undefined;
                 cursor?: string | undefined;
+                responsibleUser?: string | undefined;
+                labelsOperator?: "and" | "or" | undefined;
             };
         };
     } | {

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

@@ -1 +1 @@
-{"version":3,"file":"find-completed-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-completed-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiDvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDkB,CAAA;AAmE1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}
+{"version":3,"file":"find-completed-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-completed-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsDvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEkB,CAAA;AA2E1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { appendToQuery, resolveResponsibleUser } from '../filter-helpers.js';
 import { getToolOutput } from '../mcp-helpers.js';
 import { mapTask } from '../tool-helpers.js';
 import { ApiLimits } from '../utils/constants.js';
@@ -25,6 +26,10 @@ const ArgsSchema = {
     projectId: z.string().optional().describe('The ID of the project to get the tasks for.'),
     sectionId: z.string().optional().describe('The ID of the section to get the tasks for.'),
     parentId: z.string().optional().describe('The ID of the parent task to get the tasks for.'),
+    responsibleUser: z
+        .string()
+        .optional()
+        .describe('Find tasks assigned to this user. Can be a user ID, name, or email address.'),
     limit: z
         .number()
         .int()
@@ -43,8 +48,16 @@ const findCompletedTasks = {
     description: 'Get completed tasks.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        const { getBy, labels, labelsOperator, since, until, ...rest } = args;
+        const { getBy, labels, labelsOperator, since, until, responsibleUser, ...rest } = args;
+        // Resolve assignee name to user ID if provided
+        const resolved = await resolveResponsibleUser(client, responsibleUser);
+        const assigneeEmail = resolved?.email;
+        // Build combined filter query (labels + assignment)
         const labelsFilter = generateLabelsFilter(labels, labelsOperator);
+        let filterQuery = labelsFilter;
+        if (resolved && assigneeEmail) {
+            filterQuery = appendToQuery(filterQuery, `assigned to: ${assigneeEmail}`);
+        }
         // Get user timezone to convert local dates to UTC
         const user = await client.getUser();
         const userGmtOffset = user.tzInfo?.gmtString || '+00:00';
@@ -60,19 +73,20 @@ const findCompletedTasks = {
                 ...rest,
                 since: sinceDateTime,
                 until: untilDateTime,
-                ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
+                ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),
             })
             : await client.getCompletedTasksByDueDate({
                 ...rest,
                 since: sinceDateTime,
                 until: untilDateTime,
-                ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
+                ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),
             });
         const mappedTasks = items.map(mapTask);
         const textContent = generateTextContent({
             tasks: mappedTasks,
             args,
             nextCursor,
+            assigneeEmail,
         });
         return getToolOutput({
             textContent,
@@ -86,7 +100,7 @@ const findCompletedTasks = {
         });
     },
 };
-function generateTextContent({ tasks, args, nextCursor, }) {
+function generateTextContent({ tasks, args, nextCursor, assigneeEmail, }) {
     // Generate subject description
     const getByText = args.getBy === 'completion' ? 'completed' : 'due';
     const subject = `Completed tasks (by ${getByText} date)`;
@@ -108,6 +122,11 @@ function generateTextContent({ tasks, args, nextCursor, }) {
             .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 helpful suggestions for empty results
     const zeroReasonHints = [];
     if (tasks.length === 0) {

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

@@ -10,12 +10,16 @@ declare const findTasksByDate: {
         daysCount: z.ZodDefault<z.ZodNumber>;
         limit: z.ZodDefault<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodString>;
+        responsibleUser: z.ZodOptional<z.ZodString>;
+        responsibleUserFiltering: z.ZodOptional<z.ZodEnum<["assigned", "unassignedOrMe", "all"]>>;
     };
     execute(args: {
         limit: number;
         daysCount: number;
+        responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
         labels?: string[] | undefined;
         cursor?: string | undefined;
+        responsibleUser?: string | undefined;
         labelsOperator?: "and" | "or" | undefined;
         startDate?: string | undefined;
         overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | undefined;
@@ -39,6 +43,9 @@ declare const findTasksByDate: {
                 duration: string | null;
                 responsibleUid: string | null;
                 assignedByUid: string | null;
+                checked: boolean;
+                completedAt: string | null;
+                updatedAt: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
@@ -46,8 +53,10 @@ declare const findTasksByDate: {
             appliedFilters: {
                 limit: number;
                 daysCount: number;
+                responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
                 labels?: string[] | undefined;
                 cursor?: string | undefined;
+                responsibleUser?: string | undefined;
                 labelsOperator?: "and" | "or" | undefined;
                 startDate?: string | undefined;
                 overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | 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;AAmDvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEqB,CAAA;AAwF1C,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;AAmEvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EqB,CAAA;AAsG1C,OAAO,EAAE,eAAe,EAAE,CAAA"}

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

@@ -1,7 +1,8 @@
 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 { filterTasksByResponsibleUser, getTasksByFilter } from '../tool-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';
@@ -34,6 +35,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).'),
+    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 = {
@@ -44,14 +53,18 @@ const findTasksByDate = {
         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 = '';
-        const todoistUser = await client.getUser();
         if (args.overdueOption === 'overdue-only') {
             query = 'overdue';
         }
         else if (args.startDate === 'today') {
             // For 'today', include overdue unless explicitly excluded
-            query = args.overdueOption === 'exclude-overdue' ? 'today' : 'today | overdue';
+            // 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
@@ -60,30 +73,31 @@ const findTasksByDate = {
             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) {
-            // 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})`;
+            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,
         });
-        // Apply responsible user filtering - only show unassigned tasks or tasks assigned to current user
-        const filteredTasks = filterTasksByResponsibleUser({
-            tasks: result.tasks,
-            resolvedAssigneeId: undefined,
-            currentUserId: todoistUser.id,
-        });
+        // 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,
@@ -97,7 +111,7 @@ const findTasksByDate = {
         });
     },
 };
-function generateTextContent({ tasks, args, nextCursor, }) {
+function generateTextContent({ tasks, args, nextCursor, assigneeEmail, }) {
     // Generate filter description
     const filterHints = [];
     if (args.overdueOption === 'overdue-only') {
@@ -120,6 +134,11 @@ function generateTextContent({ tasks, args, nextCursor, }) {
             .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') {
@@ -135,6 +154,11 @@ function generateTextContent({ tasks, args, nextCursor, }) {
     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) {

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

@@ -16,9 +16,9 @@ declare const findTasks: {
     };
     execute(args: {
         limit: number;
-        projectId?: string | undefined;
         parentId?: string | undefined;
         responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
+        projectId?: string | undefined;
         sectionId?: string | undefined;
         labels?: string[] | undefined;
         cursor?: string | undefined;
@@ -45,15 +45,18 @@ declare const findTasks: {
                 duration: string | null;
                 responsibleUid: string | null;
                 assignedByUid: string | null;
+                checked: boolean;
+                completedAt: string | null;
+                updatedAt: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
             hasMore: boolean;
             appliedFilters: {
                 limit: number;
-                projectId?: string | undefined;
                 parentId?: string | undefined;
                 responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
+                projectId?: string | undefined;
                 sectionId?: string | undefined;
                 labels?: string[] | undefined;
                 cursor?: string | undefined;