@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tools/__tests__/user-info.test.d.ts

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

package/dist/tools/__tests__/user-info.test.d.ts.map

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

package/dist/tools/__tests__/user-info.test.js

@@ -1,139 +0,0 @@
-import { jest } from '@jest/globals';
-import { extractStructuredContent, extractTextContent, TEST_ERRORS, } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { userInfo } from '../user-info.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    getUser: jest.fn(),
-};
-const { USER_INFO } = ToolNames;
-// Helper function to create a mock user with default values that can be overridden
-function createMockUser(overrides = {}) {
-    return {
-        id: '123',
-        fullName: 'Test User',
-        email: 'test@example.com',
-        isPremium: true,
-        completedToday: 12,
-        dailyGoal: 10,
-        weeklyGoal: 100,
-        startDay: 1, // Monday
-        tzInfo: {
-            timezone: 'Europe/Madrid',
-            gmtString: '+02:00',
-            hours: 2,
-            minutes: 0,
-            isDst: 1,
-        },
-        lang: 'en',
-        avatarBig: 'https://example.com/avatar.jpg',
-        avatarMedium: null,
-        avatarS640: null,
-        avatarSmall: null,
-        karma: 86394.0,
-        karmaTrend: 'up',
-        nextWeek: 1,
-        weekendStartDay: 6,
-        timeFormat: 0,
-        dateFormat: 0,
-        daysOff: [6, 7],
-        businessAccountId: null,
-        completedCount: 102920,
-        inboxProjectId: '6PVw8cMf7m8fWwRp',
-        startPage: 'overdue',
-        ...overrides,
-    };
-}
-describe(`${USER_INFO} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should generate user info with all required fields', async () => {
-        const mockUser = createMockUser();
-        mockTodoistApi.getUser.mockResolvedValue(mockUser);
-        const result = await userInfo.execute({}, mockTodoistApi);
-        expect(mockTodoistApi.getUser).toHaveBeenCalledWith();
-        // Test text content contains expected information
-        const textContent = extractTextContent(result);
-        expect(textContent).toContain('User ID:** 123');
-        expect(textContent).toContain('Test User');
-        expect(textContent).toContain('test@example.com');
-        expect(textContent).toContain('Europe/Madrid');
-        expect(textContent).toContain('Monday (1)');
-        expect(textContent).toContain('Completed Today:** 12');
-        expect(textContent).toContain('Plan:** Todoist Pro');
-        // Test structured content
-        const structuredContent = extractStructuredContent(result);
-        expect(structuredContent).toEqual(expect.objectContaining({
-            type: 'user_info',
-            userId: '123',
-            fullName: 'Test User',
-            email: 'test@example.com',
-            timezone: 'Europe/Madrid',
-            startDay: 1,
-            startDayName: 'Monday',
-            completedToday: 12,
-            dailyGoal: 10,
-            weeklyGoal: 100,
-            plan: 'Todoist Pro',
-            currentLocalTime: expect.any(String),
-            weekStartDate: expect.any(String),
-            weekEndDate: expect.any(String),
-            currentWeekNumber: expect.any(Number),
-        }));
-        // Verify date formats
-        expect(structuredContent.weekStartDate).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-        expect(structuredContent.weekEndDate).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-        expect(structuredContent.currentLocalTime).toMatch(/^\d{2}\/\d{2}\/\d{4}, \d{2}:\d{2}:\d{2}$/);
-    });
-    it('should handle missing timezone info', async () => {
-        const mockUser = createMockUser({
-            isPremium: false,
-            tzInfo: {
-                timezone: 'UTC',
-                gmtString: '+00:00',
-                hours: 0,
-                minutes: 0,
-                isDst: 0,
-            },
-        });
-        mockTodoistApi.getUser.mockResolvedValue(mockUser);
-        const result = await userInfo.execute({}, mockTodoistApi);
-        const textContent = extractTextContent(result);
-        expect(textContent).toContain('UTC'); // Should default to UTC
-        expect(textContent).toContain('Monday (1)'); // Should default to Monday
-        expect(textContent).toContain('Plan:** Todoist Free');
-        const structuredContent = extractStructuredContent(result);
-        expect(structuredContent.timezone).toBe('UTC');
-        expect(structuredContent.startDay).toBe(1);
-        expect(structuredContent.startDayName).toBe('Monday');
-        expect(structuredContent.plan).toBe('Todoist Free');
-    });
-    it('should handle invalid timezone and fallback to UTC', async () => {
-        const mockUser = createMockUser({
-            startDay: 2, // Tuesday
-            tzInfo: {
-                timezone: 'Invalid/Timezone',
-                gmtString: '+05:30',
-                hours: 5,
-                minutes: 30,
-                isDst: 0,
-            },
-        });
-        mockTodoistApi.getUser.mockResolvedValue(mockUser);
-        const result = await userInfo.execute({}, mockTodoistApi);
-        const textContent = extractTextContent(result);
-        expect(textContent).toContain('UTC'); // Should fallback to UTC
-        expect(textContent).toContain('Tuesday (2)');
-        const structuredContent = extractStructuredContent(result);
-        expect(structuredContent.timezone).toBe('UTC'); // Should be UTC, not the invalid timezone
-        expect(structuredContent.startDay).toBe(2);
-        expect(structuredContent.startDayName).toBe('Tuesday');
-        expect(structuredContent.currentLocalTime).toMatch(/^\d{2}\/\d{2}\/\d{4}, \d{2}:\d{2}:\d{2}$/);
-    });
-    it('should propagate API errors', async () => {
-        const apiError = new Error(TEST_ERRORS.API_UNAUTHORIZED);
-        mockTodoistApi.getUser.mockRejectedValue(apiError);
-        await expect(userInfo.execute({}, mockTodoistApi)).rejects.toThrow(TEST_ERRORS.API_UNAUTHORIZED);
-    });
-});

package/dist/tools/add-comments.js

@@ -1,79 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { formatNextSteps } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { FIND_COMMENTS, UPDATE_COMMENTS, DELETE_OBJECT } = ToolNames;
-const CommentSchema = z.object({
-    taskId: z.string().optional().describe('The ID of the task to comment on.'),
-    projectId: z.string().optional().describe('The ID of the project to comment on.'),
-    content: z.string().min(1).describe('The content of the comment.'),
-});
-const ArgsSchema = {
-    comments: z.array(CommentSchema).min(1).describe('The array of comments to add.'),
-};
-const addComments = {
-    name: ToolNames.ADD_COMMENTS,
-    description: 'Add multiple comments to tasks or projects. Each comment must specify either taskId or projectId.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const { comments } = args;
-        // Validate each comment
-        for (const [index, comment] of comments.entries()) {
-            if (!comment.taskId && !comment.projectId) {
-                throw new Error(`Comment ${index + 1}: Either taskId or projectId must be provided.`);
-            }
-            if (comment.taskId && comment.projectId) {
-                throw new Error(`Comment ${index + 1}: Cannot provide both taskId and projectId. Choose one.`);
-            }
-        }
-        const addCommentPromises = comments.map(async ({ content, taskId, projectId }) => await client.addComment({
-            content,
-            ...(taskId ? { taskId } : { projectId }),
-        }));
-        const newComments = await Promise.all(addCommentPromises);
-        const textContent = generateTextContent({ comments: newComments });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                comments: newComments,
-                totalCount: newComments.length,
-                addedCommentIds: newComments.map((comment) => comment.id),
-            },
-        });
-    },
-};
-function generateTextContent({ comments }) {
-    // Group comments by entity type and count
-    const taskComments = comments.filter((c) => c.taskId).length;
-    const projectComments = comments.filter((c) => c.projectId).length;
-    // Generate summary text
-    const parts = [];
-    if (taskComments > 0) {
-        const commentsLabel = taskComments > 1 ? 'comments' : 'comment';
-        parts.push(`${taskComments} task ${commentsLabel}`);
-    }
-    if (projectComments > 0) {
-        const commentsLabel = projectComments > 1 ? 'comments' : 'comment';
-        parts.push(`${projectComments} project ${commentsLabel}`);
-    }
-    const summary = parts.length > 0 ? `Added ${parts.join(' and ')}` : 'No comments added';
-    // Context-aware next steps
-    const nextSteps = [];
-    if (comments.length > 0) {
-        if (comments.length === 1 && comments[0]) {
-            const comment = comments[0];
-            const targetId = comment.taskId || comment.projectId || '';
-            const targetType = comment.taskId ? 'task' : 'project';
-            nextSteps.push(`Use ${FIND_COMMENTS} with ${targetType}Id=${targetId} to see all comments`);
-            nextSteps.push(`Use ${UPDATE_COMMENTS} with id=${comment.id} to edit content`);
-        }
-        else {
-            nextSteps.push(`Use ${FIND_COMMENTS} to view comments by task or project`);
-            nextSteps.push(`Use ${UPDATE_COMMENTS} to edit any comment content`);
-        }
-        nextSteps.push(`Use ${DELETE_OBJECT} with type=comment to remove comments`);
-    }
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-export { addComments };

package/dist/tools/add-projects.js

@@ -1,63 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { formatNextSteps } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { ADD_SECTIONS, ADD_TASKS, FIND_PROJECTS, GET_OVERVIEW } = ToolNames;
-const ProjectSchema = z.object({
-    name: z.string().min(1).describe('The name of the project.'),
-    parentId: z
-        .string()
-        .optional()
-        .describe('The ID of the parent project. If provided, creates this as a sub-project.'),
-    isFavorite: z
-        .boolean()
-        .optional()
-        .describe('Whether the project is a favorite. Defaults to false.'),
-    viewStyle: z
-        .enum(['list', 'board', 'calendar'])
-        .optional()
-        .describe('The project view style. Defaults to "list".'),
-});
-const ArgsSchema = {
-    projects: z.array(ProjectSchema).min(1).describe('The array of projects to add.'),
-};
-const addProjects = {
-    name: ToolNames.ADD_PROJECTS,
-    description: 'Add one or more new projects.',
-    parameters: ArgsSchema,
-    async execute({ projects }, client) {
-        const newProjects = await Promise.all(projects.map((project) => client.addProject(project)));
-        const textContent = generateTextContent({ projects: newProjects });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                projects: newProjects,
-                totalCount: newProjects.length,
-            },
-        });
-    },
-};
-function generateTextContent({ projects }) {
-    const count = projects.length;
-    const projectList = projects.map((project) => `• ${project.name} (id=${project.id})`).join('\n');
-    const summary = `Added ${count} project${count === 1 ? '' : 's'}:\n${projectList}`;
-    // Context-aware next steps for new projects
-    const nextSteps = [];
-    if (count === 1) {
-        const project = projects[0];
-        if (project) {
-            nextSteps.push(`Use ${ADD_SECTIONS} to organize new project with sections`);
-            nextSteps.push(`Use ${ADD_TASKS} to add your first tasks to this project`);
-            nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${project.id} to see project structure`);
-        }
-    }
-    else {
-        nextSteps.push(`Use ${ADD_SECTIONS} to organize these projects with sections`);
-        nextSteps.push(`Use ${ADD_TASKS} to add tasks to these projects`);
-        nextSteps.push(`Use ${FIND_PROJECTS} to see all projects including the new ones`);
-        nextSteps.push(`Use ${GET_OVERVIEW} to see updated project hierarchy`);
-    }
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-export { addProjects };

