@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/tools/__tests__/assignment-integration.test.js

@@ -1,428 +0,0 @@
-import { createMockProject, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
-import { addTasks } from '../add-tasks.js';
-import { findProjectCollaborators } from '../find-project-collaborators.js';
-import { manageAssignments } from '../manage-assignments.js';
-import { updateTasks } from '../update-tasks.js';
-// Mock the assignment validator
-jest.mock('../../utils/assignment-validator.js', () => ({
-    assignmentValidator: {
-        validateTaskCreationAssignment: jest.fn(),
-        validateTaskUpdateAssignment: jest.fn(),
-        validateBulkAssignment: jest.fn(),
-    },
-}));
-// Mock the user resolver
-jest.mock('../../utils/user-resolver.js', () => ({
-    userResolver: {
-        resolveUser: jest.fn(),
-        getProjectCollaborators: jest.fn(),
-    },
-}));
-describe('Assignment Integration Tests', () => {
-    let mockTodoistApi;
-    const mockValidUser = {
-        userId: 'user-123',
-        name: 'John Doe',
-        email: 'john@example.com',
-    };
-    const mockTask = {
-        id: 'task-123',
-        content: 'Test task',
-        projectId: 'project-123',
-        sectionId: null,
-        parentId: null,
-        priority: 1,
-        labels: [],
-        description: '',
-        url: 'https://todoist.com/showTask?id=task-123',
-        noteCount: 0,
-        addedByUid: 'creator-123',
-        addedAt: new Date().toISOString(),
-        deadline: null,
-        responsibleUid: null,
-        assignedByUid: null,
-        isCollapsed: false,
-        isDeleted: false,
-        duration: null,
-        checked: false,
-        updatedAt: new Date().toISOString(),
-        due: null,
-        dayOrder: 0,
-        userId: 'creator-123',
-        completedAt: null,
-        childOrder: 1,
-    };
-    const mockProject = createMockProject({
-        id: 'project-123',
-        name: 'Test Project',
-        color: 'blue',
-        isShared: true,
-        canAssignTasks: true,
-        url: 'https://todoist.com/showProject?id=project-123',
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockTodoistApi = {
-            addTask: jest.fn(),
-            updateTask: jest.fn(),
-            getTask: jest.fn(),
-            getProjects: jest.fn(),
-            getProject: jest.fn(),
-        };
-        // Mock assignment validator responses
-        const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
-        mockAssignmentValidator.validateTaskCreationAssignment.mockResolvedValue({
-            isValid: true,
-            resolvedUser: mockValidUser,
-        });
-        mockAssignmentValidator.validateTaskUpdateAssignment.mockResolvedValue({
-            isValid: true,
-            resolvedUser: mockValidUser,
-        });
-        mockAssignmentValidator.validateBulkAssignment.mockResolvedValue([
-            { isValid: true, resolvedUser: mockValidUser },
-            { isValid: true, resolvedUser: mockValidUser },
-            { isValid: true, resolvedUser: mockValidUser },
-        ]);
-        // Mock user resolver
-        const mockUserResolver = require('../../utils/user-resolver.js').userResolver;
-        mockUserResolver.resolveUser.mockResolvedValue(mockValidUser);
-        mockUserResolver.getProjectCollaborators.mockResolvedValue([
-            { id: 'user-123', name: 'John Doe', email: 'john@example.com' },
-            { id: 'user-456', name: 'Jane Smith', email: 'jane@example.com' },
-        ]);
-        // Mock API responses
-        mockTodoistApi.getProjects.mockResolvedValue({
-            results: [mockProject],
-            nextCursor: null,
-        });
-        mockTodoistApi.getProject.mockResolvedValue(mockProject);
-        mockTodoistApi.addTask.mockResolvedValue({ ...mockTask, responsibleUid: 'user-123' });
-        mockTodoistApi.updateTask.mockResolvedValue({ ...mockTask, responsibleUid: 'user-123' });
-        mockTodoistApi.getTask.mockResolvedValue(mockTask);
-    });
-    describe('Task Creation with Assignment', () => {
-        it('should assign task during creation', async () => {
-            const result = await addTasks.execute({
-                tasks: [
-                    {
-                        content: 'New assigned task',
-                        projectId: 'project-123',
-                        responsibleUser: 'john@example.com',
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
-                content: 'New assigned task',
-                projectId: 'project-123',
-                assigneeId: 'user-123', // Should be resolved user ID
-            }));
-            expect(extractTextContent(result)).toContain('Added 1 task');
-        });
-        it('should validate assignment before creating task', async () => {
-            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
-            mockAssignmentValidator.validateTaskCreationAssignment.mockResolvedValueOnce({
-                isValid: false,
-                error: {
-                    message: 'User not found in project collaborators',
-                    suggestions: ['Use find-project-collaborators to see valid assignees'],
-                },
-            });
-            await expect(addTasks.execute({
-                tasks: [
-                    {
-                        content: 'Invalid assignment task',
-                        projectId: 'project-123',
-                        responsibleUser: 'nonexistent@example.com',
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task "Invalid assignment task": User not found in project collaborators. Use find-project-collaborators to see valid assignees');
-            expect(mockTodoistApi.addTask).not.toHaveBeenCalled();
-        });
-        it('should handle assignment for subtasks', async () => {
-            mockTodoistApi.getTask.mockResolvedValueOnce({
-                ...mockTask,
-                id: 'parent-123',
-                projectId: 'project-123',
-            });
-            await addTasks.execute({
-                tasks: [
-                    {
-                        content: 'Subtask with assignment',
-                        parentId: 'parent-123',
-                        responsibleUser: 'john@example.com',
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
-                content: 'Subtask with assignment',
-                parentId: 'parent-123',
-                assigneeId: 'user-123',
-            }));
-        });
-    });
-    describe('Task Update with Assignment', () => {
-        it('should update task assignment', async () => {
-            const result = await updateTasks.execute({
-                tasks: [
-                    {
-                        id: 'task-123',
-                        responsibleUser: 'jane@example.com',
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-123', expect.objectContaining({
-                assigneeId: 'user-123',
-            }));
-            expect(extractTextContent(result)).toContain('Updated 1 task');
-        });
-        it('should unassign task when responsibleUser is "unassign"', async () => {
-            await updateTasks.execute({
-                tasks: [
-                    {
-                        id: 'task-123',
-                        responsibleUser: 'unassign',
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-123', expect.objectContaining({
-                assigneeId: null,
-            }));
-        });
-        it('should unassign task when responsibleUser is null (backward compatibility)', async () => {
-            await updateTasks.execute({
-                tasks: [
-                    {
-                        id: 'task-123',
-                        responsibleUser: null,
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-123', expect.objectContaining({
-                assigneeId: null,
-            }));
-        });
-        it('should validate assignment changes', async () => {
-            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
-            mockAssignmentValidator.validateTaskUpdateAssignment.mockResolvedValueOnce({
-                isValid: false,
-                error: {
-                    message: 'User cannot be assigned to this project',
-                },
-            });
-            await expect(updateTasks.execute({
-                tasks: [
-                    {
-                        id: 'task-123',
-                        responsibleUser: 'invalid@example.com',
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task task-123: User cannot be assigned to this project');
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-        });
-    });
-    describe('Bulk Assignment Operations', () => {
-        beforeEach(() => {
-            mockTodoistApi.getTask
-                .mockResolvedValueOnce({ ...mockTask, id: 'task-1' })
-                .mockResolvedValueOnce({ ...mockTask, id: 'task-2' })
-                .mockResolvedValueOnce({ ...mockTask, id: 'task-3' });
-        });
-        it('should perform bulk assignment', async () => {
-            const result = await manageAssignments.execute({
-                operation: 'assign',
-                taskIds: ['task-1', 'task-2', 'task-3'],
-                responsibleUser: 'john@example.com',
-                dryRun: false,
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-1', {
-                assigneeId: 'user-123',
-            });
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-2', {
-                assigneeId: 'user-123',
-            });
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-3', {
-                assigneeId: 'user-123',
-            });
-            expect(extractTextContent(result)).toContain('3 tasks were successfully assigned');
-        });
-        it('should perform bulk unassignment', async () => {
-            const result = await manageAssignments.execute({
-                operation: 'unassign',
-                taskIds: ['task-1', 'task-2'],
-                dryRun: false,
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledTimes(2);
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-1', {
-                assigneeId: null,
-            });
-            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('task-2', {
-                assigneeId: null,
-            });
-            expect(extractTextContent(result)).toContain('2 tasks were successfully unassigned');
-        });
-        it('should handle dry-run mode', async () => {
-            // Mock validation for 2 tasks
-            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
-            mockAssignmentValidator.validateBulkAssignment.mockResolvedValueOnce([
-                { isValid: true, resolvedUser: mockValidUser },
-                { isValid: true, resolvedUser: mockValidUser },
-            ]);
-            const result = await manageAssignments.execute({
-                operation: 'assign',
-                taskIds: ['task-1', 'task-2'],
-                responsibleUser: 'john@example.com',
-                dryRun: true,
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateTask).not.toHaveBeenCalled();
-            expect(extractTextContent(result)).toContain('Dry Run: Bulk assign operation');
-            expect(extractTextContent(result)).toContain('2 tasks would be successfully assigned');
-        });
-        it('should handle mixed success and failure results', async () => {
-            // Mock validation for 3 tasks - 2 valid, 1 invalid
-            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
-            mockAssignmentValidator.validateBulkAssignment.mockResolvedValueOnce([
-                { isValid: true, resolvedUser: mockValidUser },
-                { isValid: false, error: { message: 'API Error' } },
-                { isValid: true, resolvedUser: mockValidUser },
-            ]);
-            mockTodoistApi.updateTask
-                .mockResolvedValueOnce({ ...mockTask, id: 'task-1' })
-                .mockResolvedValueOnce({ ...mockTask, id: 'task-3' });
-            const result = await manageAssignments.execute({
-                operation: 'assign',
-                taskIds: ['task-1', 'task-2', 'task-3'],
-                responsibleUser: 'john@example.com',
-                dryRun: false,
-            }, mockTodoistApi);
-            expect(extractTextContent(result)).toContain('2 tasks were successfully assigned');
-            expect(extractTextContent(result)).toContain('1 task failed');
-            expect(extractTextContent(result)).toContain('API Error');
-        });
-    });
-    describe('Project Collaborators Discovery', () => {
-        it('should find project collaborators', async () => {
-            const result = await findProjectCollaborators.execute({
-                projectId: 'project-123',
-            }, mockTodoistApi);
-            expect(extractTextContent(result)).toContain('Project collaborators');
-            expect(extractTextContent(result)).toContain('John Doe (john@example.com)');
-            expect(extractTextContent(result)).toContain('Jane Smith (jane@example.com)');
-            expect(extractStructuredContent(result).collaborators).toHaveLength(2);
-        });
-        it('should filter collaborators by search term', async () => {
-            const result = await findProjectCollaborators.execute({
-                projectId: 'project-123',
-                searchTerm: 'John',
-            }, mockTodoistApi);
-            expect(extractTextContent(result)).toContain('matching "John"');
-        });
-        it('should handle non-shared projects', async () => {
-            mockTodoistApi.getProject.mockResolvedValueOnce({ ...mockProject, isShared: false });
-            const result = await findProjectCollaborators.execute({
-                projectId: 'project-123',
-            }, mockTodoistApi);
-            expect(extractTextContent(result)).toContain('is not shared and has no collaborators');
-            expect(extractStructuredContent(result).collaborators).toBeUndefined(); // Empty arrays are removed
-        });
-        it('should handle project not found', async () => {
-            mockTodoistApi.getProject.mockRejectedValueOnce(new Error('Project not found'));
-            await expect(findProjectCollaborators.execute({
-                projectId: 'nonexistent-project',
-            }, mockTodoistApi)).rejects.toThrow('Failed to access project "nonexistent-project"');
-        });
-    });
-    describe('Error Handling and Edge Cases', () => {
-        it('should handle assignment validation errors gracefully', async () => {
-            const mockAssignmentValidator = require('../../utils/assignment-validator.js').assignmentValidator;
-            mockAssignmentValidator.validateTaskCreationAssignment.mockResolvedValueOnce({
-                isValid: false,
-                error: {
-                    message: 'Project not shared',
-                    suggestions: ['Share the project to enable assignments'],
-                },
-            });
-            await expect(addTasks.execute({
-                tasks: [
-                    {
-                        content: 'Task in unshared project',
-                        projectId: 'project-123',
-                        responsibleUser: 'john@example.com',
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task "Task in unshared project": Project not shared. Share the project to enable assignments');
-        });
-        it('should handle inbox assignment restriction', async () => {
-            await expect(addTasks.execute({
-                tasks: [
-                    {
-                        content: 'Inbox task with assignment',
-                        responsibleUser: 'john@example.com',
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task "Inbox task with assignment": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or parentId.');
-        });
-        it('should handle parent task not found', async () => {
-            mockTodoistApi.getTask.mockRejectedValueOnce(new Error('Task not found'));
-            await expect(addTasks.execute({
-                tasks: [
-                    {
-                        content: 'Subtask with bad parent',
-                        parentId: 'nonexistent-parent',
-                        responsibleUser: 'john@example.com',
-                    },
-                ],
-            }, mockTodoistApi)).rejects.toThrow('Task "Subtask with bad parent": Parent task "nonexistent-parent" not found');
-        });
-        it('should require responsibleUser for assign operations', async () => {
-            await expect(manageAssignments.execute({
-                operation: 'assign',
-                taskIds: ['task-1'],
-                dryRun: false,
-            }, mockTodoistApi)).rejects.toThrow('assign operation requires responsibleUser parameter');
-        });
-        it('should require responsibleUser for reassign operations', async () => {
-            await expect(manageAssignments.execute({
-                operation: 'reassign',
-                taskIds: ['task-1'],
-                dryRun: false,
-            }, mockTodoistApi)).rejects.toThrow('reassign operation requires responsibleUser parameter');
-        });
-    });
-    describe('End-to-End Assignment Workflows', () => {
-        it('should support complete assignment lifecycle', async () => {
-            // 1. Create assigned task
-            const createResult = await addTasks.execute({
-                tasks: [
-                    {
-                        content: 'Task for lifecycle test',
-                        projectId: 'project-123',
-                        responsibleUser: 'john@example.com',
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(extractTextContent(createResult)).toContain('Added 1 task');
-            // 2. Update assignment
-            const updateResult = await updateTasks.execute({
-                tasks: [
-                    {
-                        id: 'task-123',
-                        responsibleUser: 'jane@example.com',
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(extractTextContent(updateResult)).toContain('Updated 1 task');
-            // 3. Unassign task
-            const unassignResult = await updateTasks.execute({
-                tasks: [
-                    {
-                        id: 'task-123',
-                        responsibleUser: null,
-                    },
-                ],
-            }, mockTodoistApi);
-            expect(extractTextContent(unassignResult)).toContain('Updated 1 task');
-        });
-    });
-});

package/dist/tools/__tests__/complete-tasks.test.d.ts

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

package/dist/tools/__tests__/complete-tasks.test.d.ts.map

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

package/dist/tools/__tests__/complete-tasks.test.js

@@ -1,206 +0,0 @@
-import { jest } from '@jest/globals';
-import { extractTextContent } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { completeTasks } from '../complete-tasks.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    closeTask: jest.fn(),
-};
-const { COMPLETE_TASKS, GET_OVERVIEW } = ToolNames;
-describe(`${COMPLETE_TASKS} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('completing multiple tasks', () => {
-        it('should complete all tasks successfully', async () => {
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
-            // Verify API was called for each task
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(1, 'task-1');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(2, 'task-2');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(3, 'task-3');
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const { structuredContent } = result;
-            expect(structuredContent).toEqual({
-                completed: ['task-1', 'task-2', 'task-3'],
-                // failures array is removed when empty
-                totalRequested: 3,
-                successCount: 3,
-                failureCount: 0,
-            });
-        });
-        it('should complete single task', async () => {
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await completeTasks.execute({ ids: ['8485093748'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(1);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('8485093748');
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const { structuredContent } = result;
-            expect(structuredContent).toEqual({
-                completed: ['8485093748'],
-                // failures array is removed when empty
-                totalRequested: 1,
-                successCount: 1,
-                failureCount: 0,
-            });
-        });
-        it('should handle partial failures gracefully', async () => {
-            // Mock first and third tasks to succeed, second to fail
-            mockTodoistApi.closeTask
-                .mockResolvedValueOnce(true) // task-1 succeeds
-                .mockRejectedValueOnce(new Error('Task not found')) // task-2 fails
-                .mockResolvedValueOnce(true); // task-3 succeeds
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
-            // Verify API was called for all tasks despite failure
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(1, 'task-1');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(2, 'task-2');
-            expect(mockTodoistApi.closeTask).toHaveBeenNthCalledWith(3, 'task-3');
-            // Verify only successful completions are reported
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content with partial failures
-            const { structuredContent } = result;
-            expect(structuredContent).toEqual(expect.objectContaining({
-                completed: ['task-1', 'task-3'],
-                failures: [
-                    expect.objectContaining({
-                        item: 'task-2',
-                        error: 'Task not found',
-                    }),
-                ],
-                totalRequested: 3,
-                successCount: 2,
-                failureCount: 1,
-            }));
-        });
-        it('should handle all tasks failing', async () => {
-            const apiError = new Error('API Error: Network timeout');
-            mockTodoistApi.closeTask.mockRejectedValue(apiError);
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2'] }, mockTodoistApi);
-            // Verify API was attempted for all tasks
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(2);
-            // Verify no tasks were completed but still returns success
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-        it('should continue processing remaining tasks after failures', async () => {
-            // Mock various failure scenarios
-            mockTodoistApi.closeTask
-                .mockRejectedValueOnce(new Error('Task already completed'))
-                .mockRejectedValueOnce(new Error('Task not found'))
-                .mockResolvedValueOnce(true) // task-3 succeeds
-                .mockRejectedValueOnce(new Error('Permission denied'))
-                .mockResolvedValueOnce(true); // task-5 succeeds
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3', 'task-4', 'task-5'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(5);
-            // Only tasks 3 and 5 should be in completed list
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-        it('should handle different types of API errors', async () => {
-            mockTodoistApi.closeTask
-                .mockRejectedValueOnce(new Error('Task not found'))
-                .mockRejectedValueOnce(new Error('Task already completed'))
-                .mockRejectedValueOnce(new Error('Permission denied'))
-                .mockRejectedValueOnce(new Error('Rate limit exceeded'));
-            const result = await completeTasks.execute({ ids: ['not-found', 'already-done', 'no-permission', 'rate-limited'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(4);
-            // All should fail, but the tool should handle it gracefully
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-    });
-    describe('mixed success and failure scenarios', () => {
-        it('should handle realistic mixed scenario', async () => {
-            // Simulate a realistic scenario with some tasks completing and others failing
-            mockTodoistApi.closeTask
-                .mockResolvedValueOnce(true) // regular task completion
-                .mockResolvedValueOnce(true) // another successful completion
-                .mockRejectedValueOnce(new Error('Task already completed')) // duplicate completion
-                .mockResolvedValueOnce(true) // successful completion
-                .mockRejectedValueOnce(new Error('Task not found')); // deleted task
-            const result = await completeTasks.execute({
-                ids: [
-                    '8485093748', // regular task
-                    '8485093749', // regular task
-                    '8485093750', // already completed
-                    '8485093751', // regular task
-                    '8485093752', // deleted task
-                ],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(5);
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-    });
-    describe('next steps logic validation', () => {
-        it('should suggest overdue tasks when all tasks complete successfully', async () => {
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2'] }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain("Use find-tasks-by-date('today')");
-        });
-        it('should suggest reviewing failures when mixed results', async () => {
-            mockTodoistApi.closeTask
-                .mockResolvedValueOnce(true)
-                .mockRejectedValueOnce(new Error('Task not found'));
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2'] }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Review failed completions and retry if needed');
-        });
-        it('should suggest checking IDs when all tasks fail', async () => {
-            mockTodoistApi.closeTask.mockRejectedValue(new Error('Task not found'));
-            const result = await completeTasks.execute({ ids: ['bad-id-1', 'bad-id-2'] }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Check task IDs and permissions, then retry');
-            expect(textContent).not.toContain(`Use ${GET_OVERVIEW} tool`); // Should only show retry message
-        });
-    });
-    describe('error message truncation', () => {
-        it('should truncate failure messages after 3 errors', async () => {
-            mockTodoistApi.closeTask
-                .mockRejectedValueOnce(new Error('Error 1'))
-                .mockRejectedValueOnce(new Error('Error 2'))
-                .mockRejectedValueOnce(new Error('Error 3'))
-                .mockRejectedValueOnce(new Error('Error 4'))
-                .mockRejectedValueOnce(new Error('Error 5'));
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3', 'task-4', 'task-5'] }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('+2 more'); // 5 total failures, showing first 3, so +2 more
-            expect(textContent).not.toContain('Error 4'); // Should not show 4th error
-            expect(textContent).not.toContain('Error 5'); // Should not show 5th error
-        });
-        it('should not show truncation message for exactly 3 errors', async () => {
-            mockTodoistApi.closeTask
-                .mockRejectedValueOnce(new Error('Error 1'))
-                .mockRejectedValueOnce(new Error('Error 2'))
-                .mockRejectedValueOnce(new Error('Error 3'));
-            const result = await completeTasks.execute({ ids: ['task-1', 'task-2', 'task-3'] }, mockTodoistApi);
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).not.toContain('more'); // Should not show truncation
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle empty task completion (minimum one task required by schema)', async () => {
-            // Note: This test documents that the schema requires at least one task,
-            // so this scenario shouldn't occur in practice due to validation
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await completeTasks.execute({ ids: ['single-task'] }, mockTodoistApi);
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-        it('should handle tasks with special ID formats', async () => {
-            mockTodoistApi.closeTask.mockResolvedValue(true);
-            const result = await completeTasks.execute({ ids: ['proj_123_task_456', 'task-with-dashes', '1234567890'] }, mockTodoistApi);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledTimes(3);
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('proj_123_task_456');
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('task-with-dashes');
-            expect(mockTodoistApi.closeTask).toHaveBeenCalledWith('1234567890');
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-    });
-});

package/dist/tools/__tests__/delete-object.test.d.ts

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

package/dist/tools/__tests__/delete-object.test.d.ts.map

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