@doist/todoist-ai 4.1.0 → 4.4.0

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

@@ -37,7 +37,14 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 items: mockCompletedTasks,
                 nextCursor: null,
             });
-            const result = await findCompletedTasks.execute({ getBy: 'completion', limit: 50, since: '2025-08-10', until: '2025-08-15' }, mockTodoistApi);
+            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-10',
                 until: '2025-08-15',
@@ -57,6 +64,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 until: '2025-08-31',
                 projectId: 'specific-project-id',
                 cursor: 'current-cursor',
+                labels: [],
+                labelsOperator: 'or',
             }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith({
                 since: '2025-08-01',
@@ -98,6 +107,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 limit: 50,
                 since: '2025-08-10',
                 until: '2025-08-20',
+                labels: [],
+                labelsOperator: 'or',
             }, mockTodoistApi);
             expect(mockTodoistApi.getCompletedTasksByDueDate).toHaveBeenCalledWith({
                 since: '2025-08-10',
@@ -108,13 +119,134 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
             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,
+                until: params.until,
+                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,
+                until: params.until,
+                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,
+                until: params.until,
+                limit: params.limit,
+                projectId: params.projectId,
+                sectionId: params.sectionId,
+                filterQuery: '(@important)',
+                filterLang: 'en',
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).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' }, mockTodoistApi)).rejects.toThrow('API Error: 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');
@@ -125,6 +257,8 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
                 since: '2025-08-01',
                 until: '2025-08-31',
                 projectId: 'non-existent-project',
+                labels: [],
+                labelsOperator: 'or',
             }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
         });
     });

package/dist/tools/__tests__/find-tasks-by-date.test.js

