@doist/todoist-ai 4.16.0 → 4.17.0

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

@@ -1,236 +0,0 @@
-import { jest } from '@jest/globals';
-import { extractStructuredContent, extractTextContent } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { findComments } from '../find-comments.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    getComment: jest.fn(),
-    getComments: jest.fn(),
-};
-const { FIND_COMMENTS } = ToolNames;
-const createMockComment = (overrides = {}) => ({
-    id: '12345',
-    content: 'Test comment content',
-    postedAt: '2024-01-01T12:00:00Z',
-    postedUid: 'user123',
-    taskId: 'task123',
-    projectId: undefined,
-    fileAttachment: null,
-    uidsToNotify: null,
-    reactions: null,
-    isDeleted: false,
-    ...overrides,
-});
-describe(`${FIND_COMMENTS} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('finding comments by task', () => {
-        it('should find comments for a task', async () => {
-            const mockComments = [
-                createMockComment({ id: '1', content: 'First comment', taskId: 'task123' }),
-                createMockComment({ id: '2', content: 'Second comment', taskId: 'task123' }),
-            ];
-            mockTodoistApi.getComments.mockResolvedValue({
-                results: mockComments,
-                nextCursor: null,
-            });
-            const result = await findComments.execute({
-                taskId: 'task123',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getComments).toHaveBeenCalledWith({
-                taskId: 'task123',
-                cursor: null,
-                limit: 10,
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: expect.arrayContaining([
-                    expect.objectContaining({ id: '1', content: 'First comment' }),
-                    expect.objectContaining({ id: '2', content: 'Second comment' }),
-                ]),
-                searchType: 'task',
-                searchId: 'task123',
-                hasMore: false,
-                totalCount: 2,
-            }));
-        });
-        it('should handle pagination', async () => {
-            const mockComments = [createMockComment({ id: '1', content: 'Comment 1' })];
-            mockTodoistApi.getComments.mockResolvedValue({
-                results: mockComments,
-                nextCursor: 'next_page_token',
-            });
-            const result = await findComments.execute({
-                taskId: 'task123',
-                limit: 1,
-                cursor: 'current_cursor',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getComments).toHaveBeenCalledWith({
-                taskId: 'task123',
-                cursor: 'current_cursor',
-                limit: 1,
-            });
-            // Verify result includes pagination info
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content includes pagination
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: expect.arrayContaining([
-                    expect.objectContaining({ id: '1', content: 'Comment 1' }),
-                ]),
-                searchType: 'task',
-                searchId: 'task123',
-                hasMore: true,
-                nextCursor: 'next_page_token',
-                totalCount: 1,
-            }));
-        });
-    });
-    describe('finding comments by project', () => {
-        it('should find comments for a project', async () => {
-            const mockComments = [
-                createMockComment({
-                    id: '1',
-                    content: 'Project comment',
-                    taskId: undefined,
-                    projectId: 'project456',
-                }),
-            ];
-            mockTodoistApi.getComments.mockResolvedValue({
-                results: mockComments,
-                nextCursor: null,
-            });
-            const result = await findComments.execute({
-                projectId: 'project456',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getComments).toHaveBeenCalledWith({
-                projectId: 'project456',
-                cursor: null,
-                limit: 10,
-            });
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: '1',
-                        content: 'Project comment',
-                        projectId: 'project456',
-                    }),
-                ]),
-                searchType: 'project',
-                searchId: 'project456',
-                hasMore: false,
-                totalCount: 1,
-            }));
-        });
-    });
-    describe('finding single comment', () => {
-        it('should find comment by ID', async () => {
-            const mockComment = createMockComment({
-                id: 'comment789',
-                content: 'Single comment content',
-                taskId: 'task123',
-            });
-            mockTodoistApi.getComment.mockResolvedValue(mockComment);
-            const result = await findComments.execute({
-                commentId: 'comment789',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getComment).toHaveBeenCalledWith('comment789');
-            // Verify result is a concise summary
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: 'comment789',
-                        content: 'Single comment content',
-                        taskId: 'task123',
-                    }),
-                ]),
-                searchType: 'single',
-                searchId: 'comment789',
-                hasMore: false,
-                totalCount: 1,
-            }));
-        });
-        it('should handle comment with attachment', async () => {
-            const mockComment = createMockComment({
-                id: 'comment789',
-                content: 'Comment with file',
-                fileAttachment: {
-                    resourceType: 'file',
-                    fileName: 'document.pdf',
-                    fileUrl: 'https://example.com/document.pdf',
-                    fileType: 'application/pdf',
-                },
-            });
-            mockTodoistApi.getComment.mockResolvedValue(mockComment);
-            const result = await findComments.execute({
-                commentId: 'comment789',
-            }, mockTodoistApi);
-            // Verify result includes attachment info
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content includes attachment
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: expect.arrayContaining([
-                    expect.objectContaining({
-                        id: 'comment789',
-                        content: 'Comment with file',
-                        fileAttachment: expect.objectContaining({
-                            resourceType: 'file',
-                            fileName: 'document.pdf',
-                            fileUrl: 'https://example.com/document.pdf',
-                            fileType: 'application/pdf',
-                        }),
-                    }),
-                ]),
-                searchType: 'single',
-                searchId: 'comment789',
-                hasMore: false,
-                totalCount: 1,
-            }));
-        });
-    });
-    describe('validation', () => {
-        it('should throw error when no search parameter provided', async () => {
-            await expect(findComments.execute({}, mockTodoistApi)).rejects.toThrow('Must provide exactly one of: taskId, projectId, or commentId.');
-        });
-        it('should throw error when multiple search parameters provided', async () => {
-            await expect(findComments.execute({
-                taskId: 'task123',
-                projectId: 'project456',
-            }, mockTodoistApi)).rejects.toThrow('Cannot provide multiple search parameters.');
-        });
-    });
-    describe('empty results', () => {
-        it('should handle no comments found', async () => {
-            mockTodoistApi.getComments.mockResolvedValue({
-                results: [],
-                nextCursor: null,
-            });
-            const result = await findComments.execute({
-                taskId: 'task123',
-            }, mockTodoistApi);
-            // Verify result handles empty case
-            expect(extractTextContent(result)).toMatchSnapshot();
-            // Verify structured content
-            const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual({
-                searchType: 'task',
-                searchId: 'task123',
-                hasMore: false,
-                totalCount: 0,
-                // comments array is removed when empty
-            });
-        });
-    });
-});

package/dist/tools/__tests__/find-completed-tasks.test.d.ts

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

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

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

package/dist/tools/__tests__/find-completed-tasks.test.js

@@ -1,423 +0,0 @@
-import { jest } from '@jest/globals';
-import { createMockTask, createMockUser, extractTextContent, TEST_IDS, } from '../../utils/test-helpers.js';
-import { ToolNames } from '../../utils/tool-names.js';
-import { findCompletedTasks } from '../find-completed-tasks.js';
-// Mock the Todoist API
-const mockTodoistApi = {
-    getCompletedTasksByCompletionDate: jest.fn(),
-    getCompletedTasksByDueDate: jest.fn(),
-    getUser: jest.fn(),
-};
-const { FIND_COMPLETED_TASKS } = ToolNames;
-describe(`${FIND_COMPLETED_TASKS} tool`, () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        // Mock default user with UTC timezone
-        mockTodoistApi.getUser.mockResolvedValue({
-            id: 'test-user-id',
-            fullName: 'Test User',
-            email: 'test@example.com',
-            tzInfo: {
-                timezone: 'UTC',
-                gmtString: '+00:00',
-                hours: 0,
-                minutes: 0,
-                isDst: 0,
-            },
-        });
-    });
-    describe('getting completed tasks by completion date (default)', () => {
-        it('should get completed tasks by completion date', async () => {
-            const mockCompletedTasks = [
-                createMockTask({
-                    id: '8485093748',
-                    content: 'Completed task 1',
-                    description: 'Task completed yesterday',
-                    completedAt: '2024-01-01T00:00:00Z',
-                    labels: ['work'],
-                    priority: 2,
-                    url: 'https://todoist.com/showTask?id=8485093748',
-                    addedAt: '2025-08-13T22:09:56.123456Z',
-                    due: {
-                        date: '2025-08-14',
-                        isRecurring: false,
-                        lang: 'en',
-                        string: 'Aug 14',
-                        timezone: null,
-                    },
-                }),
-            ];
-            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
-                items: mockCompletedTasks,
-                nextCursor: null,
-            });
-            const result = await findCompletedTasks.execute({
-                getBy: 'completion',
-                limit: 50,
-                since: '2025-08-10',
-                until: '2025-08-15',
-                labels: [],
-                labelsOperator: 'or',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
-                since: '2025-08-10T00:00:00.000Z',
-                until: '2025-08-15T23:59:59.000Z',
-                limit: 50,
-            });
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-        it('should handle explicit completion date query', async () => {
-            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
-                items: [],
-                nextCursor: 'next-cursor',
-            });
-            const result = await findCompletedTasks.execute({
-                getBy: 'completion',
-                limit: 100,
-                since: '2025-08-01',
-                until: '2025-08-31',
-                projectId: 'specific-project-id',
-                cursor: 'current-cursor',
-                labels: [],
-                labelsOperator: 'or',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
-                since: '2025-08-01T00:00:00.000Z',
-                until: '2025-08-31T23:59:59.000Z',
-                projectId: 'specific-project-id',
-                limit: 100,
-                cursor: 'current-cursor',
-            });
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-    });
-    describe('getting completed tasks by due date', () => {
-        it('should get completed tasks by due date', async () => {
-            const mockCompletedTasks = [
-                createMockTask({
-                    id: '8485093750',
-                    content: 'Task completed by due date',
-                    description: 'This task was due and completed',
-                    completedAt: '2024-01-01T00:00:00Z',
-                    labels: ['urgent'],
-                    priority: 3,
-                    url: 'https://todoist.com/showTask?id=8485093750',
-                    addedAt: '2025-08-13T22:09:58.123456Z',
-                    due: {
-                        date: '2025-08-15',
-                        isRecurring: true,
-                        lang: 'en',
-                        string: 'every Monday',
-                        timezone: null,
-                    },
-                }),
-            ];
-            mockTodoistApi.getCompletedTasksByDueDate.mockResolvedValue({
-                items: mockCompletedTasks,
-                nextCursor: null,
-            });
-            const result = await findCompletedTasks.execute({
-                getBy: 'due',
-                limit: 50,
-                since: '2025-08-10',
-                until: '2025-08-20',
-                labels: [],
-                labelsOperator: 'or',
-            }, mockTodoistApi);
-            expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
-                since: '2025-08-10T00:00:00.000Z',
-                until: '2025-08-20T23:59:59.000Z',
-                limit: 50,
-            });
-            expect(mockTodoistApi.getCompletedTasksByCompletionDate).not.toHaveBeenCalled();
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-    });
-    describe('label filtering', () => {
-        it.each([
-            {
-                name: 'single label with OR operator',
-                params: {
-                    getBy: 'completion',
-                    since: '2025-08-01',
-                    until: '2025-08-31',
-                    limit: 50,
-                    labels: ['work'],
-                },
-                expectedMethod: 'getCompletedTasksByCompletionDate',
-                expectedFilter: '(@work)',
-            },
-            {
-                name: 'multiple labels with AND operator',
-                params: {
-                    getBy: 'due',
-                    since: '2025-08-01',
-                    until: '2025-08-31',
-                    limit: 50,
-                    labels: ['work', 'urgent'],
-                    labelsOperator: 'and',
-                },
-                expectedMethod: 'getCompletedTasksByDueDate',
-                expectedFilter: '(@work  &  @urgent)',
-            },
-            {
-                name: 'multiple labels with OR operator',
-                params: {
-                    getBy: 'completion',
-                    since: '2025-08-10',
-                    until: '2025-08-20',
-                    limit: 25,
-                    labels: ['personal', 'shopping'],
-                },
-                expectedMethod: 'getCompletedTasksByCompletionDate',
-                expectedFilter: '(@personal  |  @shopping)',
-            },
-        ])('should filter completed tasks by labels: $name', async ({ params, expectedMethod, expectedFilter }) => {
-            const mockCompletedTasks = [
-                createMockTask({
-                    id: '8485093748',
-                    content: 'Completed task with label',
-                    labels: params.labels,
-                    completedAt: '2024-01-01T00:00:00Z',
-                }),
-            ];
-            const mockResponse = { items: mockCompletedTasks, nextCursor: null };
-            const mockMethod = mockTodoistApi[expectedMethod];
-            mockMethod.mockResolvedValue(mockResponse);
-            const result = await findCompletedTasks.execute(params, mockTodoistApi);
-            expect(mockMethod).toHaveBeenCalledWith({
-                since: `${params.since}T00:00:00.000Z`,
-                until: `${params.until}T23:59:59.000Z`,
-                limit: params.limit,
-                filterQuery: expectedFilter,
-                filterLang: 'en',
-            });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-        });
-        it('should handle empty labels array', async () => {
-            const params = {
-                getBy: 'completion',
-                since: '2025-08-01',
-                until: '2025-08-31',
-                limit: 50,
-                labels: [],
-                labelsOperator: 'or',
-            };
-            const mockResponse = { items: [], nextCursor: null };
-            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue(mockResponse);
-            await findCompletedTasks.execute(params, mockTodoistApi);
-            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
-                since: `${params.since}T00:00:00.000Z`,
-                until: `${params.until}T23:59:59.000Z`,
-                limit: params.limit,
-            });
-        });
-        it('should combine other filters with label filters', async () => {
-            const params = {
-                getBy: 'due',
-                since: '2025-08-01',
-                until: '2025-08-31',
-                limit: 25,
-                projectId: 'test-project-id',
-                sectionId: 'test-section-id',
-                labels: ['important'],
-                labelsOperator: 'or',
-            };
-            const mockTasks = [
-                createMockTask({
-                    content: 'Important completed task',
-                    labels: ['important'],
-                    completedAt: '2024-01-01T00:00:00Z',
-                }),
-            ];
-            const mockResponse = { items: mockTasks, nextCursor: null };
-            mockTodoistApi.getCompletedTasksByDueDate.mockResolvedValue(mockResponse);
-            const result = await findCompletedTasks.execute(params, mockTodoistApi);
-            expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
-                since: `${params.since}T00:00:00.000Z`,
-                until: `${params.until}T23:59:59.000Z`,
-                limit: params.limit,
-                projectId: params.projectId,
-                sectionId: params.sectionId,
-                filterQuery: '(@important)',
-                filterLang: 'en',
-            });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-        });
-    });
-    describe('timezone handling', () => {
-        it('should convert user timezone to UTC correctly (Europe/Madrid)', async () => {
-            // Mock user with Madrid timezone
-            mockTodoistApi.getUser.mockResolvedValue({
-                id: 'test-user-id',
-                fullName: 'Test User',
-                email: 'test@example.com',
-                tzInfo: {
-                    timezone: 'Europe/Madrid',
-                    gmtString: '+02:00',
-                    hours: 2,
-                    minutes: 0,
-                    isDst: 0,
-                },
-            });
-            const mockCompletedTasks = [
-                createMockTask({
-                    id: '8485093750',
-                    content: 'Task completed in Madrid timezone',
-                    completedAt: '2025-10-11T15:30:00Z',
-                }),
-            ];
-            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
-                items: mockCompletedTasks,
-                nextCursor: null,
-            });
-            const result = await findCompletedTasks.execute({
-                getBy: 'completion',
-                limit: 50,
-                since: '2025-10-11',
-                until: '2025-10-11',
-                labels: [],
-                labelsOperator: 'or',
-            }, mockTodoistApi);
-            // Should convert Madrid local time to UTC
-            // 2025-10-11 00:00:00 +02:00 = 2025-10-10 22:00:00 UTC
-            // 2025-10-11 23:59:59 +02:00 = 2025-10-11 21:59:59 UTC
-            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
-                since: '2025-10-10T22:00:00.000Z',
-                until: '2025-10-11T21:59:59.000Z',
-                limit: 50,
-            });
-            expect(extractTextContent(result)).toMatchSnapshot();
-        });
-    });
-    describe('error handling', () => {
-        it('should propagate completion date API errors', async () => {
-            const apiError = new Error('API Error: Invalid date range');
-            mockTodoistApi.getCompletedTasksByCompletionDate.mockRejectedValue(apiError);
-            await expect(findCompletedTasks.execute(
-            // invalid date range
-            {
-                getBy: 'completion',
-                limit: 50,
-                since: '2025-08-31',
-                until: '2025-08-01',
-                labels: [],
-                labelsOperator: 'or',
-            }, mockTodoistApi)).rejects.toThrow('API Error: Invalid date range');
-        });
-        it('should propagate due date API errors', async () => {
-            const apiError = new Error('API Error: Project not found');
-            mockTodoistApi.getCompletedTasksByDueDate.mockRejectedValue(apiError);
-            await expect(findCompletedTasks.execute({
-                getBy: 'due',
-                limit: 50,
-                since: '2025-08-01',
-                until: '2025-08-31',
-                projectId: 'non-existent-project',
-                labels: [],
-                labelsOperator: 'or',
-            }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
-        });
-    });
-    describe('inbox project ID resolution', () => {
-        it('should resolve "inbox" to actual inbox project ID', async () => {
-            const mockUser = createMockUser({
-                inboxProjectId: TEST_IDS.PROJECT_INBOX,
-                tzInfo: {
-                    timezone: 'UTC',
-                    gmtString: '+00:00',
-                    hours: 0,
-                    minutes: 0,
-                    isDst: 0,
-                },
-            });
-            const mockCompletedTasks = [
-                createMockTask({
-                    id: '8485093760',
-                    content: 'Completed inbox task',
-                    projectId: TEST_IDS.PROJECT_INBOX,
-                    completedAt: '2025-08-15T12:00:00Z',
-                    url: 'https://todoist.com/showTask?id=8485093760',
-                    addedAt: '2025-08-13T22:09:56.123456Z',
-                }),
-            ];
-            // Mock getUser to return our mock user with inbox ID
-            mockTodoistApi.getUser.mockResolvedValue(mockUser);
-            // Mock the API response
-            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
-                items: mockCompletedTasks,
-                nextCursor: null,
-            });
-            const result = await findCompletedTasks.execute({
-                getBy: 'completion',
-                since: '2025-08-15',
-                until: '2025-08-15',
-                projectId: 'inbox',
-                labels: [],
-                labelsOperator: 'or',
-                limit: 50,
-            }, mockTodoistApi);
-            // Verify getUser was called
-            expect(mockTodoistApi.getUser).toHaveBeenCalledTimes(1);
-            // Verify getCompletedTasksByCompletionDate was called with resolved inbox project ID
-            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith(expect.objectContaining({
-                projectId: TEST_IDS.PROJECT_INBOX,
-                since: '2025-08-15T00:00:00.000Z',
-                until: '2025-08-15T23:59:59.000Z',
-                limit: 50,
-            }));
-            // Verify result contains the completed tasks
-            const textContent = extractTextContent(result);
-            expect(textContent).toContain('Completed tasks');
-            expect(textContent).toContain('Completed inbox task');
-        });
-        it('should use regular project ID when not "inbox"', async () => {
-            const mockUser = createMockUser({
-                tzInfo: {
-                    timezone: 'UTC',
-                    gmtString: '+00:00',
-                    hours: 0,
-                    minutes: 0,
-                    isDst: 0,
-                },
-            });
-            const mockCompletedTasks = [
-                createMockTask({
-                    id: '8485093761',
-                    content: 'Completed regular task',
-                    projectId: '6cfCcrrCFg2xP94Q',
-                    completedAt: '2025-08-15T12:00:00Z',
-                    url: 'https://todoist.com/showTask?id=8485093761',
-                    addedAt: '2025-08-13T22:09:56.123456Z',
-                }),
-            ];
-            // Mock getUser (will be called for timezone, but inbox resolution won't happen)
-            mockTodoistApi.getUser.mockResolvedValue(mockUser);
-            // Mock the API response
-            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
-                items: mockCompletedTasks,
-                nextCursor: null,
-            });
-            await findCompletedTasks.execute({
-                getBy: 'completion',
-                since: '2025-08-15',
-                until: '2025-08-15',
-                projectId: '6cfCcrrCFg2xP94Q',
-                labels: [],
-                labelsOperator: 'or',
-                limit: 50,
-            }, mockTodoistApi);
-            // Verify getUser was called (for timezone info)
-            expect(mockTodoistApi.getUser).toHaveBeenCalledTimes(1);
-            // Verify getCompletedTasksByCompletionDate was called with original project ID
-            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith(expect.objectContaining({
-                projectId: '6cfCcrrCFg2xP94Q',
-                since: '2025-08-15T00:00:00.000Z',
-                until: '2025-08-15T23:59:59.000Z',
-                limit: 50,
-            }));
-        });
-    });
-});

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

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

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

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