@doist/todoist-ai 2.0.0 → 2.1.0

package/dist/tools/__tests__/tasks-update-one.test.js

@@ -0,0 +1,251 @@
+import { jest } from '@jest/globals';
+import { tasksUpdateOne } from '../tasks-update-one.js';
+import { createMockTask } from '../test-helpers.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    updateTask: jest.fn(),
+    moveTasks: jest.fn(),
+};
+describe('tasks-update-one tool', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('updating task properties', () => {
+        it('should update task content and description', async () => {
+            // Mock API response extracted from recordings (Task type)
+            const mockApiResponse = createMockTask({
+                id: '8485093748',
+                content: 'Updated task content',
+                description: 'Updated task description',
+                url: 'https://todoist.com/showTask?id=8485093748',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
+            const result = await tasksUpdateOne.execute({
+                id: '8485093748',
+                content: 'Updated task content',
+                description: 'Updated task description',
+            }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093748', {
+                content: 'Updated task content',
+                description: 'Updated task description',
+            });
+            // Verify result matches API response
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should update task priority and due date', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093749',
+                content: 'Original task content',
+                labels: ['urgent'],
+                priority: 3,
+                url: 'https://todoist.com/showTask?id=8485093749',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+                due: {
+                    date: '2025-08-20',
+                    isRecurring: false,
+                    lang: 'en',
+                    string: 'Aug 20',
+                    timezone: null,
+                },
+            });
+            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
+            const result = await tasksUpdateOne.execute({ id: '8485093749', priority: 3, dueString: 'Aug 20' }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093749', {
+                priority: 3,
+                dueString: 'Aug 20',
+            });
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should move task to different project', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093750',
+                content: 'Task to move',
+                projectId: 'new-project-id',
+                url: 'https://todoist.com/showTask?id=8485093750',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.moveTasks.mockResolvedValue([mockApiResponse]);
+            const result = await tasksUpdateOne.execute({ id: '8485093750', projectId: 'new-project-id' }, mockTodoistApi);
+            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093750'], {
+                projectId: 'new-project-id',
+            });
+            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should update task parent (create subtask relationship)', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093751',
+                content: 'Subtask content',
+                parentId: 'parent-task-123',
+                url: 'https://todoist.com/showTask?id=8485093751',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.moveTasks.mockResolvedValue([mockApiResponse]);
+            const result = await tasksUpdateOne.execute({ id: '8485093751', parentId: 'parent-task-123' }, mockTodoistApi);
+            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093751'], {
+                parentId: 'parent-task-123',
+            });
+            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should move task and update properties at once', async () => {
+            const movedTask = createMockTask({
+                id: '8485093752',
+                content: 'Task to move',
+                projectId: 'different-project-id',
+            });
+            const updatedTask = createMockTask({
+                id: '8485093752',
+                content: 'Completely updated task',
+                description: 'New description with details',
+                priority: 4,
+                projectId: 'different-project-id',
+                url: 'https://todoist.com/showTask?id=8485093752',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+                due: {
+                    date: '2025-08-25',
+                    isRecurring: true,
+                    lang: 'en',
+                    string: 'every Friday',
+                    timezone: null,
+                },
+            });
+            mockTodoistApi.moveTasks.mockResolvedValue([movedTask]);
+            mockTodoistApi.updateTask.mockResolvedValue(updatedTask);
+            const result = await tasksUpdateOne.execute({
+                id: '8485093752',
+                content: 'Completely updated task',
+                description: 'New description with details',
+                priority: 4,
+                dueString: 'every Friday',
+                projectId: 'different-project-id',
+            }, mockTodoistApi);
+            // Should call moveTasks first for the projectId
+            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093752'], {
+                projectId: 'different-project-id',
+            });
+            // Then call updateTask for the other properties
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093752', {
+                content: 'Completely updated task',
+                description: 'New description with details',
+                priority: 4,
+                dueString: 'every Friday',
+            });
+            expect(result).toEqual(updatedTask);
+        });
+        it('should update task duration', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093753',
+                content: 'Task with updated duration',
+                duration: { amount: 150, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093753',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
+            const result = await tasksUpdateOne.execute({
+                id: '8485093753',
+                duration: '2h30m',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093753', {
+                duration: 150,
+                durationUnit: 'minute',
+            });
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should handle various duration formats', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093754',
+                content: 'Test task',
+                duration: { amount: 120, unit: 'minute' },
+            });
+            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
+            // Test different duration formats
+            const testCases = [
+                { input: '2h', expectedMinutes: 120 },
+                { input: '90m', expectedMinutes: 90 },
+                { input: '1.5h', expectedMinutes: 90 },
+                { input: ' 2h 30m ', expectedMinutes: 150 },
+                { input: '2H30M', expectedMinutes: 150 },
+            ];
+            for (const testCase of testCases) {
+                mockTodoistApi.updateTask.mockClear();
+                await tasksUpdateOne.execute({
+                    id: '8485093754',
+                    duration: testCase.input,
+                }, mockTodoistApi);
+                expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093754', expect.objectContaining({
+                    duration: testCase.expectedMinutes,
+                    durationUnit: 'minute',
+                }));
+            }
+        });
+        it('should update task with duration and move at once', async () => {
+            const movedTask = createMockTask({
+                id: '8485093755',
+                content: 'Task to move and update',
+                projectId: 'new-project-id',
+            });
+            const updatedTask = createMockTask({
+                id: '8485093755',
+                content: 'Updated task with duration',
+                duration: { amount: 120, unit: 'minute' },
+                projectId: 'new-project-id',
+            });
+            mockTodoistApi.moveTasks.mockResolvedValue([movedTask]);
+            mockTodoistApi.updateTask.mockResolvedValue(updatedTask);
+            const result = await tasksUpdateOne.execute({
+                id: '8485093755',
+                content: 'Updated task with duration',
+                duration: '2h',
+                projectId: 'new-project-id',
+            }, mockTodoistApi);
+            // Should call moveTasks first
+            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093755'], {
+                projectId: 'new-project-id',
+            });
+            // Then call updateTask with duration
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093755', {
+                content: 'Updated task with duration',
+                duration: 120,
+                durationUnit: 'minute',
+            });
+            expect(result).toEqual(updatedTask);
+        });
+    });
+    describe('error handling', () => {
+        it('should throw error for invalid duration format', async () => {
+            await expect(tasksUpdateOne.execute({
+                id: '8485093756',
+                duration: 'invalid',
+            }, mockTodoistApi)).rejects.toThrow('Task 8485093756: Invalid duration format "invalid"');
+        });
+        it('should throw error for duration exceeding 24 hours', async () => {
+            await expect(tasksUpdateOne.execute({
+                id: '8485093757',
+                duration: '25h',
+            }, mockTodoistApi)).rejects.toThrow('Task 8485093757: Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
+        });
+        it('should throw error when multiple move parameters are provided', async () => {
+            await expect(tasksUpdateOne.execute({ id: '8485093748', projectId: 'new-project', sectionId: 'new-section' }, mockTodoistApi)).rejects.toThrow('Only one of projectId, sectionId, or parentId can be specified at a time. ' +
+                'The Todoist API requires exactly one destination for move operations.');
+        });
+        it('should throw error when all three move parameters are provided', async () => {
+            await expect(tasksUpdateOne.execute({ id: '8485093748', projectId: 'p1', sectionId: 's1', parentId: 't1' }, mockTodoistApi)).rejects.toThrow('Only one of projectId, sectionId, or parentId can be specified at a time');
+        });
+        it.each([
+            {
+                error: 'API Error: Task not found',
+                params: { id: 'non-existent-task', content: 'Updated content' },
+            },
+            {
+                error: 'API Error: Invalid priority value',
+                params: { id: '8485093748', priority: 5 },
+            },
+        ])('should propagate $error', async ({ error, params }) => {
+            mockTodoistApi.updateTask.mockRejectedValue(new Error(error));
+            await expect(tasksUpdateOne.execute(params, mockTodoistApi)).rejects.toThrow(error);
+        });
+    });
+});