package/dist/tools/add-sections.js

@@ -1,61 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { formatNextSteps } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { ADD_TASKS, FIND_TASKS, GET_OVERVIEW, FIND_SECTIONS } = ToolNames;
-const SectionSchema = z.object({
-    name: z.string().min(1).describe('The name of the section.'),
-    projectId: z.string().min(1).describe('The ID of the project to add the section to.'),
-});
-const ArgsSchema = {
-    sections: z.array(SectionSchema).min(1).describe('The array of sections to add.'),
-};
-const addSections = {
-    name: ToolNames.ADD_SECTIONS,
-    description: 'Add one or more new sections to projects.',
-    parameters: ArgsSchema,
-    async execute({ sections }, client) {
-        const newSections = await Promise.all(sections.map((section) => client.addSection(section)));
-        const textContent = generateTextContent({ sections: newSections });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                sections: newSections,
-                totalCount: newSections.length,
-            },
-        });
-    },
-};
-function generateTextContent({ sections }) {
-    const count = sections.length;
-    const sectionList = sections
-        .map((section) => `• ${section.name} (id=${section.id}, projectId=${section.projectId})`)
-        .join('\n');
-    const summary = `Added ${count} section${count === 1 ? '' : 's'}:\n${sectionList}`;
-    // Context-aware next steps for new sections
-    const nextSteps = [];
-    if (count === 1) {
-        const section = sections[0];
-        if (section) {
-            nextSteps.push(`Use ${ADD_TASKS} with sectionId=${section.id} to add your first tasks`);
-            nextSteps.push(`Use ${FIND_TASKS} with sectionId=${section.id} to verify setup`);
-            nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${section.projectId} to see project organization`);
-        }
-    }
-    else {
-        // Group sections by project for better guidance
-        const projectIds = [...new Set(sections.map((s) => s.projectId))];
-        nextSteps.push(`Use ${ADD_TASKS} to add tasks to these new sections`);
-        if (projectIds.length === 1) {
-            nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${projectIds[0]} to see updated project structure`);
-            nextSteps.push(`Use ${FIND_SECTIONS} with projectId=${projectIds[0]} to see all sections`);
-        }
-        else {
-            nextSteps.push(`Use ${GET_OVERVIEW} to see updated project structures`);
-            nextSteps.push(`Use ${FIND_SECTIONS} to see sections in specific projects`);
-        }
-    }
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-export { addSections };

