@doist/todoist-ai 4.10.0 → 4.13.0

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

@@ -6,11 +6,25 @@ import { findCompletedTasks } from '../find-completed-tasks.js';
 const mockTodoistApi = {
     getCompletedTasksByCompletionDate: jest.fn(),
     getCompletedTasksByDueDate: jest.fn(),
+    getUser: jest.fn(),
 };
 const { FIND_COMPLETED_TASKS } = ToolNames;
 describe(`${FIND_COMPLETED_TASKS} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        // Mock default user with UTC timezone
+        mockTodoistApi.getUser.mockResolvedValue({
+            id: 'test-user-id',
+            fullName: 'Test User',
+            email: 'test@example.com',
+            tzInfo: {
+                timezone: 'UTC',
+                gmtString: '+00:00',
+                hours: 0,
+                minutes: 0,
+                isDst: 0,
+            },
+        });
     });
     describe('getting completed tasks by completion date (default)', () => {
         it('should get completed tasks by completion date', async () => {
@@ -46,8 +60,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 labelsOperator: 'or',
             }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
-                since: '2025-08-10',
-                until: '2025-08-15',
+                since: '2025-08-10T00:00:00.000Z',
+                until: '2025-08-15T23:59:59.000Z',
                 limit: 50,
             });
             expect(extractTextContent(result)).toMatchSnapshot();
@@ -68,8 +82,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 labelsOperator: 'or',
             }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
-                since: '2025-08-01',
-                until: '2025-08-31',
+                since: '2025-08-01T00:00:00.000Z',
+                until: '2025-08-31T23:59:59.000Z',
                 projectId: 'specific-project-id',
                 limit: 100,
                 cursor: 'current-cursor',
@@ -111,8 +125,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 labelsOperator: 'or',
             }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
-                since: '2025-08-10',
-                until: '2025-08-20',
+                since: '2025-08-10T00:00:00.000Z',
+                until: '2025-08-20T23:59:59.000Z',
                 limit: 50,
             });
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).not.toHaveBeenCalled();
@@ -172,8 +186,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
             mockMethod.mockResolvedValue(mockResponse);
             const result = await findCompletedTasks.execute(params, mockTodoistApi);
             expect(mockMethod).toHaveBeenCalledWith({
-                since: params.since,
-                until: params.until,
+                since: `${params.since}T00:00:00.000Z`,
+                until: `${params.until}T23:59:59.000Z`,
                 limit: params.limit,
                 filterQuery: expectedFilter,
                 filterLang: 'en',
@@ -194,8 +208,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
             mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue(mockResponse);
             await findCompletedTasks.execute(params, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
-                since: params.since,
-                until: params.until,
+                since: `${params.since}T00:00:00.000Z`,
+                until: `${params.until}T23:59:59.000Z`,
                 limit: params.limit,
             });
         });
@@ -221,8 +235,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
             mockTodoistApi.getCompletedTasksByDueDate.mockResolvedValue(mockResponse);
             const result = await findCompletedTasks.execute(params, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
-                since: params.since,
-                until: params.until,
+                since: `${params.since}T00:00:00.000Z`,
+                until: `${params.until}T23:59:59.000Z`,
                 limit: params.limit,
                 projectId: params.projectId,
                 sectionId: params.sectionId,
@@ -233,6 +247,51 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
             expect(textContent).toMatchSnapshot();
         });
     });
+    describe('timezone handling', () => {
+        it('should convert user timezone to UTC correctly (Europe/Madrid)', async () => {
+            // Mock user with Madrid timezone
+            mockTodoistApi.getUser.mockResolvedValue({
+                id: 'test-user-id',
+                fullName: 'Test User',
+                email: 'test@example.com',
+                tzInfo: {
+                    timezone: 'Europe/Madrid',
+                    gmtString: '+02:00',
+                    hours: 2,
+                    minutes: 0,
+                    isDst: 0,
+                },
+            });
+            const mockCompletedTasks = [
+                createMockTask({
+                    id: '8485093750',
+                    content: 'Task completed in Madrid timezone',
+                    completedAt: '2025-10-11T15:30:00Z',
+                }),
+            ];
+            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
+                items: mockCompletedTasks,
+                nextCursor: null,
+            });
+            const result = await findCompletedTasks.execute({
+                getBy: 'completion',
+                limit: 50,
+                since: '2025-10-11',
+                until: '2025-10-11',
+                labels: [],
+                labelsOperator: 'or',
+            }, mockTodoistApi);
+            // Should convert Madrid local time to UTC
+            // 2025-10-11 00:00:00 +02:00 = 2025-10-10 22:00:00 UTC
+            // 2025-10-11 23:59:59 +02:00 = 2025-10-11 21:59:59 UTC
+            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
+                since: '2025-10-10T22:00:00.000Z',
+                until: '2025-10-11T21:59:59.000Z',
+                limit: 50,
+            });
+            expect(extractTextContent(result)).toMatchSnapshot();
+        });
+    });
     describe('error handling', () => {
         it('should propagate completion date API errors', async () => {
             const apiError = new Error('API Error: Invalid date range');

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,6 +12,7 @@ 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>;
     };
@@ -20,12 +21,13 @@ declare const findCompletedTasks: {
         getBy: "due" | "completion";
         since: string;
         until: string;
-        projectId?: string | undefined;
         parentId?: string | undefined;
         workspaceId?: string | undefined;
+        projectId?: string | undefined;
         sectionId?: string | undefined;
         labels?: string[] | undefined;
         cursor?: string | undefined;
+        responsibleUser?: string | undefined;
         labelsOperator?: "and" | "or" | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
@@ -47,6 +49,9 @@ 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;
@@ -56,12 +61,13 @@ declare const findCompletedTasks: {
                 getBy: "due" | "completion";
                 since: string;
                 until: string;
-                projectId?: string | undefined;
                 parentId?: string | undefined;
                 workspaceId?: string | undefined;
+                projectId?: string | undefined;
                 sectionId?: 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCkB,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,22 +48,45 @@ const findCompletedTasks = {
     description: 'Get completed tasks.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        const { getBy, labels, labelsOperator, ...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';
+        // Convert user's local date to UTC timestamps
+        // This ensures we capture the entire day from the user's perspective
+        const sinceWithOffset = `${since}T00:00:00${userGmtOffset}`;
+        const untilWithOffset = `${until}T23:59:59${userGmtOffset}`;
+        // Parse and convert to UTC
+        const sinceDateTime = new Date(sinceWithOffset).toISOString();
+        const untilDateTime = new Date(untilWithOffset).toISOString();
         const { items, nextCursor } = getBy === 'completion'
             ? await client.getCompletedTasksByCompletionDate({
                 ...rest,
-                ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
+                since: sinceDateTime,
+                until: untilDateTime,
+                ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),
             })
             : await client.getCompletedTasksByDueDate({
                 ...rest,
-                ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
+                since: sinceDateTime,
+                until: untilDateTime,
+                ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),
             });
         const mappedTasks = items.map(mapTask);
         const textContent = generateTextContent({
             tasks: mappedTasks,
             args,
             nextCursor,
+            assigneeEmail,
         });
         return getToolOutput({
             textContent,
@@ -72,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)`;
@@ -94,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"}