@doist/todoist-ai 1.1.0 → 2.0.0

package/dist/{tools/shared.test.js → tool-helpers.test.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const shared_1 = require("./shared");
+const tool_helpers_1 = require("./tool-helpers");
 describe('shared utilities', () => {
     describe('mapTask', () => {
         it('should map a basic task correctly', () => {
@@ -21,7 +21,7 @@ describe('shared utilities', () => {
                     timezone: 'UTC',
                 },
             };
-            const result = (0, shared_1.mapTask)(mockTask);
+            const result = (0, tool_helpers_1.mapTask)(mockTask);
             expect(result).toEqual({
                 id: '123',
                 content: 'Test task',
@@ -53,7 +53,7 @@ describe('shared utilities', () => {
                     timezone: 'UTC',
                 },
             };
-            const result = (0, shared_1.mapTask)(mockTask);
+            const result = (0, tool_helpers_1.mapTask)(mockTask);
             expect(result.recurring).toBe('every day');
         });
     });
@@ -69,7 +69,7 @@ describe('shared utilities', () => {
                 inboxProject: false,
                 viewStyle: 'list',
             };
-            const result = (0, shared_1.mapProject)(mockPersonalProject);
+            const result = (0, tool_helpers_1.mapProject)(mockPersonalProject);
             expect(result).toEqual({
                 id: 'proj-1',
                 name: 'Personal Project',
@@ -90,7 +90,7 @@ describe('shared utilities', () => {
                 isShared: true,
                 viewStyle: 'board',
             };
-            const result = (0, shared_1.mapProject)(mockWorkspaceProject);
+            const result = (0, tool_helpers_1.mapProject)(mockWorkspaceProject);
             expect(result).toEqual({
                 id: 'proj-2',
                 name: 'Workspace Project',
@@ -115,8 +115,8 @@ describe('shared utilities', () => {
                 inboxProject: true,
                 viewStyle: 'list',
             };
-            expect((0, shared_1.isPersonalProject)(personalProject)).toBe(true);
-            expect((0, shared_1.isWorkspaceProject)(personalProject)).toBe(false);
+            expect((0, tool_helpers_1.isPersonalProject)(personalProject)).toBe(true);
+            expect((0, tool_helpers_1.isWorkspaceProject)(personalProject)).toBe(false);
         });
         it('should correctly identify workspace projects', () => {
             const workspaceProject = {
@@ -128,8 +128,8 @@ describe('shared utilities', () => {
                 viewStyle: 'board',
                 accessLevel: 'admin',
             };
-            expect((0, shared_1.isWorkspaceProject)(workspaceProject)).toBe(true);
-            expect((0, shared_1.isPersonalProject)(workspaceProject)).toBe(false);
+            expect((0, tool_helpers_1.isWorkspaceProject)(workspaceProject)).toBe(true);
+            expect((0, tool_helpers_1.isPersonalProject)(workspaceProject)).toBe(false);
         });
     });
 });

package/dist/tools/{tasks-delete-one.d.ts → delete-one.d.ts}

@@ -1,15 +1,17 @@
 import { z } from 'zod';
-declare const tasksDeleteOne: {
+declare const deleteOne: {
     name: string;
     description: string;
     parameters: {
+        type: z.ZodEnum<["project", "section", "task"]>;
         id: z.ZodString;
     };
     execute(args: {
+        type: "project" | "section" | "task";
         id: string;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         success: boolean;
     }>;
 };
-export { tasksDeleteOne };
-//# sourceMappingURL=tasks-delete-one.d.ts.map
+export { deleteOne };
+//# sourceMappingURL=delete-one.d.ts.map

package/dist/tools/delete-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-one.d.ts","sourceRoot":"","sources":["../../src/tools/delete-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;CAkB2B,CAAA;AAE1C,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/tools/delete-one.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteOne = void 0;
+const zod_1 = require("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.'),
+};
+const deleteOne = {
+    name: 'delete-one',
+    description: 'Delete a project, section, or task by its ID.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        switch (args.type) {
+            case 'project':
+                await client.deleteProject(args.id);
+                break;
+            case 'section':
+                await client.deleteSection(args.id);
+                break;
+            case 'task':
+                await client.deleteTask(args.id);
+                break;
+        }
+        return { success: true };
+    },
+};
+exports.deleteOne = deleteOne;

package/dist/tools/{project-overview.d.ts → overview.d.ts}

@@ -1,14 +1,14 @@
 import type { TodoistApi } from '@doist/todoist-api-typescript';
 import { z } from 'zod';
-declare const projectOverview: {
+declare const overview: {
     name: string;
     description: string;
     parameters: {
-        projectId: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
-        projectId: string;
+        projectId?: string | undefined;
     }, client: TodoistApi): Promise<string>;
 };
-export { projectOverview };
-//# sourceMappingURL=project-overview.d.ts.map
+export { overview };
+//# sourceMappingURL=overview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/tools/overview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,UAAU,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA+NvB,QAAA,MAAM,QAAQ;;;;;;;;;CAW4B,CAAA;AAE1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/overview.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overview = void 0;
+const zod_1 = require("zod");
+const tool_helpers_1 = require("../tool-helpers");
+const ArgsSchema = {
+    projectId: zod_1.z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional project ID. If provided, shows detailed overview of that project. If omitted, shows overview of all projects.'),
+};
+function buildProjectTree(projects) {
+    // Sort projects by childOrder, then build a tree
+    const byId = {};
+    for (const p of projects) {
+        byId[p.id] = {
+            ...p,
+            children: [],
+            childOrder: p.childOrder ?? 0,
+        };
+    }
+    const roots = [];
+    for (const p of projects) {
+        const current = byId[p.id];
+        if (!current)
+            continue;
+        if ((0, tool_helpers_1.isPersonalProject)(p) && p.parentId) {
+            const parent = byId[p.parentId];
+            if (parent) {
+                parent.children.push(current);
+            }
+            else {
+                roots.push(current);
+            }
+        }
+        else {
+            roots.push(current);
+        }
+    }
+    function sortTree(nodes) {
+        nodes.sort((a, b) => a.childOrder - b.childOrder);
+        for (const n of nodes) {
+            sortTree(n.children);
+        }
+    }
+    sortTree(roots);
+    return roots;
+}
+async function getSectionsByProject(client, projectIds) {
+    const result = {};
+    await Promise.all(projectIds.map(async (projectId) => {
+        const { results } = await client.getSections({ projectId });
+        result[projectId] = results;
+    }));
+    return result;
+}
+function renderProjectMarkdown(project, sectionsByProject, indent = '') {
+    const lines = [];
+    lines.push(`${indent}- Project: ${project.name} (id=${project.id})`);
+    const sections = sectionsByProject[project.id] || [];
+    for (const section of sections) {
+        lines.push(`${indent}  - Section: ${section.name} (id=${section.id})`);
+    }
+    for (const child of project.children) {
+        lines.push(...renderProjectMarkdown(child, sectionsByProject, `${indent}  `));
+    }
+    return lines;
+}
+function buildTaskTree(tasks) {
+    const byId = {};
+    for (const task of tasks) {
+        byId[task.id] = { ...task, children: [] };
+    }
+    const roots = [];
+    for (const task of tasks) {
+        const node = byId[task.id];
+        if (!node)
+            continue;
+        if (!task.parentId) {
+            roots.push(node);
+            continue;
+        }
+        const parent = byId[task.parentId];
+        if (parent) {
+            parent.children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    return roots;
+}
+function renderTaskTreeMarkdown(tasks, indent = '') {
+    const lines = [];
+    for (const task of tasks) {
+        const idPart = `id=${task.id}`;
+        const duePart = task.dueDate ? `; due=${task.dueDate}` : '';
+        const contentPart = `; content=${task.content}`;
+        lines.push(`${indent}- ${idPart}${duePart}${contentPart}`);
+        if (task.children.length > 0) {
+            lines.push(...renderTaskTreeMarkdown(task.children, `${indent}  `));
+        }
+    }
+    return lines;
+}
+async function getAllTasksForProject(client, projectId) {
+    let allTasks = [];
+    let cursor = undefined;
+    do {
+        const { results, nextCursor } = await client.getTasks({
+            projectId,
+            limit: 50,
+            cursor: cursor ?? undefined,
+        });
+        allTasks = allTasks.concat(results.map(tool_helpers_1.mapTask));
+        cursor = nextCursor ?? undefined;
+    } while (cursor);
+    return allTasks;
+}
+async function getProjectSections(client, projectId) {
+    const { results } = await client.getSections({ projectId });
+    return results;
+}
+// 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 tree = buildProjectTree(nonInbox);
+    const allProjectIds = projects.map((p) => p.id);
+    const sectionsByProject = await getSectionsByProject(client, allProjectIds);
+    const lines = ['# Personal Projects', ''];
+    if (inbox) {
+        lines.push(`- Inbox Project: ${inbox.name} (id=${inbox.id})`);
+        for (const section of sectionsByProject[inbox.id] || []) {
+            lines.push(`  - Section: ${section.name} (id=${section.id})`);
+        }
+    }
+    if (tree.length) {
+        for (const project of tree) {
+            lines.push(...renderProjectMarkdown(project, sectionsByProject));
+        }
+    }
+    else {
+        lines.push('_No projects found._');
+    }
+    lines.push('');
+    // Add explanation about nesting if there are nested projects
+    const hasNested = tree.some((p) => p.children.length > 0);
+    if (hasNested) {
+        lines.push('_Note: Indentation indicates that a project is a sub-project of the one above it. This allows for organizing projects hierarchically, with parent projects containing related sub-projects._', '');
+    }
+    return lines.join('\n');
+}
+// Project overview implementation
+async function generateProjectOverview(client, projectId) {
+    const project = await client.getProject(projectId);
+    const sections = await getProjectSections(client, projectId);
+    const allTasks = await getAllTasksForProject(client, projectId);
+    // Group tasks by sectionId
+    const tasksBySection = {};
+    for (const section of sections) {
+        tasksBySection[section.id] = [];
+    }
+    const tasksWithoutSection = [];
+    for (const task of allTasks) {
+        if (task.sectionId && tasksBySection[task.sectionId]) {
+            // biome-ignore lint/style/noNonNullAssertion: the "if" above ensures that it is defined
+            tasksBySection[task.sectionId].push(task);
+        }
+        else {
+            tasksWithoutSection.push(task);
+        }
+    }
+    const lines = [`# ${project.name}`];
+    if (tasksWithoutSection.length > 0) {
+        lines.push('');
+        const tree = buildTaskTree(tasksWithoutSection);
+        lines.push(...renderTaskTreeMarkdown(tree));
+    }
+    for (const section of sections) {
+        lines.push('');
+        lines.push(`## ${section.name}`);
+        const sectionTasks = tasksBySection[section.id];
+        if (!sectionTasks?.length) {
+            continue;
+        }
+        const tree = buildTaskTree(sectionTasks);
+        lines.push(...renderTaskTreeMarkdown(tree));
+    }
+    return lines.join('\n');
+}
+const overview = {
+    name: 'overview',
+    description: 'Get a Markdown overview. If no projectId is provided, shows all projects with hierarchy and sections (useful for navigation). If projectId is provided, shows detailed overview of that specific project including all tasks grouped by sections.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        if (args.projectId) {
+            return await generateProjectOverview(client, args.projectId);
+        }
+        return await generateAccountOverview(client);
+    },
+};
+exports.overview = overview;

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

@@ -3,14 +3,25 @@ declare const projectsList: {
     name: string;
     description: string;
     parameters: {
+        search: z.ZodOptional<z.ZodString>;
         limit: z.ZodDefault<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
         limit: number;
         cursor?: string | undefined;
+        search?: string | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
-        projects: (import("@doist/todoist-api-typescript").PersonalProject | import("@doist/todoist-api-typescript").WorkspaceProject)[];
+        projects: {
+            id: string;
+            name: string;
+            color: string;
+            isFavorite: boolean;
+            isShared: boolean;
+            parentId: string | null;
+            inboxProject: boolean;
+            viewStyle: string;
+        }[];
         nextCursor: string | null;
     }>;
 };

package/dist/tools/projects-list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projects-list.d.ts","sourceRoot":"","sources":["../../src/tools/projects-list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAmBvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;CAcwB,CAAA;AAE1C,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"projects-list.d.ts","sourceRoot":"","sources":["../../src/tools/projects-list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA0BvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;CAmBwB,CAAA;AAE1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/projects-list.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectsList = void 0;
 const zod_1 = require("zod");
+const tool_helpers_1 = require("../tool-helpers");
 const ArgsSchema = {
+    search: zod_1.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
         .number()
         .int()
@@ -17,15 +22,19 @@ const ArgsSchema = {
 };
 const projectsList = {
     name: 'projects-list',
-    description: 'List all projects for the user.',
+    description: 'List all projects or search for projects by name. If search parameter is omitted, all projects are returned.',
     parameters: ArgsSchema,
     async execute(args, client) {
         const { results, nextCursor } = await client.getProjects({
             limit: args.limit,
             cursor: args.cursor ?? null,
         });
+        const searchLower = args.search ? args.search.toLowerCase() : undefined;
+        const filtered = searchLower
+            ? results.filter((project) => project.name.toLowerCase().includes(searchLower))
+            : results;
         return {
-            projects: results,
+            projects: filtered.map(tool_helpers_1.mapProject),
             nextCursor,
         };
     },

package/dist/tools/{projects-add-one.d.ts → projects-manage.d.ts}

@@ -1,13 +1,15 @@
 import { z } from 'zod';
-declare const projectsAddOne: {
+declare const projectsManage: {
     name: string;
     description: string;
     parameters: {
+        id: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
     };
     execute(args: {
         name: string;
-    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        id?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<import("@doist/todoist-api-typescript").WorkspaceProject | {
         id: string;
         name: string;
         color: string;
@@ -18,5 +20,5 @@ declare const projectsAddOne: {
         viewStyle: string;
     }>;
 };
-export { projectsAddOne };
-//# sourceMappingURL=projects-add-one.d.ts.map
+export { projectsManage };
+//# sourceMappingURL=projects-manage.d.ts.map

package/dist/tools/projects-manage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projects-manage.d.ts","sourceRoot":"","sources":["../../src/tools/projects-manage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;CAgBsB,CAAA;AAE1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/projects-manage.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectsManage = void 0;
+const zod_1 = require("zod");
+const tool_helpers_1 = require("../tool-helpers");
+const ArgsSchema = {
+    id: zod_1.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.'),
+};
+const projectsManage = {
+    name: 'projects-manage',
+    description: 'Add a new project or update an existing project. If id is provided, updates the project. If id is omitted, creates a new project.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        if (args.id) {
+            // Update existing project
+            const project = await client.updateProject(args.id, { name: args.name });
+            return project;
+        }
+        // Create new project
+        const project = await client.addProject({ name: args.name });
+        return (0, tool_helpers_1.mapProject)(project);
+    },
+};
+exports.projectsManage = projectsManage;

package/dist/tools/sections-manage.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+declare const sectionsManage: {
+    name: string;
+    description: string;
+    parameters: {
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        name: string;
+        id?: string | undefined;
+        projectId?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        isError: boolean;
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    } | import("@doist/todoist-api-typescript").Section>;
+};
+export { sectionsManage };
+//# sourceMappingURL=sections-manage.d.ts.map

package/dist/tools/sections-manage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections-manage.d.ts","sourceRoot":"","sources":["../../src/tools/sections-manage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;CA0BsB,CAAA;AAE1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/sections-manage.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sectionsManage = void 0;
+const zod_1 = require("zod");
+const mcp_helpers_1 = require("../mcp-helpers");
+const ArgsSchema = {
+    id: zod_1.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
+        .string()
+        .min(1)
+        .optional()
+        .describe('The ID of the project to add the section to. Required when creating a new section (when id is not provided).'),
+};
+const sectionsManage = {
+    name: 'sections-manage',
+    description: 'Add a new section to a project or update an existing section. If id is provided, updates the section. If id is omitted, creates a new section (requires projectId).',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        if (args.id) {
+            // Update existing section
+            const section = await client.updateSection(args.id, { name: args.name });
+            return section;
+        }
+        // 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).');
+        }
+        const section = await client.addSection({
+            name: args.name,
+            projectId: args.projectId,
+        });
+        return section;
+    },
+};
+exports.sectionsManage = sectionsManage;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tasksAddMultiple = void 0;
 const zod_1 = require("zod");
-const shared_1 = require("./shared");
+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.'),
@@ -26,7 +26,7 @@ const tasksAddMultiple = {
             const taskArgs = { ...task, projectId, sectionId, parentId };
             newTasks.push(await client.addTask(taskArgs));
         }
-        return newTasks.map(shared_1.mapTask);
+        return newTasks.map(tool_helpers_1.mapTask);
     },
 };
 exports.tasksAddMultiple = tasksAddMultiple;

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;AA+BvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBqB,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

@@ -3,19 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tasksListByDate = void 0;
 const date_fns_1 = require("date-fns");
 const zod_1 = require("zod");
-const shared_1 = require("./shared");
+const tool_helpers_1 = require("../tool-helpers");
 const ArgsSchema = {
     startDate: zod_1.z
         .string()
-        .regex(/^(\d{4}-\d{2}-\d{2}|today)$/)
-        .describe("The start date to get the tasks for. Format: YYYY-MM-DD or 'today'."),
+        .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
         .number()
         .int()
         .min(1)
         .max(30)
         .default(1)
-        .describe('The number of days to get the tasks for, starting from the start date.'),
+        .describe("The number of days to get the tasks for, starting from the start date. Ignored when startDate is 'overdue'."),
     limit: zod_1.z
         .number()
         .int()
@@ -30,16 +30,22 @@ const ArgsSchema = {
 };
 const tasksListByDate = {
     name: 'tasks-list-by-date',
-    description: 'Get tasks by date range.',
+    description: "Get tasks by date range or overdue tasks. Use startDate 'overdue' for overdue tasks, or provide a date/date range.",
     parameters: ArgsSchema,
     async execute(args, client) {
-        const startDate = args.startDate === 'today'
-            ? (0, date_fns_1.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 query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
-        return await (0, shared_1.getTasksByFilter)({
+        let query;
+        if (args.startDate === 'overdue') {
+            query = 'overdue';
+        }
+        else {
+            const startDate = args.startDate === 'today'
+                ? (0, date_fns_1.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' });
+            query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
+        }
+        return await (0, tool_helpers_1.getTasksByFilter)({
             client,
             query,
             cursor: args.cursor,

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tasksListCompleted = void 0;
 const zod_1 = require("zod");
-const shared_1 = require("./shared");
+const tool_helpers_1 = require("../tool-helpers");
 const ArgsSchema = {
     getBy: zod_1.z
         .enum(['completion', 'due'])
@@ -44,7 +44,7 @@ const tasksListCompleted = {
             ? await client.getCompletedTasksByCompletionDate(rest)
             : await client.getCompletedTasksByDueDate(rest);
         return {
-            tasks: items.map(shared_1.mapTask),
+            tasks: items.map(tool_helpers_1.mapTask),
             nextCursor,
         };
     },