package/dist/tools/delete-one.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteOne = void 0;
-const zod_1 = require("zod");
+import { z } from 'zod';
 const ArgsSchema = {
-    type: zod_1.z.enum(['project', 'section', 'task']).describe('The type of entity to delete.'),
-    id: zod_1.z.string().min(1).describe('The ID of the entity to delete.'),
+    type: z.enum(['project', 'section', 'task']).describe('The type of entity to delete.'),
+    id: z.string().min(1).describe('The ID of the entity to delete.'),
 };
 const deleteOne = {
     name: 'delete-one',
@@ -25,4 +22,4 @@ const deleteOne = {
         return { success: true };
     },
 };
-exports.deleteOne = deleteOne;
+export { deleteOne };

package/dist/tools/overview.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.overview = void 0;
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
+import { z } from 'zod';
+import { isPersonalProject, mapTask } from '../tool-helpers.js';
 const ArgsSchema = {
-    projectId: zod_1.z
+    projectId: z
         .string()
         .min(1)
         .optional()
@@ -25,7 +22,7 @@ function buildProjectTree(projects) {
         const current = byId[p.id];
         if (!current)
             continue;
-        if ((0, tool_helpers_1.isPersonalProject)(p) && p.parentId) {
+        if (isPersonalProject(p) && p.parentId) {
             const parent = byId[p.parentId];
             if (parent) {
                 parent.children.push(current);
@@ -113,7 +110,7 @@ async function getAllTasksForProject(client, projectId) {
             limit: 50,
             cursor: cursor ?? undefined,
         });
-        allTasks = allTasks.concat(results.map(tool_helpers_1.mapTask));
+        allTasks = allTasks.concat(results.map(mapTask));
         cursor = nextCursor ?? undefined;
     } while (cursor);
     return allTasks;
@@ -125,8 +122,8 @@ async function getProjectSections(client, projectId) {
 // Account overview implementation
 async function generateAccountOverview(client) {
     const { results: projects } = await client.getProjects({});
-    const inbox = projects.find((p) => (0, tool_helpers_1.isPersonalProject)(p) && p.inboxProject === true);
-    const nonInbox = projects.filter((p) => !(0, tool_helpers_1.isPersonalProject)(p) || p.inboxProject !== true);
+    const inbox = projects.find((p) => isPersonalProject(p) && p.inboxProject === true);
+    const nonInbox = projects.filter((p) => !isPersonalProject(p) || p.inboxProject !== true);
     const tree = buildProjectTree(nonInbox);
     const allProjectIds = projects.map((p) => p.id);
     const sectionsByProject = await getSectionsByProject(client, allProjectIds);
@@ -202,4 +199,4 @@ const overview = {
         return await generateAccountOverview(client);
     },
 };
-exports.overview = overview;
+export { overview };

package/dist/tools/projects-list.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectsList = void 0;
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
+import { z } from 'zod';
+import { mapProject } from '../tool-helpers.js';
 const ArgsSchema = {
-    search: zod_1.z
+    search: z
         .string()
         .optional()
         .describe('Search for a project by name (partial and case insensitive match). If omitted, all projects are returned.'),
-    limit: zod_1.z
+    limit: z
         .number()
         .int()
         .min(1)
         .max(100)
         .default(50)
         .describe('The maximum number of projects to return.'),
-    cursor: zod_1.z
+    cursor: z
         .string()
         .optional()
         .describe('The cursor to get the next page of projects (cursor is obtained from the previous call to this tool, with the same parameters).'),
@@ -34,9 +31,9 @@ const projectsList = {
             ? results.filter((project) => project.name.toLowerCase().includes(searchLower))
             : results;
         return {
-            projects: filtered.map(tool_helpers_1.mapProject),
+            projects: filtered.map(mapProject),
             nextCursor,
         };
     },
 };
-exports.projectsList = projectsList;
+export { projectsList };

package/dist/tools/projects-manage.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectsManage = void 0;
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
+import { z } from 'zod';
+import { mapProject } from '../tool-helpers.js';
 const ArgsSchema = {
-    id: zod_1.z
+    id: z
         .string()
         .min(1)
         .optional()
         .describe('The ID of the project to update. If provided, updates the project. If omitted, creates a new project.'),
-    name: zod_1.z.string().min(1).describe('The name of the project.'),
+    name: z.string().min(1).describe('The name of the project.'),
 };
 const projectsManage = {
     name: 'projects-manage',
@@ -23,7 +20,7 @@ const projectsManage = {
         }
         // Create new project
         const project = await client.addProject({ name: args.name });
-        return (0, tool_helpers_1.mapProject)(project);
+        return mapProject(project);
     },
 };
-exports.projectsManage = projectsManage;
+export { projectsManage };

package/dist/tools/sections-manage.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sectionsManage = void 0;
-const zod_1 = require("zod");
-const mcp_helpers_1 = require("../mcp-helpers");
+import { z } from 'zod';
+import { errorContent } from '../mcp-helpers.js';
 const ArgsSchema = {
-    id: zod_1.z
+    id: z
         .string()
         .min(1)
         .optional()
         .describe('The ID of the section to update. If provided, updates the section. If omitted, creates a new section.'),
-    name: zod_1.z.string().min(1).describe('The name of the section.'),
-    projectId: zod_1.z
+    name: z.string().min(1).describe('The name of the section.'),
+    projectId: z
         .string()
         .min(1)
         .optional()
@@ -28,7 +25,7 @@ const sectionsManage = {
         }
         // Create new section - projectId is required
         if (!args.projectId) {
-            return (0, mcp_helpers_1.errorContent)('Error: projectId is required when creating a new section (when id is not provided).');
+            return errorContent('Error: projectId is required when creating a new section (when id is not provided).');
         }
         const section = await client.addSection({
             name: args.name,
@@ -37,4 +34,4 @@ const sectionsManage = {
         return section;
     },
 };
-exports.sectionsManage = sectionsManage;
+export { sectionsManage };

package/dist/tools/sections-search.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sectionsSearch = void 0;
-const zod_1 = require("zod");
+import { z } from 'zod';
 const ArgsSchema = {
-    projectId: zod_1.z.string().min(1).describe('The ID of the project to search sections in.'),
-    search: zod_1.z
+    projectId: z.string().min(1).describe('The ID of the project to search sections in.'),
+    search: z
         .string()
         .optional()
         .describe('Search for a section by name (partial and case insensitive match). If omitted, all sections in the project are returned.'),
@@ -27,4 +24,4 @@ const sectionsSearch = {
         }));
     },
 };
-exports.sectionsSearch = sectionsSearch;
+export { sectionsSearch };

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

@@ -11,16 +11,19 @@ declare const tasksAddMultiple: {
             description: z.ZodOptional<z.ZodString>;
             priority: z.ZodOptional<z.ZodNumber>;
             dueString: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             content: string;
             description?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
+            duration?: string | undefined;
         }, {
             content: string;
             description?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
+            duration?: string | undefined;
         }>, "many">;
     };
     execute(args: {
@@ -29,6 +32,7 @@ declare const tasksAddMultiple: {
             description?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
+            duration?: string | undefined;
         }[];
         parentId?: string | undefined;
         projectId?: string | undefined;
@@ -44,6 +48,7 @@ declare const tasksAddMultiple: {
         sectionId: string | null;
         parentId: string | null;
         labels: string[];
+        duration: string | null;
     }[]>;
 };
 export { tasksAddMultiple };

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

@@ -1 +1 @@
-{"version":3,"file":"tasks-add-multiple.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-add-multiple.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaoB,CAAA;AAE1C,OAAO,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"tasks-add-multiple.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-add-multiple.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAyBvB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCoB,CAAA;AAE1C,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/tools/tasks-add-multiple.js

@@ -1,19 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tasksAddMultiple = void 0;
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
-const TaskSchema = zod_1.z.object({
-    content: zod_1.z.string().min(1).describe('The content of the task to create.'),
-    description: zod_1.z.string().optional().describe('The description of the task.'),
-    priority: zod_1.z.number().int().min(1).max(4).optional().describe('The priority of the task (1-4).'),
-    dueString: zod_1.z.string().optional().describe('The due date for the task, in natural language.'),
+import { z } from 'zod';
+import { mapTask } from '../tool-helpers.js';
+import { DurationParseError, parseDuration } from '../utils/duration-parser.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.'),
+    priority: z.number().int().min(1).max(4).optional().describe('The priority of the task (1-4).'),
+    dueString: z.string().optional().describe('The due date for the task, in natural language.'),
+    duration: z
+        .string()
+        .optional()
+        .describe('The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'),
 });
 const ArgsSchema = {
-    projectId: zod_1.z.string().optional().describe('The project ID to add the tasks to.'),
-    sectionId: zod_1.z.string().optional().describe('The section ID to add the tasks to.'),
-    parentId: zod_1.z.string().optional().describe('The parent task ID (for subtasks).'),
-    tasks: zod_1.z.array(TaskSchema).min(1).describe('The array of tasks to add.'),
+    projectId: z.string().optional().describe('The project ID to add the tasks to.'),
+    sectionId: z.string().optional().describe('The section ID to add the tasks to.'),
+    parentId: z.string().optional().describe('The parent task ID (for subtasks).'),
+    tasks: z.array(TaskSchema).min(1).describe('The array of tasks to add.'),
 };
 const tasksAddMultiple = {
     name: 'tasks-add-multiple',
@@ -23,10 +25,28 @@ const tasksAddMultiple = {
         const { projectId, sectionId, parentId, tasks } = args;
         const newTasks = [];
         for (const task of tasks) {
-            const taskArgs = { ...task, projectId, sectionId, parentId };
+            const { duration: durationStr, ...otherTaskArgs } = task;
+            let taskArgs = { ...otherTaskArgs, projectId, sectionId, parentId };
+            // Parse duration if provided
+            if (durationStr) {
+                try {
+                    const { minutes } = parseDuration(durationStr);
+                    taskArgs = {
+                        ...taskArgs,
+                        duration: minutes,
+                        durationUnit: 'minute',
+                    };
+                }
+                catch (error) {
+                    if (error instanceof DurationParseError) {
+                        throw new Error(`Task "${task.content}": ${error.message}`);
+                    }
+                    throw error;
+                }
+            }
             newTasks.push(await client.addTask(taskArgs));
         }
-        return newTasks.map(tool_helpers_1.mapTask);
+        return newTasks.map(mapTask);
     },
 };
-exports.tasksAddMultiple = tasksAddMultiple;
+export { tasksAddMultiple };

package/dist/tools/tasks-complete-multiple.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tasksCompleteMultiple = void 0;
-const zod_1 = require("zod");
+import { z } from 'zod';
 const ArgsSchema = {
-    ids: zod_1.z.array(zod_1.z.string().min(1)).min(1).describe('The IDs of the tasks to complete.'),
+    ids: z.array(z.string().min(1)).min(1).describe('The IDs of the tasks to complete.'),
 };
 const tasksCompleteMultiple = {
     name: 'tasks-complete-multiple',
@@ -23,4 +20,4 @@ const tasksCompleteMultiple = {
         return { success: true, completed };
     },
 };
-exports.tasksCompleteMultiple = tasksCompleteMultiple;
+export { tasksCompleteMultiple };

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

@@ -25,6 +25,7 @@ declare const tasksListByDate: {
             sectionId: string | null;
             parentId: string | null;
             labels: string[];
+            duration: string | null;
         }[];
         nextCursor: string | null;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"tasks-list-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAmCvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BqB,CAAA;AAE1C,OAAO,EAAE,eAAe,EAAE,CAAA"}
+{"version":3,"file":"tasks-list-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAmCvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BqB,CAAA;AAE1C,OAAO,EAAE,eAAe,EAAE,CAAA"}

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

@@ -1,29 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tasksListByDate = void 0;
-const date_fns_1 = require("date-fns");
-const zod_1 = require("zod");
-const tool_helpers_1 = require("../tool-helpers");
+import { addDays, formatISO } from 'date-fns';
+import { z } from 'zod';
+import { getTasksByFilter } from '../tool-helpers.js';
 const ArgsSchema = {
-    startDate: zod_1.z
+    startDate: z
         .string()
         .regex(/^(\d{4}-\d{2}-\d{2}|today|overdue)$/)
         .describe("The start date to get the tasks for. Format: YYYY-MM-DD, 'today', or 'overdue'."),
-    daysCount: zod_1.z
+    daysCount: z
         .number()
         .int()
         .min(1)
         .max(30)
         .default(1)
         .describe("The number of days to get the tasks for, starting from the start date. Ignored when startDate is 'overdue'."),
-    limit: zod_1.z
+    limit: z
         .number()
         .int()
         .min(1)
         .max(50)
         .default(10)
         .describe('The maximum number of tasks to return.'),
-    cursor: zod_1.z
+    cursor: z
         .string()
         .optional()
         .describe('The cursor to get the next page of tasks (cursor is obtained from the previous call to this tool, with the same parameters).'),
@@ -39,13 +36,13 @@ const tasksListByDate = {
         }
         else {
             const startDate = args.startDate === 'today'
-                ? (0, date_fns_1.formatISO)(new Date(), { representation: 'date' })
+                ? formatISO(new Date(), { representation: 'date' })
                 : args.startDate;
-            const endDate = (0, date_fns_1.addDays)(startDate, args.daysCount + 1);
-            const endDateStr = (0, date_fns_1.formatISO)(endDate, { representation: 'date' });
+            const endDate = addDays(startDate, args.daysCount + 1);
+            const endDateStr = formatISO(endDate, { representation: 'date' });
             query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
         }
-        return await (0, tool_helpers_1.getTasksByFilter)({
+        return await getTasksByFilter({
             client,
             query,
             cursor: args.cursor,
@@ -53,4 +50,4 @@ const tasksListByDate = {
         });
     },
 };
-exports.tasksListByDate = tasksListByDate;
+export { tasksListByDate };