@doist/todoist-ai 1.1.0 → 2.0.1

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

@@ -0,0 +1,161 @@
+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);
+        });
+    });
+    describe('error handling', () => {
+        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/{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,25 @@
+import { z } from 'zod';
+const ArgsSchema = {
+    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',
+    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 };
+    },
+};
+export { 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,202 @@
+import { z } from 'zod';
+import { isPersonalProject, mapTask } from '../tool-helpers.js';
+const ArgsSchema = {
+    projectId: 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 (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(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) => 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);
+    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);
+    },
+};
+export { 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

@@ -1,33 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectsList = void 0;
-const zod_1 = require("zod");
+import { z } from 'zod';
+import { mapProject } from '../tool-helpers.js';
 const ArgsSchema = {
-    limit: 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: 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).'),
 };
 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(mapProject),
             nextCursor,
         };
     },
 };
-exports.projectsList = projectsList;
+export { projectsList };

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,26 @@
+import { z } from 'zod';
+import { mapProject } from '../tool-helpers.js';
+const ArgsSchema = {
+    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: 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 mapProject(project);
+    },
+};
+export { 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,37 @@
+import { z } from 'zod';
+import { errorContent } from '../mcp-helpers.js';
+const ArgsSchema = {
+    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: z.string().min(1).describe('The name of the section.'),
+    projectId: 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 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;
+    },
+};
+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 };