@doist/todoist-ai 2.2.2 → 4.0.0

package/dist/tools/{overview.js → get-overview.js}

@@ -1,5 +1,8 @@
 import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
 import { isPersonalProject, mapTask } from '../tool-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { ToolNames } from '../utils/tool-names.js';
 const ArgsSchema = {
     projectId: z
         .string()
@@ -101,13 +104,22 @@ function renderTaskTreeMarkdown(tasks, indent = '') {
     }
     return lines;
 }
+function buildProjectStructure(project, sectionsByProject) {
+    return {
+        id: project.id,
+        name: project.name,
+        parentId: isPersonalProject(project) ? (project.parentId ?? null) : null,
+        sections: sectionsByProject[project.id] || [],
+        children: project.children.map((child) => buildProjectStructure(child, sectionsByProject)),
+    };
+}
 async function getAllTasksForProject(client, projectId) {
     let allTasks = [];
     let cursor = undefined;
     do {
         const { results, nextCursor } = await client.getTasks({
             projectId,
-            limit: 50,
+            limit: ApiLimits.TASKS_BATCH_SIZE,
             cursor: cursor ?? undefined,
         });
         allTasks = allTasks.concat(results.map(mapTask));
@@ -119,7 +131,6 @@ async function getProjectSections(client, projectId) {
     const { results } = await client.getSections({ projectId });
     return results;
 }
-// Account overview implementation
 async function generateAccountOverview(client) {
     const { results: projects } = await client.getProjects({});
     const inbox = projects.find((p) => isPersonalProject(p) && p.inboxProject === true);
@@ -127,6 +138,7 @@ async function generateAccountOverview(client) {
     const tree = buildProjectTree(nonInbox);
     const allProjectIds = projects.map((p) => p.id);
     const sectionsByProject = await getSectionsByProject(client, allProjectIds);
+    // Generate markdown text content
     const lines = ['# Personal Projects', ''];
     if (inbox) {
         lines.push(`- Inbox Project: ${inbox.name} (id=${inbox.id})`);
@@ -148,9 +160,24 @@ async function generateAccountOverview(client) {
     if (hasNested) {
         lines.push('_Note: Indentation indicates that a project is a sub-project of the one above it. This allows for organizing projects hierarchically, with parent projects containing related sub-projects._', '');
     }
-    return lines.join('\n');
+    const textContent = lines.join('\n');
+    // Generate structured content
+    const structuredContent = {
+        type: 'account_overview',
+        inbox: inbox
+            ? {
+                id: inbox.id,
+                name: inbox.name,
+                sections: sectionsByProject[inbox.id] || [],
+            }
+            : null,
+        projects: tree.map((project) => buildProjectStructure(project, sectionsByProject)),
+        totalProjects: projects.length,
+        totalSections: allProjectIds.reduce((total, id) => total + (sectionsByProject[id]?.length || 0), 0),
+        hasNestedProjects: hasNested,
+    };
+    return { textContent, structuredContent };
 }
-// Project overview implementation
 async function generateProjectOverview(client, projectId) {
     const project = await client.getProject(projectId);
     const sections = await getProjectSections(client, projectId);
@@ -162,14 +189,12 @@ async function generateProjectOverview(client, projectId) {
     }
     const tasksWithoutSection = [];
     for (const task of allTasks) {
-        if (task.sectionId && tasksBySection[task.sectionId]) {
-            // biome-ignore lint/style/noNonNullAssertion: the "if" above ensures that it is defined
-            tasksBySection[task.sectionId].push(task);
-        }
-        else {
-            tasksWithoutSection.push(task);
-        }
+        const sectionTasks = task.sectionId
+            ? (tasksBySection[task.sectionId] ?? tasksWithoutSection)
+            : tasksWithoutSection;
+        sectionTasks.push(task);
     }
+    // Generate markdown text content
     const lines = [`# ${project.name}`];
     if (tasksWithoutSection.length > 0) {
         lines.push('');
@@ -186,17 +211,39 @@ async function generateProjectOverview(client, projectId) {
         const tree = buildTaskTree(sectionTasks);
         lines.push(...renderTaskTreeMarkdown(tree));
     }
-    return lines.join('\n');
+    const textContent = lines.join('\n');
+    // Generate structured content
+    const structuredContent = {
+        type: 'project_overview',
+        project: {
+            id: project.id,
+            name: project.name,
+        },
+        sections: sections,
+        tasks: allTasks.map((task) => ({
+            ...task,
+            children: [], // Tasks already include hierarchical info via parentId
+        })),
+        stats: {
+            totalTasks: allTasks.length,
+            totalSections: sections.length,
+            tasksWithoutSection: tasksWithoutSection.length,
+        },
+    };
+    return { textContent, structuredContent };
 }
-const overview = {
-    name: 'overview',
+const getOverview = {
+    name: ToolNames.GET_OVERVIEW,
     description: 'Get a Markdown overview. If no projectId is provided, shows all projects with hierarchy and sections (useful for navigation). If projectId is provided, shows detailed overview of that specific project including all tasks grouped by sections.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        if (args.projectId) {
-            return await generateProjectOverview(client, args.projectId);
-        }
-        return await generateAccountOverview(client);
+        const result = args.projectId
+            ? await generateProjectOverview(client, args.projectId)
+            : await generateAccountOverview(client);
+        return getToolOutput({
+            textContent: result.textContent,
+            structuredContent: result.structuredContent,
+        });
     },
 };
-export { overview };
+export { getOverview };

package/dist/tools/update-comments.d.ts

@@ -0,0 +1,50 @@
+import type { Comment } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const updateComments: {
+    name: "update-comments";
+    description: string;
+    parameters: {
+        comments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            id: string;
+        }, {
+            content: string;
+            id: string;
+        }>, "many">;
+    };
+    execute(args: {
+        comments: {
+            content: string;
+            id: string;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            comments: Comment[];
+            totalCount: number;
+            updatedCommentIds: string[];
+            appliedOperations: {
+                updateCount: number;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { updateComments };
+//# sourceMappingURL=update-comments.d.ts.map

package/dist/tools/update-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-comments.d.ts","sourceRoot":"","sources":["../../src/tools/update-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BsB,CAAA;AA2D1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/update-comments.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { formatNextSteps } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_COMMENTS, DELETE_OBJECT } = ToolNames;
+const CommentUpdateSchema = z.object({
+    id: z.string().min(1).describe('The ID of the comment to update.'),
+    content: z.string().min(1).describe('The new content for the comment.'),
+});
+const ArgsSchema = {
+    comments: z.array(CommentUpdateSchema).min(1).describe('The comments to update.'),
+};
+const updateComments = {
+    name: ToolNames.UPDATE_COMMENTS,
+    description: 'Update multiple existing comments with new content.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { comments } = args;
+        const updateCommentPromises = comments.map(async (comment) => {
+            return await client.updateComment(comment.id, { content: comment.content });
+        });
+        const updatedComments = await Promise.all(updateCommentPromises);
+        const textContent = generateTextContent({
+            comments: updatedComments,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                comments: updatedComments,
+                totalCount: updatedComments.length,
+                updatedCommentIds: updatedComments.map((comment) => comment.id),
+                appliedOperations: {
+                    updateCount: updatedComments.length,
+                },
+            },
+        });
+    },
+};
+function generateNextSteps(comments) {
+    const nextSteps = [];
+    // Early return for empty comments
+    if (comments.length === 0) {
+        return nextSteps;
+    }
+    // Multiple comments case
+    if (comments.length > 1) {
+        nextSteps.push(`Use ${FIND_COMMENTS} to view comments by task or project`);
+        nextSteps.push(`Use ${DELETE_OBJECT} with type=comment to remove comments`);
+        return nextSteps;
+    }
+    // Single comment case
+    const comment = comments[0];
+    if (!comment)
+        return nextSteps;
+    if (comment.taskId) {
+        nextSteps.push(`Use ${FIND_COMMENTS} with taskId=${comment.taskId} to see all task comments`);
+    }
+    else if (comment.projectId) {
+        nextSteps.push(`Use ${FIND_COMMENTS} with projectId=${comment.projectId} to see all project comments`);
+    }
+    nextSteps.push(`Use ${DELETE_OBJECT} with type=comment id=${comment.id} to remove comment`);
+    return nextSteps;
+}
+function generateTextContent({ comments, }) {
+    // Group comments by entity type and count
+    const taskComments = comments.filter((c) => c.taskId).length;
+    const projectComments = comments.filter((c) => c.projectId).length;
+    const parts = [];
+    if (taskComments > 0) {
+        const commentsLabel = taskComments > 1 ? 'comments' : 'comment';
+        parts.push(`${taskComments} task ${commentsLabel}`);
+    }
+    if (projectComments > 0) {
+        const commentsLabel = projectComments > 1 ? 'comments' : 'comment';
+        parts.push(`${projectComments} project ${commentsLabel}`);
+    }
+    const summary = parts.length > 0 ? `Updated ${parts.join(' and ')}` : 'No comments updated';
+    const nextSteps = generateNextSteps(comments);
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { updateComments };

package/dist/tools/update-projects.d.ts

@@ -0,0 +1,59 @@
+import type { PersonalProject, WorkspaceProject } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const updateProjects: {
+    name: "update-projects";
+    description: string;
+    parameters: {
+        projects: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            isFavorite: z.ZodOptional<z.ZodBoolean>;
+            viewStyle: z.ZodOptional<z.ZodEnum<["list", "board", "calendar"]>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            name?: string | undefined;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }, {
+            id: string;
+            name?: string | undefined;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        projects: {
+            id: string;
+            name?: string | undefined;
+            isFavorite?: boolean | undefined;
+            viewStyle?: "list" | "board" | "calendar" | undefined;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            projects: (PersonalProject | WorkspaceProject)[];
+            totalCount: number;
+            updatedProjectIds: string[];
+            appliedOperations: {
+                updateCount: number;
+                skippedCount: number;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { updateProjects };
+//# sourceMappingURL=update-projects.d.ts.map

package/dist/tools/update-projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-projects.d.ts","sourceRoot":"","sources":["../../src/tools/update-projects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AACtF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCsB,CAAA;AAuD1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/update-projects.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { formatNextSteps } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_PROJECTS, FIND_TASKS, GET_OVERVIEW } = ToolNames;
+const ProjectUpdateSchema = z.object({
+    id: z.string().min(1).describe('The ID of the project to update.'),
+    name: z.string().min(1).optional().describe('The new name of the project.'),
+    isFavorite: z.boolean().optional().describe('Whether the project is a favorite.'),
+    viewStyle: z.enum(['list', 'board', 'calendar']).optional().describe('The project view style.'),
+});
+const ArgsSchema = {
+    projects: z.array(ProjectUpdateSchema).min(1).describe('The projects to update.'),
+};
+const updateProjects = {
+    name: ToolNames.UPDATE_PROJECTS,
+    description: 'Update multiple existing projects with new values.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { projects } = args;
+        const updateProjectsPromises = projects.map(async (project) => {
+            if (!hasUpdatesToMake(project)) {
+                return undefined;
+            }
+            const { id, ...updateArgs } = project;
+            return await client.updateProject(id, updateArgs);
+        });
+        const updatedProjects = (await Promise.all(updateProjectsPromises)).filter((project) => project !== undefined);
+        const textContent = generateTextContent({
+            projects: updatedProjects,
+            args,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                projects: updatedProjects,
+                totalCount: updatedProjects.length,
+                updatedProjectIds: updatedProjects.map((project) => project.id),
+                appliedOperations: {
+                    updateCount: updatedProjects.length,
+                    skippedCount: projects.length - updatedProjects.length,
+                },
+            },
+        });
+    },
+};
+function generateTextContent({ projects, args, }) {
+    const totalRequested = args.projects.length;
+    const actuallyUpdated = projects.length;
+    const skipped = totalRequested - actuallyUpdated;
+    const count = projects.length;
+    const projectList = projects.map((project) => `• ${project.name} (id=${project.id})`).join('\n');
+    let summary = `Updated ${count} project${count === 1 ? '' : 's'}`;
+    if (skipped > 0) {
+        summary += ` (${skipped} skipped - no changes)`;
+    }
+    if (count > 0) {
+        summary += `:\n${projectList}`;
+    }
+    // Context-aware next steps for updated projects
+    const nextSteps = [];
+    if (projects.length > 0) {
+        if (count === 1) {
+            const project = projects[0];
+            if (project) {
+                nextSteps.push(`Use ${GET_OVERVIEW} with projectId=${project.id} to see project structure`);
+                nextSteps.push(`Use ${FIND_TASKS} with projectId=${project.id} to review existing tasks`);
+            }
+        }
+        else {
+            nextSteps.push(`Use ${FIND_PROJECTS} to see all projects with updated names`);
+            nextSteps.push(`Use ${GET_OVERVIEW} to see updated project hierarchy`);
+        }
+    }
+    else {
+        nextSteps.push(`Use ${FIND_PROJECTS} to see current projects`);
+    }
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+function hasUpdatesToMake({ id, ...otherUpdateArgs }) {
+    return Object.keys(otherUpdateArgs).length > 0;
+}
+export { updateProjects };

package/dist/tools/update-sections.d.ts

@@ -0,0 +1,47 @@
+import type { Section } from '@doist/todoist-api-typescript';
+import { z } from 'zod';
+declare const updateSections: {
+    name: "update-sections";
+    description: string;
+    parameters: {
+        sections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            id: string;
+        }, {
+            name: string;
+            id: string;
+        }>, "many">;
+    };
+    execute({ sections }: {
+        sections: {
+            name: string;
+            id: string;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            sections: Section[];
+            totalCount: number;
+            updatedSectionIds: string[];
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { updateSections };
+//# sourceMappingURL=update-sections.d.ts.map

package/dist/tools/update-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-sections.d.ts","sourceRoot":"","sources":["../../src/tools/update-sections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBsB,CAAA;AAsD1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/update-sections.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { formatNextSteps } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+const { FIND_TASKS, GET_OVERVIEW, FIND_SECTIONS } = ToolNames;
+const SectionUpdateSchema = z.object({
+    id: z.string().min(1).describe('The ID of the section to update.'),
+    name: z.string().min(1).describe('The new name of the section.'),
+});
+const ArgsSchema = {
+    sections: z.array(SectionUpdateSchema).min(1).describe('The sections to update.'),
+};
+const updateSections = {
+    name: ToolNames.UPDATE_SECTIONS,
+    description: 'Update multiple existing sections with new values.',
+    parameters: ArgsSchema,
+    async execute({ sections }, client) {
+        const updatedSections = await Promise.all(sections.map((section) => client.updateSection(section.id, { name: section.name })));
+        const textContent = generateTextContent({
+            sections: updatedSections,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                sections: updatedSections,
+                totalCount: updatedSections.length,
+                updatedSectionIds: updatedSections.map((section) => section.id),
+            },
+        });
+    },
+};
+function generateNextSteps(sections) {
+    // Handle empty sections first (early return)
+    if (sections.length === 0) {
+        return [`Use ${FIND_SECTIONS} to see current sections`];
+    }
+    // Handle single section case
+    if (sections.length === 1) {
+        const section = sections[0];
+        if (!section)
+            return [];
+        return [
+            `Use ${FIND_TASKS} with sectionId=${section.id} to see existing tasks`,
+            `Use ${GET_OVERVIEW} with projectId=${section.projectId} to see project structure`,
+            'Consider updating task descriptions if section purpose changed',
+        ];
+    }
+    // Handle multiple sections case
+    const projectIds = [...new Set(sections.map((s) => s.projectId))];
+    const steps = [`Use ${FIND_SECTIONS} to see all sections with updated names`];
+    if (projectIds.length === 1) {
+        steps.push(`Use ${GET_OVERVIEW} with projectId=${projectIds[0]} to see updated project structure`);
+    }
+    else {
+        steps.push(`Use ${GET_OVERVIEW} to see updated project structures`);
+    }
+    steps.push('Consider updating task descriptions if section purposes changed');
+    return steps;
+}
+function generateTextContent({ sections, }) {
+    const count = sections.length;
+    const sectionList = sections
+        .map((section) => `• ${section.name} (id=${section.id}, projectId=${section.projectId})`)
+        .join('\n');
+    const summary = `Updated ${count} section${count === 1 ? '' : 's'}:\n${sectionList}`;
+    const nextSteps = generateNextSteps(sections);
+    const next = formatNextSteps(nextSteps);
+    return `${summary}\n${next}`;
+}
+export { updateSections };

package/dist/tools/update-tasks.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+declare const updateTasks: {
+    name: "update-tasks";
+    description: string;
+    parameters: {
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            sectionId: z.ZodOptional<z.ZodString>;
+            parentId: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodNumber>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            dueString: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            content?: string | undefined;
+            description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+            duration?: string | undefined;
+            order?: number | undefined;
+        }, {
+            id: string;
+            content?: string | undefined;
+            description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+            duration?: string | undefined;
+            order?: number | undefined;
+        }>, "many">;
+    };
+    execute(args: {
+        tasks: {
+            id: string;
+            content?: string | undefined;
+            description?: string | undefined;
+            parentId?: string | undefined;
+            projectId?: string | undefined;
+            sectionId?: string | undefined;
+            priority?: number | undefined;
+            dueString?: string | undefined;
+            duration?: string | undefined;
+            order?: number | undefined;
+        }[];
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                priority: number;
+                projectId: string;
+                sectionId: string | null;
+                parentId: string | null;
+                labels: string[];
+                duration: string | null;
+            }[];
+            totalCount: number;
+            updatedTaskIds: string[];
+            appliedOperations: {
+                updateCount: number;
+                skippedCount: number;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    }>;
+};
+export { updateTasks };
+//# sourceMappingURL=update-tasks.d.ts.map

package/dist/tools/update-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/update-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2CvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EyB,CAAA;AAqC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}