@doist/todoist-ai 4.16.0 → 4.17.0

package/dist/tools/__tests__/delete-object.test.js

@@ -1,110 +0,0 @@
-import { jest } from '@jest/globals';
-import { extractTextContent } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { deleteObject } from '../delete-object.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    deleteProject: jest.fn(),
-    deleteSection: jest.fn(),
-    deleteTask: jest.fn(),
-};
-const { FIND_PROJECTS, FIND_TASKS_BY_DATE, DELETE_OBJECT } = ToolNames;
-describe(`${DELETE_OBJECT} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('deleting projects', () => {
-        it('should delete a project by ID', async () => {
-            mockTodoistApi.deleteProject.mockResolvedValue(true);
-            const result = await deleteObject.execute({ type: 'project', id: '6cfCcrrCFg2xP94Q' }, mockTodoistApi);
-            expect(mockTodoistApi.deleteProject).toHaveBeenCalledWith('6cfCcrrCFg2xP94Q');
-            expect(mockTodoistApi.deleteSection).not.toHaveBeenCalled();
-            expect(mockTodoistApi.deleteTask).not.toHaveBeenCalled();
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Deleted project: id=6cfCcrrCFg2xP94Q');
-            expect(textContent).toContain(`Use ${FIND_PROJECTS} to see remaining projects`);
-            expect(result.structuredContent).toEqual({
-                deletedEntity: {
-                    type: 'project',
-                    id: '6cfCcrrCFg2xP94Q',
-                },
-                success: true,
-            });
-        });
-        it('should propagate project deletion errors', async () => {
-            const apiError = new Error('API Error: Cannot delete project with tasks');
-            mockTodoistApi.deleteProject.mockRejectedValue(apiError);
-            await expect(deleteObject.execute({ type: 'project', id: 'project-with-tasks' }, mockTodoistApi)).rejects.toThrow('API Error: Cannot delete project with tasks');
-        });
-    });
-    describe('deleting sections', () => {
-        it('should delete a section by ID', async () => {
-            mockTodoistApi.deleteSection.mockResolvedValue(true);
-            const result = await deleteObject.execute({ type: 'section', id: 'section-123' }, mockTodoistApi);
-            expect(mockTodoistApi.deleteSection).toHaveBeenCalledWith('section-123');
-            expect(mockTodoistApi.deleteProject).not.toHaveBeenCalled();
-            expect(mockTodoistApi.deleteTask).not.toHaveBeenCalled();
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Deleted section: id=section-123');
-            expect(textContent).toContain(`Use ${ToolNames.FIND_SECTIONS} to see remaining sections`);
-            expect(result.structuredContent).toEqual({
-                deletedEntity: { type: 'section', id: 'section-123' },
-                success: true,
-            });
-        });
-        it('should propagate section deletion errors', async () => {
-            const apiError = new Error('API Error: Section not found');
-            mockTodoistApi.deleteSection.mockRejectedValue(apiError);
-            await expect(deleteObject.execute({ type: 'section', id: 'non-existent-section' }, mockTodoistApi)).rejects.toThrow('API Error: Section not found');
-        });
-    });
-    describe('deleting tasks', () => {
-        it('should delete a task by ID', async () => {
-            mockTodoistApi.deleteTask.mockResolvedValue(true);
-            const result = await deleteObject.execute({ type: 'task', id: '8485093748' }, mockTodoistApi);
-            expect(mockTodoistApi.deleteTask).toHaveBeenCalledWith('8485093748');
-            expect(mockTodoistApi.deleteProject).not.toHaveBeenCalled();
-            expect(mockTodoistApi.deleteSection).not.toHaveBeenCalled();
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Deleted task: id=8485093748');
-            expect(textContent).toContain(`Use ${FIND_TASKS_BY_DATE} to see remaining tasks`);
-            expect(result.structuredContent).toEqual({
-                deletedEntity: { type: 'task', id: '8485093748' },
-                success: true,
-            });
-        });
-        it('should propagate task deletion errors', async () => {
-            const apiError = new Error('API Error: Task not found');
-            mockTodoistApi.deleteTask.mockRejectedValue(apiError);
-            await expect(deleteObject.execute({ type: 'task', id: 'non-existent-task' }, mockTodoistApi)).rejects.toThrow('API Error: Task not found');
-        });
-        it('should handle permission errors', async () => {
-            const apiError = new Error('API Error: Insufficient permissions to delete task');
-            mockTodoistApi.deleteTask.mockRejectedValue(apiError);
-            await expect(deleteObject.execute({ type: 'task', id: 'restricted-task' }, mockTodoistApi)).rejects.toThrow('API Error: Insufficient permissions to delete task');
-        });
-    });
-    describe('type validation', () => {
-        it('should handle all supported entity types', async () => {
-            mockTodoistApi.deleteProject.mockResolvedValue(true);
-            mockTodoistApi.deleteSection.mockResolvedValue(true);
-            mockTodoistApi.deleteTask.mockResolvedValue(true);
-            // Delete project
-            await deleteObject.execute({ type: 'project', id: 'proj-1' }, mockTodoistApi);
-            expect(mockTodoistApi.deleteProject).toHaveBeenCalledWith('proj-1');
-            // Delete section
-            await deleteObject.execute({ type: 'section', id: 'sect-1' }, mockTodoistApi);
-            expect(mockTodoistApi.deleteSection).toHaveBeenCalledWith('sect-1');
-            // Delete task
-            await deleteObject.execute({ type: 'task', id: 'task-1' }, mockTodoistApi);
-            expect(mockTodoistApi.deleteTask).toHaveBeenCalledWith('task-1');
-            // Verify each API method was called exactly once
-            expect(mockTodoistApi.deleteProject).toHaveBeenCalledTimes(1);
-            expect(mockTodoistApi.deleteSection).toHaveBeenCalledTimes(1);
-            expect(mockTodoistApi.deleteTask).toHaveBeenCalledTimes(1);
-        });
-    });
-});

package/dist/tools/__tests__/fetch.test.d.ts

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

package/dist/tools/__tests__/fetch.test.d.ts.map

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

package/dist/tools/__tests__/fetch.test.js

@@ -1,279 +0,0 @@
-import { jest } from '@jest/globals';
-import { createMockProject, createMockTask, TEST_IDS } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { fetch } from '../fetch.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    getTask: jest.fn(),
-    getProject: jest.fn(),
-};
-const { FETCH } = ToolNames;
-describe(`${FETCH} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('fetching tasks', () => {
-        it('should fetch a task by composite ID and return full content', async () => {
-            const mockTask = createMockTask({
-                id: TEST_IDS.TASK_1,
-                content: 'Important meeting with team',
-                description: 'Discuss project roadmap and timeline',
-                labels: ['work', 'urgent'],
-                priority: 2,
-                projectId: TEST_IDS.PROJECT_WORK,
-                sectionId: TEST_IDS.SECTION_1,
-                due: {
-                    date: '2025-10-15',
-                    isRecurring: false,
-                    datetime: null,
-                    string: '2025-10-15',
-                    timezone: null,
-                    lang: 'en',
-                },
-            });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            // Verify API was called correctly
-            expect(mockTodoistApi.getTask).toHaveBeenCalledWith(TEST_IDS.TASK_1);
-            // Verify result structure
-            expect(result.content).toHaveLength(1);
-            expect(result.content[0]?.type).toBe('text');
-            // Parse the JSON response
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse).toEqual({
-                id: `task:${TEST_IDS.TASK_1}`,
-                title: 'Important meeting with team',
-                text: 'Important meeting with team\n\nDescription: Discuss project roadmap and timeline\nDue: 2025-10-15\nLabels: work, urgent',
-                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_1}`,
-                metadata: {
-                    priority: 2,
-                    projectId: TEST_IDS.PROJECT_WORK,
-                    sectionId: TEST_IDS.SECTION_1,
-                    parentId: null,
-                    recurring: false,
-                    duration: null,
-                    responsibleUid: null,
-                    assignedByUid: null,
-                    checked: false,
-                    completedAt: null,
-                },
-            });
-        });
-        it('should fetch a task without optional fields', async () => {
-            const mockTask = createMockTask({
-                id: TEST_IDS.TASK_2,
-                content: 'Simple task',
-                description: '',
-                labels: [],
-                due: null,
-            });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_2}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.title).toBe('Simple task');
-            expect(jsonResponse.text).toBe('Simple task');
-            expect(jsonResponse.metadata).toEqual({
-                priority: 1,
-                projectId: TEST_IDS.PROJECT_TEST,
-                sectionId: null,
-                parentId: null,
-                recurring: false,
-                duration: null,
-                responsibleUid: null,
-                assignedByUid: null,
-                checked: false,
-                completedAt: null,
-            });
-        });
-        it('should handle tasks with recurring due dates', async () => {
-            const mockTask = createMockTask({
-                id: TEST_IDS.TASK_3,
-                content: 'Weekly meeting',
-                due: {
-                    date: '2025-10-15',
-                    isRecurring: true,
-                    datetime: null,
-                    string: 'every monday',
-                    timezone: null,
-                    lang: 'en',
-                },
-            });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_3}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.metadata.recurring).toBe('every monday');
-        });
-        it('should handle tasks with duration', async () => {
-            const mockTask = createMockTask({
-                id: TEST_IDS.TASK_1,
-                content: 'Task with duration',
-                duration: {
-                    amount: 90,
-                    unit: 'minute',
-                },
-            });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.metadata.duration).toBe('1h30m');
-        });
-        it('should handle tasks with assignments', async () => {
-            const mockTask = createMockTask({
-                id: TEST_IDS.TASK_1,
-                content: 'Assigned task',
-                responsibleUid: 'user-123',
-                assignedByUid: 'user-456',
-            });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.metadata.responsibleUid).toBe('user-123');
-            expect(jsonResponse.metadata.assignedByUid).toBe('user-456');
-        });
-    });
-    describe('fetching projects', () => {
-        it('should fetch a project by composite ID and return full content', async () => {
-            const mockProject = createMockProject({
-                id: TEST_IDS.PROJECT_WORK,
-                name: 'Work Project',
-                color: 'blue',
-                isFavorite: true,
-                isShared: true,
-                viewStyle: 'board',
-                parentId: null,
-                inboxProject: false,
-            });
-            mockTodoistApi.getProject.mockResolvedValue(mockProject);
-            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_WORK}` }, mockTodoistApi);
-            // Verify API was called correctly
-            expect(mockTodoistApi.getProject).toHaveBeenCalledWith(TEST_IDS.PROJECT_WORK);
-            // Verify result structure
-            expect(result.content).toHaveLength(1);
-            expect(result.content[0]?.type).toBe('text');
-            // Parse the JSON response
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse).toEqual({
-                id: `project:${TEST_IDS.PROJECT_WORK}`,
-                title: 'Work Project',
-                text: 'Work Project\n\nShared project\nFavorite: Yes',
-                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
-                metadata: {
-                    color: 'blue',
-                    isFavorite: true,
-                    isShared: true,
-                    parentId: null,
-                    inboxProject: false,
-                    viewStyle: 'board',
-                },
-            });
-        });
-        it('should fetch a project without optional flags', async () => {
-            const mockProject = createMockProject({
-                id: TEST_IDS.PROJECT_TEST,
-                name: 'Simple Project',
-                isFavorite: false,
-                isShared: false,
-            });
-            mockTodoistApi.getProject.mockResolvedValue(mockProject);
-            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_TEST}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.title).toBe('Simple Project');
-            expect(jsonResponse.text).toBe('Simple Project');
-            expect(jsonResponse.metadata.isFavorite).toBe(false);
-            expect(jsonResponse.metadata.isShared).toBe(false);
-        });
-        it('should fetch inbox project', async () => {
-            const mockProject = createMockProject({
-                id: TEST_IDS.PROJECT_INBOX,
-                name: 'Inbox',
-                inboxProject: true,
-            });
-            mockTodoistApi.getProject.mockResolvedValue(mockProject);
-            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_INBOX}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.metadata.inboxProject).toBe(true);
-        });
-        it('should fetch project with parent ID', async () => {
-            const mockProject = createMockProject({
-                id: 'sub-project-id',
-                name: 'Sub Project',
-                parentId: TEST_IDS.PROJECT_WORK,
-            });
-            mockTodoistApi.getProject.mockResolvedValue(mockProject);
-            const result = await fetch.execute({ id: 'project:sub-project-id' }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse.metadata.parentId).toBe(TEST_IDS.PROJECT_WORK);
-        });
-    });
-    describe('error handling', () => {
-        it('should return error response for invalid ID format (missing colon)', async () => {
-            const result = await fetch.execute({ id: 'invalid-id' }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toContain('Invalid ID format');
-        });
-        it('should return error response for invalid ID format (missing type)', async () => {
-            const result = await fetch.execute({ id: ':8485093748' }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toContain('Invalid ID format');
-        });
-        it('should return error response for invalid ID format (missing object ID)', async () => {
-            const result = await fetch.execute({ id: 'task:' }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toContain('Invalid ID format');
-        });
-        it('should return error response for invalid type', async () => {
-            const result = await fetch.execute({ id: 'section:123' }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toContain('Invalid ID format');
-        });
-        it('should return error response for task fetch failure', async () => {
-            mockTodoistApi.getTask.mockRejectedValue(new Error('Task not found'));
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toBe('Task not found');
-        });
-        it('should return error response for project fetch failure', async () => {
-            mockTodoistApi.getProject.mockRejectedValue(new Error('Project not found'));
-            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_WORK}` }, mockTodoistApi);
-            expect(result.isError).toBe(true);
-            expect(result.content[0]?.text).toBe('Project not found');
-        });
-    });
-    describe('OpenAI MCP spec compliance', () => {
-        it('should return exactly one content item with type "text"', async () => {
-            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            expect(result.content).toHaveLength(1);
-            expect(result.content[0]?.type).toBe('text');
-        });
-        it('should return valid JSON string in text field', async () => {
-            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            expect(() => JSON.parse(result.content[0]?.text ?? '{}')).not.toThrow();
-        });
-        it('should include all required fields (id, title, text, url)', async () => {
-            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse).toHaveProperty('id');
-            expect(jsonResponse).toHaveProperty('title');
-            expect(jsonResponse).toHaveProperty('text');
-            expect(jsonResponse).toHaveProperty('url');
-            expect(typeof jsonResponse.id).toBe('string');
-            expect(typeof jsonResponse.title).toBe('string');
-            expect(typeof jsonResponse.text).toBe('string');
-            expect(typeof jsonResponse.url).toBe('string');
-        });
-        it('should include optional metadata field', async () => {
-            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
-            mockTodoistApi.getTask.mockResolvedValue(mockTask);
-            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
-            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
-            expect(jsonResponse).toHaveProperty('metadata');
-            expect(typeof jsonResponse.metadata).toBe('object');
-        });
-    });
-});

package/dist/tools/__tests__/find-activity.test.d.ts

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

package/dist/tools/__tests__/find-activity.test.d.ts.map

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

package/dist/tools/__tests__/find-activity.test.js

@@ -1,229 +0,0 @@
-import { jest } from '@jest/globals';
-import { extractTextContent } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { findActivity } from '../find-activity.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    getActivityLogs: jest.fn(),
-};
-const { FIND_ACTIVITY } = ToolNames;
-/**
- * Helper to create a mock activity event
- */
-function createMockActivityEvent(overrides = {}) {
-    return {
-        id: 'event-123',
-        objectType: 'task',
-        objectId: 'task-456',
-        eventType: 'added',
-        eventDate: '2024-10-23T10:30:00Z',
-        parentProjectId: 'project-789',
-        parentItemId: null,
-        initiatorId: 'user-001',
-        extraData: null,
-        ...overrides,
-    };
-}
-describe(`${FIND_ACTIVITY} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('basic functionality', () => {
-        it('should retrieve activity events with default parameters', async () => {
-            const mockEvents = [
-                createMockActivityEvent({
-                    id: 'event-1',
-                    eventType: 'added',
-                    eventDate: '2024-10-23T10:00:00Z',
-                }),
-                createMockActivityEvent({
-                    id: 'event-2',
-                    eventType: 'completed',
-                    eventDate: '2024-10-23T11:00:00Z',
-                }),
-            ];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({ limit: 20 }, mockTodoistApi);
-            expect(mockTodoistApi.getActivityLogs).toHaveBeenCalledWith({
-                limit: 20,
-                cursor: null,
-            });
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-        it('should handle empty results', async () => {
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: [],
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({ limit: 20 }, mockTodoistApi);
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-        it('should handle pagination with cursor', async () => {
-            const mockEvents = Array.from({ length: 20 }, (_, i) => createMockActivityEvent({
-                id: `event-${i}`,
-                objectId: `task-${i}`,
-            }));
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: 'next-page-cursor',
-            });
-            const result = await findActivity.execute({ limit: 20, cursor: 'current-cursor' }, mockTodoistApi);
-            expect(mockTodoistApi.getActivityLogs).toHaveBeenCalledWith({
-                limit: 20,
-                cursor: 'current-cursor',
-            });
-            expect(extractTextContent(result)).toContain('Pass cursor');
-            expect(extractTextContent(result)).toContain('next-page-cursor');
-        });
-    });
-    describe('filtering', () => {
-        it.each([
-            ['task', 'added'],
-            ['project', 'updated'],
-            ['comment', 'deleted'],
-        ])('should filter by object type: %s', async (objectType, eventType) => {
-            const mockEvents = [
-                createMockActivityEvent({
-                    objectType: objectType,
-                    eventType: eventType,
-                }),
-            ];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({ objectType: objectType, limit: 20 }, mockTodoistApi);
-            expect(mockTodoistApi.getActivityLogs).toHaveBeenCalledWith({
-                objectType,
-                limit: 20,
-                cursor: null,
-            });
-            expect(extractTextContent(result)).toContain(objectType);
-        });
-        it.each([
-            ['added', 'task-1'],
-            ['completed', 'task-2'],
-            ['updated', 'task-3'],
-            ['deleted', 'task-4'],
-        ])('should filter by event type: %s', async (eventType, objectId) => {
-            const mockEvents = [
-                createMockActivityEvent({
-                    eventType: eventType,
-                    objectId,
-                }),
-            ];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({
-                eventType: eventType,
-                limit: 20,
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getActivityLogs).toHaveBeenCalledWith({
-                eventType,
-                limit: 20,
-                cursor: null,
-            });
-            expect(extractTextContent(result)).toContain(eventType);
-        });
-        it.each([
-            ['objectId', 'task-123', { objectId: 'task-123' }],
-            ['projectId', 'project-abc', { parentProjectId: 'project-abc' }],
-            ['taskId', 'parent-task-789', { parentItemId: 'parent-task-789' }],
-            ['initiatorId', 'user-alice', { initiatorId: 'user-alice' }],
-        ])('should filter by %s', async (filterName, filterId, expectedApiCall) => {
-            const mockEvents = [createMockActivityEvent()];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const args = { limit: 20 };
-            args[filterName] = filterId;
-            await findActivity.execute(args, mockTodoistApi);
-            expect(mockTodoistApi.getActivityLogs).toHaveBeenCalledWith({
-                ...expectedApiCall,
-                limit: 20,
-                cursor: null,
-            });
-        });
-        it('should support multiple filters simultaneously', async () => {
-            const mockEvents = [
-                createMockActivityEvent({
-                    objectType: 'task',
-                    eventType: 'completed',
-                    parentProjectId: 'project-work',
-                    initiatorId: 'user-bob',
-                }),
-            ];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({
-                objectType: 'task',
-                eventType: 'completed',
-                projectId: 'project-work',
-                initiatorId: 'user-bob',
-                limit: 50,
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getActivityLogs).toHaveBeenCalledWith({
-                objectType: 'task',
-                eventType: 'completed',
-                parentProjectId: 'project-work',
-                initiatorId: 'user-bob',
-                limit: 50,
-                cursor: null,
-            });
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-    });
-    describe('content extraction', () => {
-        it('should extract task content from extraData', async () => {
-            const mockEvents = [
-                createMockActivityEvent({
-                    eventType: 'added',
-                    extraData: { content: 'Buy groceries' },
-                }),
-            ];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({ limit: 20 }, mockTodoistApi);
-            expect(extractTextContent(result)).toContain('Buy groceries');
-        });
-        it('should handle system-generated events with no initiator', async () => {
-            const mockEvents = [
-                createMockActivityEvent({
-                    initiatorId: null,
-                    eventType: 'completed',
-                }),
-            ];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({ limit: 20 }, mockTodoistApi);
-            expect(extractTextContent(result)).toContain('system');
-        });
-        it('should truncate long content', async () => {
-            const longContent = 'A'.repeat(100);
-            const mockEvents = [
-                createMockActivityEvent({
-                    extraData: { content: longContent },
-                }),
-            ];
-            mockTodoistApi.getActivityLogs.mockResolvedValue({
-                results: mockEvents,
-                nextCursor: null,
-            });
-            const result = await findActivity.execute({ limit: 20 }, mockTodoistApi);
-            expect(extractTextContent(result)).toContain('...');
-            expect(extractTextContent(result)).not.toContain(longContent);
-        });
-    });
-});

package/dist/tools/__tests__/find-comments.test.d.ts

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

package/dist/tools/__tests__/find-comments.test.d.ts.map

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