@@ -193,7 +193,11 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             ];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasksByDate.execute({ startDate: '2025-08-15', limit: 10, daysCount: 1 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({
+                startDate: '2025-08-15',
+                limit: 10,
+                daysCount: 1,
+            }, mockTodoistApi);
             const textContent = extractTextContent(result);
             expect(textContent).toMatchSnapshot();
             expect(textContent).toContain(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
@@ -240,13 +244,128 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
         it('should provide helpful suggestions for empty date range results', async () => {
             const mockResponse = { tasks: [], nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasksByDate.execute({ startDate: '2025-08-20', limit: 10, daysCount: 1 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({
+                startDate: '2025-08-20',
+                limit: 10,
+                daysCount: 1,
+            }, mockTodoistApi);
             const textContent = extractTextContent(result);
             expect(textContent).toMatchSnapshot();
             expect(textContent).toContain("Expand date range with larger 'daysCount'");
             expect(textContent).toContain("Check 'overdue' for past-due items");
         });
     });
+    describe('label filtering', () => {
+        it.each([
+            {
+                name: 'single label with OR operator',
+                params: {
+                    startDate: 'today',
+                    daysCount: 1,
+                    limit: 50,
+                    labels: ['work'],
+                },
+                expectedQueryPattern: '((@work))', // Will be combined with date query
+            },
+            {
+                name: 'multiple labels with AND operator',
+                params: {
+                    startDate: 'overdue',
+                    daysCount: 1,
+                    limit: 50,
+                    labels: ['work', 'urgent'],
+                    labelsOperator: 'and',
+                },
+                expectedQueryPattern: 'overdue & ((@work  &  @urgent))',
+            },
+            {
+                name: 'multiple labels with OR operator',
+                params: {
+                    startDate: '2025-08-20',
+                    daysCount: 3,
+                    limit: 50,
+                    labels: ['personal', 'shopping'],
+                    labelsOperator: 'or',
+                },
+                expectedQueryPattern: '((@personal  |  @shopping))',
+            },
+        ])('should filter tasks by labels: $name', async ({ params, expectedQueryPattern }) => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task with work label',
+                    labels: ['work'],
+                    dueDate: '2025-08-20',
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.stringContaining('(@'),
+                cursor: undefined,
+                limit: 50,
+            });
+            // For overdue specifically, check the exact pattern
+            if (params.startDate === 'overdue') {
+                expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                    client: mockTodoistApi,
+                    query: expectedQueryPattern,
+                    cursor: undefined,
+                    limit: 50,
+                });
+            }
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
+                labels: params.labels,
+                ...(params.labelsOperator ? { labelsOperator: params.labelsOperator } : {}),
+            }));
+        });
+        it('should handle empty labels array', async () => {
+            const params = {
+                startDate: 'today',
+                daysCount: 1,
+                limit: 50,
+            };
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            await findTasksByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.not.stringContaining('@'),
+                cursor: undefined,
+                limit: 50,
+            });
+        });
+        it('should combine date filters with label filters', async () => {
+            const params = {
+                startDate: '2025-08-15',
+                daysCount: 1,
+                limit: 25,
+                labels: ['important'],
+            };
+            const mockTasks = [
+                createMappedTask({
+                    content: 'Important task for specific date',
+                    labels: ['important'],
+                    dueDate: '2025-08-15',
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expect.stringContaining('due after:') &&
+                    expect.stringContaining('(@important)'),
+                cursor: undefined,
+                limit: 25,
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+        });
+    });
     describe('error handling', () => {
         it.each([
             {

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

@@ -60,7 +60,6 @@ describe(`${FIND_TASKS} tool`, () => {
                 appliedFilters: {
                     searchText: 'important meeting',
                     limit: 10,
-                    cursor: undefined,
                 },
             }));
             expect(structuredContent).toEqual(expect.objectContaining({
@@ -70,14 +69,21 @@ describe(`${FIND_TASKS} tool`, () => {
         it.each([
             {
                 name: 'custom limit',
-                params: { searchText: 'project update', limit: 5 },
+                params: {
+                    searchText: 'project update',
+                    limit: 5,
+                },
                 expectedQuery: 'search: project update',
                 expectedLimit: 5,
                 expectedCursor: undefined,
             },
             {
                 name: 'pagination cursor',
-                params: { searchText: 'follow up', limit: 20, cursor: 'cursor-from-first-page' },
+                params: {
+                    searchText: 'follow up',
+                    limit: 20,
+                    cursor: 'cursor-from-first-page',
+                },
                 expectedQuery: 'search: follow up',
                 expectedLimit: 20,
                 expectedCursor: 'cursor-from-first-page',
@@ -141,26 +147,35 @@ describe(`${FIND_TASKS} tool`, () => {
     });
     describe('validation', () => {
         it('should require at least one filter parameter', async () => {
-            await expect(findTasks.execute({ limit: 10 }, mockTodoistApi)).rejects.toThrow('At least one filter must be provided: searchText, projectId, sectionId, or parentId');
+            await expect(findTasks.execute({ limit: 10 }, mockTodoistApi)).rejects.toThrow('At least one filter must be provided: searchText, projectId, sectionId, parentId, or labels');
         });
     });
     describe('container filtering', () => {
         it.each([
             {
                 name: 'project',
-                params: { projectId: TEST_IDS.PROJECT_TEST, limit: 10 },
+                params: {
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    limit: 10,
+                },
                 expectedApiParam: { projectId: TEST_IDS.PROJECT_TEST },
                 tasks: [createMockTask({ content: 'Project task' })],
             },
             {
                 name: 'section',
-                params: { sectionId: TEST_IDS.SECTION_1, limit: 10 },
+                params: {
+                    sectionId: TEST_IDS.SECTION_1,
+                    limit: 10,
+                },
                 expectedApiParam: { sectionId: TEST_IDS.SECTION_1 },
                 tasks: [createMockTask({ content: 'Section task' })],
             },
             {
                 name: 'parent task',
-                params: { parentId: TEST_IDS.TASK_1, limit: 10 },
+                params: {
+                    parentId: TEST_IDS.TASK_1,
+                    limit: 10,
+                },
                 expectedApiParam: { parentId: TEST_IDS.TASK_1 },
                 tasks: [createMockTask({ content: 'Subtask' })],
             },
@@ -307,21 +322,253 @@ describe(`${FIND_TASKS} tool`, () => {
             expect(textContent).toContain('Verify spelling and try partial words');
         });
     });
+    describe('label filtering', () => {
+        it.each([
+            {
+                name: 'text search with single label OR operator',
+                params: {
+                    searchText: 'important meeting',
+                    limit: 10,
+                    labels: ['work'],
+                },
+                expectedQuery: 'search: important meeting & (@work)',
+            },
+            {
+                name: 'text search with multiple labels AND operator',
+                params: {
+                    searchText: 'project update',
+                    limit: 15,
+                    labels: ['work', 'urgent'],
+                    labelsOperator: 'and',
+                },
+                expectedQuery: 'search: project update & (@work  &  @urgent)',
+            },
+            {
+                name: 'text search with multiple labels OR operator',
+                params: {
+                    searchText: 'follow up',
+                    limit: 20,
+                    labels: ['personal', 'shopping'],
+                },
+                expectedQuery: 'search: follow up & (@personal  |  @shopping)',
+            },
+        ])('should filter tasks by labels in text search: $name', async ({ params, expectedQuery }) => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task with work label',
+                    labels: ['work'],
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: expectedQuery,
+                cursor: undefined,
+                limit: params.limit,
+            });
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
+                searchText: params.searchText,
+                labels: params.labels,
+                ...(params.labelsOperator ? { labelsOperator: params.labelsOperator } : {}),
+            }));
+        });
+        it.each([
+            {
+                name: 'project filter with labels',
+                params: {
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    limit: 10,
+                    labels: ['important'],
+                },
+                expectedApiParam: { projectId: TEST_IDS.PROJECT_TEST },
+            },
+            {
+                name: 'section filter with multiple labels',
+                params: {
+                    sectionId: TEST_IDS.SECTION_1,
+                    limit: 10,
+                    labels: ['work', 'urgent'],
+                    labelsOperator: 'and',
+                },
+                expectedApiParam: { sectionId: TEST_IDS.SECTION_1 },
+            },
+            {
+                name: 'parent task filter with labels',
+                params: {
+                    parentId: TEST_IDS.TASK_1,
+                    limit: 10,
+                    labels: ['personal'],
+                },
+                expectedApiParam: { parentId: TEST_IDS.TASK_1 },
+            },
+        ])('should apply label filtering to container searches: $name', async ({ params, expectedApiParam }) => {
+            const allTasks = [
+                createMockTask({
+                    id: '1',
+                    content: 'Task with matching label',
+                    labels: params.labels,
+                }),
+                createMockTask({
+                    id: '2',
+                    content: 'Task without matching label',
+                    labels: ['other'],
+                }),
+            ];
+            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(allTasks));
+            const result = await findTasks.execute(params, mockTodoistApi);
+            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
+                limit: 10,
+                cursor: null,
+                ...expectedApiParam,
+            });
+            // Should filter results client-side based on labels
+            const structuredContent = extractStructuredContent(result);
+            if (params.labelsOperator === 'and') {
+                // AND operation: task must have all specified labels
+                expect(structuredContent.tasks).toEqual(expect.arrayContaining([
+                    expect.objectContaining({
+                        labels: expect.arrayContaining(params.labels),
+                    }),
+                ]));
+            }
+            else {
+                // OR operation: task must have at least one of the specified labels
+                expect(structuredContent.tasks.length).toBeGreaterThanOrEqual(0);
+            }
+        });
+        it('should handle empty labels array', async () => {
+            const params = {
+                searchText: 'test',
+                limit: 10,
+            };
+            const mockResponse = { tasks: [], nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            await findTasks.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: 'search: test',
+                cursor: undefined,
+                limit: 10,
+            });
+        });
+        it('should combine search text, container, and label filters', async () => {
+            const params = {
+                projectId: TEST_IDS.PROJECT_TEST,
+                searchText: 'important',
+                limit: 10,
+                labels: ['urgent'],
+            };
+            const allTasks = [
+                createMockTask({
+                    id: '1',
+                    content: 'important task',
+                    description: 'urgent work',
+                    labels: ['urgent'],
+                }),
+                createMockTask({
+                    id: '2',
+                    content: 'other task',
+                    description: 'not important',
+                    labels: ['work'],
+                }),
+            ];
+            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(allTasks));
+            const result = await findTasks.execute(params, mockTodoistApi);
+            // Should call API with container filter
+            expect(mockTodoistApi.getTasks).toHaveBeenCalledWith({
+                limit: 10,
+                cursor: null,
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+            // Should filter results by search text AND labels
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.tasks).toEqual([
+                expect.objectContaining({
+                    content: 'important task',
+                    labels: expect.arrayContaining(['urgent']),
+                }),
+            ]);
+        });
+        it('should handle labels-only filtering', async () => {
+            const params = {
+                limit: 10,
+                labels: ['work'],
+            };
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task with work label',
+                    labels: ['work'],
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute(params, mockTodoistApi);
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: '(@work)',
+                cursor: undefined,
+                limit: 10,
+            });
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
+                labels: ['work'],
+            }));
+        });
+        it('should handle labels with @ symbol', async () => {
+            const params = {
+                limit: 10,
+                labels: ['@work', 'personal'], // Mix of with and without @
+            };
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Task with work label',
+                    labels: ['work', 'personal'],
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute(params, mockTodoistApi);
+            // Should handle both @work (already has @) and personal (needs @ added)
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: '(@work  |  @personal)',
+                cursor: undefined,
+                limit: 10,
+            });
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.appliedFilters).toEqual(expect.objectContaining({
+                labels: ['@work', 'personal'],
+            }));
+        });
+    });
     describe('error handling', () => {
         it.each([
             {
-                error: 'At least one filter must be provided: searchText, projectId, sectionId, or parentId',
+                error: 'At least one filter must be provided: searchText, projectId, sectionId, parentId, or labels',
                 params: { limit: 10 },
                 expectValidation: true,
             },
             {
                 error: TEST_ERRORS.API_RATE_LIMIT,
-                params: { searchText: 'any search term', limit: 10 },
+                params: {
+                    searchText: 'any search term',
+                    limit: 10,
+                },
                 expectValidation: false,
             },
             {
                 error: TEST_ERRORS.INVALID_CURSOR,
-                params: { searchText: 'test', cursor: 'invalid-cursor-format', limit: 10 },
+                params: {
+                    searchText: 'test',
+                    cursor: 'invalid-cursor-format',
+                    limit: 10,
+                },
                 expectValidation: false,
             },
         ])('should propagate $error', async ({ error, params, expectValidation }) => {

package/dist/tools/__tests__/update-sections.test.js

@@ -25,6 +25,7 @@ describe(`${UPDATE_SECTIONS} tool`, () => {
                 isDeleted: false,
                 isCollapsed: false,
                 name: 'Updated Section Name',
+                url: 'https://todoist.com/sections/existing-section-123',
             };
             mockTodoistApi.updateSection.mockResolvedValue(mockApiResponse);
             const result = await updateSections.execute({ sections: [{ id: 'existing-section-123', name: 'Updated Section Name' }] }, mockTodoistApi);

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

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

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

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