@doist/todoist-ai 4.9.4 → 4.11.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__/search.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=search.test.d.ts.map

package/dist/tools/__tests__/search.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.test.d.ts","sourceRoot":"","sources":["../../../src/tools/__tests__/search.test.ts"],"names":[],"mappings":""}

package/dist/tools/__tests__/search.test.js

@@ -0,0 +1,208 @@
+import { jest } from '@jest/globals';
+import { getTasksByFilter } from '../../tool-helpers.js';
+import { createMappedTask, createMockApiResponse, createMockProject, TEST_IDS, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { search } from '../search.js';
+jest.mock('../../tool-helpers', () => {
+    const actual = jest.requireActual('../../tool-helpers');
+    return {
+        getTasksByFilter: jest.fn(),
+        buildTodoistUrl: actual.buildTodoistUrl,
+    };
+});
+const { SEARCH } = ToolNames;
+const mockGetTasksByFilter = getTasksByFilter;
+// Mock the Todoist API
+const mockTodoistApi = {
+    getProjects: jest.fn(),
+};
+describe(`${SEARCH} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('searching tasks and projects', () => {
+        it('should search both tasks and projects and return combined results', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Important meeting task',
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_2,
+                    content: 'Another important item',
+                }),
+            ];
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Important Work Project',
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'Test Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'important' }, mockTodoistApi);
+            // Verify both API calls were made
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: 'search: important',
+                limit: 100, // TASKS_MAX
+                cursor: undefined,
+            });
+            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
+                limit: 100, // PROJECTS_MAX
+            });
+            // Verify result structure
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+            // Parse the JSON response
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toHaveProperty('results');
+            expect(jsonResponse.results).toHaveLength(3); // 2 tasks + 1 project matching "important"
+            // Verify task results
+            expect(jsonResponse.results[0]).toEqual({
+                id: `task:${TEST_IDS.TASK_1}`,
+                title: 'Important meeting task',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_1}`,
+            });
+            expect(jsonResponse.results[1]).toEqual({
+                id: `task:${TEST_IDS.TASK_2}`,
+                title: 'Another important item',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_2}`,
+            });
+            // Verify project result (only "Important Work Project" matches)
+            expect(jsonResponse.results[2]).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Important Work Project',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+            });
+        });
+        it('should return only matching tasks when no projects match', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Unique task content',
+                }),
+            ];
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Work Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'unique' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0].id).toBe(`task:${TEST_IDS.TASK_1}`);
+        });
+        it('should return only matching projects when no tasks match', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Special Project Name',
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'Another Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'special' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0]).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Special Project Name',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+            });
+        });
+        it('should return empty results when nothing matches', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'nonexistent' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(0);
+        });
+        it('should perform case-insensitive project filtering', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Important Work',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'IMPORTANT' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0].title).toBe('Important Work');
+        });
+        it('should handle partial matches in project names', async () => {
+            const mockProjects = [
+                createMockProject({ id: 'project-1', name: 'Development Tasks' }),
+                createMockProject({ id: 'project-2', name: 'Developer Resources' }),
+                createMockProject({ id: 'project-3', name: 'Marketing' }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'develop' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(2);
+            expect(jsonResponse.results[0].title).toBe('Development Tasks');
+            expect(jsonResponse.results[1].title).toBe('Developer Resources');
+        });
+    });
+    describe('error handling', () => {
+        it('should return error response for task search failure', async () => {
+            mockGetTasksByFilter.mockRejectedValue(new Error('Task search failed'));
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Task search failed');
+        });
+        it('should return error response for project search failure', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockRejectedValue(new Error('Project search failed'));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Project search failed');
+        });
+    });
+    describe('OpenAI MCP spec compliance', () => {
+        it('should return exactly one content item with type "text"', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+        });
+        it('should return valid JSON string in text field', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(() => JSON.parse(result.content[0]?.text ?? '{}')).not.toThrow();
+        });
+        it('should include required fields (id, title, url) in each result', async () => {
+            const mockTasks = [createMappedTask({ id: TEST_IDS.TASK_1, content: 'Test' })];
+            const mockProjects = [createMockProject({ id: TEST_IDS.PROJECT_WORK, name: 'Test' })];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            for (const item of jsonResponse.results) {
+                expect(item).toHaveProperty('id');
+                expect(item).toHaveProperty('title');
+                expect(item).toHaveProperty('url');
+                expect(typeof item.id).toBe('string');
+                expect(typeof item.title).toBe('string');
+                expect(typeof item.url).toBe('string');
+            }
+        });
+    });
+});

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;AA2CvB,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/add-tasks.js

@@ -7,8 +7,14 @@ import { convertPriorityToNumber, PrioritySchema } from '../utils/priorities.js'
 import { generateTaskNextSteps, getDateString, summarizeTaskOperation, } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const TaskSchema = z.object({
-    content: z.string().min(1).describe('The content of the task to create.'),
-    description: z.string().optional().describe('The description of the task.'),
+    content: z
+        .string()
+        .min(1)
+        .describe('The task name/title. Should be concise and actionable (e.g., "Review PR #123", "Call dentist"). For longer content, use the description field instead. Supports Markdown.'),
+    description: z
+        .string()
+        .optional()
+        .describe('Additional details, notes, or context for the task. Use this for longer content rather than putting it in the task name. Supports Markdown.'),
     priority: PrioritySchema.optional().describe('The priority of the task: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default).'),
     dueString: z.string().optional().describe('The due date for the task, in natural language.'),
     duration: z

package/dist/tools/fetch.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+type FetchToolOutput = {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: boolean;
+};
+/**
+ * OpenAI MCP fetch tool - retrieves the full contents of a task or project by ID.
+ *
+ * This tool follows the OpenAI MCP fetch tool specification:
+ * @see https://platform.openai.com/docs/mcp#fetch-tool
+ */
+declare const fetch: {
+    name: "fetch";
+    description: string;
+    parameters: {
+        id: z.ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<FetchToolOutput>;
+};
+export { fetch };
+//# sourceMappingURL=fetch.d.ts.map

package/dist/tools/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/tools/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,KAAK,eAAe,GAAG;IACnB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,QAAA,MAAM,KAAK;;;;;;;;oEAKsB,OAAO,CAAC,eAAe,CAAC;CAsFf,CAAA;AAE1C,OAAO,EAAE,KAAK,EAAE,CAAA"}

package/dist/tools/fetch.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { getErrorOutput } from '../mcp-helpers.js';
+import { buildTodoistUrl, mapProject, mapTask } from '../tool-helpers.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    id: z
+        .string()
+        .min(1)
+        .describe('A unique identifier for the document in the format "task:{id}" or "project:{id}".'),
+};
+/**
+ * OpenAI MCP fetch tool - retrieves the full contents of a task or project by ID.
+ *
+ * This tool follows the OpenAI MCP fetch tool specification:
+ * @see https://platform.openai.com/docs/mcp#fetch-tool
+ */
+const fetch = {
+    name: ToolNames.FETCH,
+    description: 'Fetch the full contents of a task or project by its ID. The ID should be in the format "task:{id}" or "project:{id}".',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        try {
+            const { id } = args;
+            // Parse the composite ID
+            const [type, objectId] = id.split(':', 2);
+            if (!objectId || (type !== 'task' && type !== 'project')) {
+                throw new Error('Invalid ID format. Expected "task:{id}" or "project:{id}". Example: "task:8485093748" or "project:6cfCcrrCFg2xP94Q"');
+            }
+            let result;
+            if (type === 'task') {
+                // Fetch task
+                const task = await client.getTask(objectId);
+                const mappedTask = mapTask(task);
+                // Build text content
+                const textParts = [mappedTask.content];
+                if (mappedTask.description) {
+                    textParts.push(`\n\nDescription: ${mappedTask.description}`);
+                }
+                if (mappedTask.dueDate) {
+                    textParts.push(`\nDue: ${mappedTask.dueDate}`);
+                }
+                if (mappedTask.labels.length > 0) {
+                    textParts.push(`\nLabels: ${mappedTask.labels.join(', ')}`);
+                }
+                result = {
+                    id: `task:${mappedTask.id}`,
+                    title: mappedTask.content,
+                    text: textParts.join(''),
+                    url: buildTodoistUrl('task', mappedTask.id),
+                    metadata: {
+                        priority: mappedTask.priority,
+                        projectId: mappedTask.projectId,
+                        sectionId: mappedTask.sectionId,
+                        parentId: mappedTask.parentId,
+                        recurring: mappedTask.recurring,
+                        duration: mappedTask.duration,
+                        responsibleUid: mappedTask.responsibleUid,
+                        assignedByUid: mappedTask.assignedByUid,
+                    },
+                };
+            }
+            else {
+                // Fetch project
+                const project = await client.getProject(objectId);
+                const mappedProject = mapProject(project);
+                // Build text content
+                const textParts = [mappedProject.name];
+                if (mappedProject.isShared) {
+                    textParts.push('\n\nShared project');
+                }
+                if (mappedProject.isFavorite) {
+                    textParts.push('\nFavorite: Yes');
+                }
+                result = {
+                    id: `project:${mappedProject.id}`,
+                    title: mappedProject.name,
+                    text: textParts.join(''),
+                    url: buildTodoistUrl('project', mappedProject.id),
+                    metadata: {
+                        color: mappedProject.color,
+                        isFavorite: mappedProject.isFavorite,
+                        isShared: mappedProject.isShared,
+                        parentId: mappedProject.parentId,
+                        inboxProject: mappedProject.inboxProject,
+                        viewStyle: mappedProject.viewStyle,
+                    },
+                };
+            }
+            // Return as JSON-encoded string in a text content item (OpenAI MCP spec)
+            const jsonText = JSON.stringify(result);
+            return { content: [{ type: 'text', text: jsonText }] };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'An unknown error occurred';
+            return getErrorOutput(message);
+        }
+    },
+};
+export { fetch };

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

@@ -16,17 +16,17 @@ declare const findCompletedTasks: {
         cursor: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
-        limit: number;
-        getBy: "due" | "completion";
+        getBy: "completion" | "due";
         since: string;
         until: string;
-        projectId?: string | undefined;
-        parentId?: string | undefined;
+        limit: number;
+        labels?: string[] | undefined;
+        labelsOperator?: "and" | "or" | undefined;
         workspaceId?: string | undefined;
+        projectId?: string | undefined;
         sectionId?: string | undefined;
-        labels?: string[] | undefined;
+        parentId?: string | undefined;
         cursor?: string | undefined;
-        labelsOperator?: "and" | "or" | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
@@ -52,17 +52,17 @@ declare const findCompletedTasks: {
             totalCount: number;
             hasMore: boolean;
             appliedFilters: {
-                limit: number;
-                getBy: "due" | "completion";
+                getBy: "completion" | "due";
                 since: string;
                 until: string;
-                projectId?: string | undefined;
-                parentId?: string | undefined;
+                limit: number;
+                labels?: string[] | undefined;
+                labelsOperator?: "and" | "or" | undefined;
                 workspaceId?: string | undefined;
+                projectId?: string | undefined;
                 sectionId?: string | undefined;
-                labels?: string[] | undefined;
+                parentId?: string | undefined;
                 cursor?: 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;AAiDvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDkB,CAAA;AAmE1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

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

@@ -43,15 +43,29 @@ const findCompletedTasks = {
     description: 'Get completed tasks.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        const { getBy, labels, labelsOperator, ...rest } = args;
+        const { getBy, labels, labelsOperator, since, until, ...rest } = args;
         const labelsFilter = generateLabelsFilter(labels, labelsOperator);
+        // 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,
+                since: sinceDateTime,
+                until: untilDateTime,
                 ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
             })
             : await client.getCompletedTasksByDueDate({
                 ...rest,
+                since: sinceDateTime,
+                until: untilDateTime,
                 ...(labelsFilter ? { filterQuery: labelsFilter, filterLang: 'en' } : {}),
             });
         const mappedTasks = items.map(mapTask);

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

@@ -9,8 +9,8 @@ declare const findProjects: {
     };
     execute(args: {
         limit: number;
-        cursor?: string | undefined;
         search?: string | undefined;
+        cursor?: string | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
@@ -32,8 +32,8 @@ declare const findProjects: {
             hasMore: boolean;
             appliedFilters: {
                 limit: number;
-                cursor?: string | undefined;
                 search?: string | undefined;
+                cursor?: string | undefined;
             };
         };
     } | {

package/dist/tools/search.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+type SearchToolOutput = {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: boolean;
+};
+/**
+ * OpenAI MCP search tool - returns a list of relevant search results from Todoist.
+ *
+ * This tool follows the OpenAI MCP search tool specification:
+ * @see https://platform.openai.com/docs/mcp#search-tool
+ */
+declare const search: {
+    name: "search";
+    description: string;
+    parameters: {
+        query: z.ZodString;
+    };
+    execute(args: {
+        query: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<SearchToolOutput>;
+};
+export { search };
+//# sourceMappingURL=search.d.ts.map

package/dist/tools/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/tools/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,KAAK,gBAAgB,GAAG;IACpB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,QAAA,MAAM,MAAM;;;;;;;;oEAKqB,OAAO,CAAC,gBAAgB,CAAC;CAmDhB,CAAA;AAE1C,OAAO,EAAE,MAAM,EAAE,CAAA"}