package/dist/tools/add-tasks.js

@@ -1,160 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { mapTask } from '../tool-helpers.js';
-import { assignmentValidator } from '../utils/assignment-validator.js';
-import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
-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 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.'),
-    deadlineDate: z
-        .string()
-        .optional()
-        .describe('The deadline date for the task in ISO 8601 format (YYYY-MM-DD, e.g., "2025-12-31"). Deadlines are immovable constraints shown with a different indicator than due dates.'),
-    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.'),
-    labels: z.array(z.string()).optional().describe('The labels to attach to the task.'),
-    projectId: z.string().optional().describe('The project ID to add this task to.'),
-    sectionId: z.string().optional().describe('The section ID to add this task to.'),
-    parentId: z.string().optional().describe('The parent task ID (for subtasks).'),
-    responsibleUser: z
-        .string()
-        .optional()
-        .describe('Assign task to this user. Can be a user ID, name, or email address. User must be a collaborator on the target project.'),
-});
-const ArgsSchema = {
-    tasks: z.array(TaskSchema).min(1).describe('The array of tasks to add.'),
-};
-const addTasks = {
-    name: ToolNames.ADD_TASKS,
-    description: 'Add one or more tasks to a project, section, or parent. Supports assignment to project collaborators.',
-    parameters: ArgsSchema,
-    async execute({ tasks }, client) {
-        const addTaskPromises = tasks.map((task) => processTask(task, client));
-        const newTasks = await Promise.all(addTaskPromises);
-        const mappedTasks = newTasks.map(mapTask);
-        const textContent = generateTextContent({
-            tasks: mappedTasks,
-            args: { tasks },
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                tasks: mappedTasks,
-                totalCount: mappedTasks.length,
-            },
-        });
-    },
-};
-async function processTask(task, client) {
-    const { duration: durationStr, projectId, sectionId, parentId, responsibleUser, priority, labels, deadlineDate, ...otherTaskArgs } = task;
-    let taskArgs = {
-        ...otherTaskArgs,
-        projectId,
-        sectionId,
-        parentId,
-        labels,
-        deadlineDate,
-    };
-    // Handle priority conversion if provided
-    if (priority) {
-        taskArgs.priority = convertPriorityToNumber(priority);
-    }
-    // Only prevent assignment (not task creation) without sufficient project context
-    if (responsibleUser && !projectId && !sectionId && !parentId) {
-        throw new Error(`Task "${task.content}": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or 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;
-        }
-    }
-    // Handle assignment if provided
-    if (responsibleUser) {
-        // Resolve target project for validation
-        let targetProjectId = projectId;
-        if (!targetProjectId && parentId) {
-            // For subtasks, get project from parent task
-            try {
-                const parentTask = await client.getTask(parentId);
-                targetProjectId = parentTask.projectId;
-            }
-            catch (_error) {
-                throw new Error(`Task "${task.content}": Parent task "${parentId}" not found`);
-            }
-        }
-        else if (!targetProjectId && sectionId) {
-            // For section tasks, we need to find the project - this is a limitation
-            // For now, we'll require explicit projectId when using assignments with sections
-            throw new Error(`Task "${task.content}": When assigning tasks to sections, please also specify projectId`);
-        }
-        if (!targetProjectId) {
-            throw new Error(`Task "${task.content}": Cannot determine target project for assignment validation`);
-        }
-        // Validate assignment using comprehensive validator
-        const validation = await assignmentValidator.validateTaskCreationAssignment(client, targetProjectId, responsibleUser);
-        if (!validation.isValid) {
-            const errorMsg = validation.error?.message || 'Assignment validation failed';
-            const suggestions = validation.error?.suggestions?.join('. ') || '';
-            throw new Error(`Task "${task.content}": ${errorMsg}${suggestions ? `. ${suggestions}` : ''}`);
-        }
-        // Use the validated assignee ID
-        taskArgs.assigneeId = validation.resolvedUser?.userId;
-    }
-    return await client.addTask(taskArgs);
-}
-function generateTextContent({ tasks, args, }) {
-    // Get context for smart next steps
-    const todayStr = getDateString();
-    const hasToday = tasks.some((task) => task.dueDate === todayStr);
-    // Generate context description for mixed contexts
-    const contextTypes = new Set();
-    for (const task of args.tasks) {
-        if (task.projectId)
-            contextTypes.add('projects');
-        else if (task.sectionId)
-            contextTypes.add('sections');
-        else if (task.parentId)
-            contextTypes.add('subtasks');
-        else
-            contextTypes.add('inbox');
-    }
-    let projectContext = '';
-    if (contextTypes.size === 1) {
-        const contextType = Array.from(contextTypes)[0];
-        projectContext = contextType === 'inbox' ? '' : `to ${contextType}`;
-    }
-    else if (contextTypes.size > 1) {
-        projectContext = 'to multiple contexts';
-    }
-    return summarizeTaskOperation('Added', tasks, {
-        context: projectContext,
-        nextSteps: generateTaskNextSteps('added', tasks, { hasToday }),
-        showDetails: true,
-    });
-}
-export { addTasks };

package/dist/tools/complete-tasks.js

@@ -1,68 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { summarizeBatch } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const ArgsSchema = {
-    ids: z.array(z.string().min(1)).min(1).describe('The IDs of the tasks to complete.'),
-};
-const completeTasks = {
-    name: ToolNames.COMPLETE_TASKS,
-    description: 'Complete one or more tasks by their IDs.',
-    parameters: ArgsSchema,
-    async execute(args, client) {
-        const completed = [];
-        const failures = [];
-        for (const id of args.ids) {
-            try {
-                await client.closeTask(id);
-                completed.push(id);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                failures.push({
-                    item: id,
-                    error: errorMessage,
-                });
-            }
-        }
-        const textContent = generateTextContent({
-            completed,
-            failures,
-            args,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                completed,
-                failures,
-                totalRequested: args.ids.length,
-                successCount: completed.length,
-                failureCount: failures.length,
-            },
-        });
-    },
-};
-function generateNextSteps(completed, failures) {
-    if (completed > 0) {
-        const moveResult = failures === 0
-            ? "Use find-tasks-by-date('today') to tackle remaining overdue items."
-            : 'Review failed completions and retry if needed.';
-        return [moveResult];
-    }
-    if (failures > 0) {
-        return ['Check task IDs and permissions, then retry.'];
-    }
-    return ['No tasks were completed.'];
-}
-function generateTextContent({ completed, failures, args, }) {
-    const nextSteps = generateNextSteps(completed.length, failures.length);
-    return summarizeBatch({
-        action: 'Completed tasks',
-        success: completed.length,
-        total: args.ids.length,
-        successItems: completed,
-        failures,
-        nextSteps,
-    });
-}
-export { completeTasks };

package/dist/tools/delete-object.js

@@ -1,79 +0,0 @@
-import { z } from 'zod';
-import { getToolOutput } from '../mcp-helpers.js';
-import { formatNextSteps } from '../utils/response-builders.js';
-import { ToolNames } from '../utils/tool-names.js';
-const { FIND_PROJECTS, GET_OVERVIEW, FIND_SECTIONS, FIND_TASKS, FIND_TASKS_BY_DATE, FIND_COMMENTS, } = ToolNames;
-const ArgsSchema = {
-    type: z
-        .enum(['project', 'section', 'task', 'comment'])
-        .describe('The type of entity to delete.'),
-    id: z.string().min(1).describe('The ID of the entity to delete.'),
-};
-const deleteObject = {
-    name: ToolNames.DELETE_OBJECT,
-    description: 'Delete a project, section, task, or comment 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;
-            case 'comment':
-                await client.deleteComment(args.id);
-                break;
-        }
-        const textContent = generateTextContent({
-            type: args.type,
-            id: args.id,
-        });
-        return getToolOutput({
-            textContent,
-            structuredContent: {
-                deletedEntity: {
-                    type: args.type,
-                    id: args.id,
-                },
-                success: true,
-            },
-        });
-    },
-};
-function generateTextContent({ type, id, }) {
-    const summary = `Deleted ${type}: id=${id}`;
-    // Recovery-focused next steps based on what was deleted
-    const nextSteps = [];
-    switch (type) {
-        case 'project':
-            // Help user understand impact and navigate remaining work
-            nextSteps.push(`Use ${FIND_PROJECTS} to see remaining projects`);
-            nextSteps.push('Note: All tasks and sections in this project were also deleted');
-            nextSteps.push(`Use ${GET_OVERVIEW} to review your updated project structure`);
-            break;
-        case 'section':
-            // Guide user to reorganize remaining sections and tasks
-            nextSteps.push(`Use ${FIND_SECTIONS} to see remaining sections in the project`);
-            nextSteps.push('Note: Tasks in this section were also deleted');
-            nextSteps.push(`Use ${FIND_TASKS} with projectId to see unorganized tasks`);
-            break;
-        case 'task':
-            // Help user stay focused on remaining work
-            nextSteps.push(`Use ${FIND_TASKS_BY_DATE} to see remaining tasks for today`);
-            nextSteps.push(`Use ${GET_OVERVIEW} to check if this affects any dependent tasks`);
-            nextSteps.push('Note: Any subtasks of this task were also deleted');
-            break;
-        case 'comment':
-            // Help user understand comment deletion impact
-            nextSteps.push(`Use ${FIND_COMMENTS} to see remaining comments on the task/project`);
-            nextSteps.push('Note: Comment attachments were also deleted');
-            break;
-    }
-    const next = formatNextSteps(nextSteps);
-    return `${summary}\n${next}`;
-}
-export { deleteObject };