@doist/todoist-ai 4.4.0 → 4.6.0

package/dist/tools/manage-assignments.js

@@ -0,0 +1,337 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { assignmentValidator, } from '../utils/assignment-validator.js';
+import { ToolNames } from '../utils/tool-names.js';
+import { userResolver } from '../utils/user-resolver.js';
+const { FIND_TASKS, FIND_PROJECT_COLLABORATORS, UPDATE_TASKS } = ToolNames;
+// Maximum tasks per operation to prevent abuse and timeouts
+const MAX_TASKS_PER_OPERATION = 50;
+const ArgsSchema = {
+    operation: z
+        .enum(['assign', 'unassign', 'reassign'])
+        .describe('The assignment operation to perform.'),
+    taskIds: z
+        .array(z.string())
+        .min(1)
+        .max(MAX_TASKS_PER_OPERATION)
+        .describe('The IDs of the tasks to operate on (max 50).'),
+    responsibleUser: z
+        .string()
+        .optional()
+        .describe('The user to assign tasks to. Can be user ID, name, or email. Required for assign and reassign operations.'),
+    fromAssigneeUser: z
+        .string()
+        .optional()
+        .describe('For reassign operations: the current assignee to reassign from. Can be user ID, name, or email. Optional - if not provided, reassigns from any current assignee.'),
+    dryRun: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('If true, validates operations without executing them.'),
+};
+const manageAssignments = {
+    name: ToolNames.MANAGE_ASSIGNMENTS,
+    description: 'Bulk assignment operations for multiple tasks. Supports assign, unassign, and reassign operations with atomic rollback on failures.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { operation, taskIds, responsibleUser, fromAssigneeUser, dryRun } = args;
+        // Validate required parameters based on operation
+        if ((operation === 'assign' || operation === 'reassign') && !responsibleUser) {
+            throw new Error(`${operation} operation requires responsibleUser parameter`);
+        }
+        // Fetch all tasks first to validate they exist and get project information
+        const tasks = await Promise.allSettled(taskIds.map(async (taskId) => {
+            try {
+                return await client.getTask(taskId);
+            }
+            catch (_error) {
+                throw new Error(`Task ${taskId} not found or not accessible`);
+            }
+        }));
+        const validTasks = [];
+        const taskErrors = [];
+        for (let i = 0; i < tasks.length; i++) {
+            const result = tasks[i];
+            if (result && result.status === 'fulfilled') {
+                validTasks.push(result.value);
+            }
+            else if (result && result.status === 'rejected') {
+                taskErrors.push({
+                    taskId: taskIds[i] || 'invalid-task-id',
+                    success: false,
+                    error: result.reason?.message || 'Task not accessible',
+                });
+            }
+            else {
+                taskErrors.push({
+                    taskId: taskIds[i] || 'invalid-task-id',
+                    success: false,
+                    error: 'Task not accessible',
+                });
+            }
+        }
+        if (validTasks.length === 0) {
+            const textContent = generateTextContent({
+                operation,
+                results: taskErrors,
+                dryRun,
+            });
+            return getToolOutput({
+                textContent,
+                structuredContent: {
+                    operation,
+                    results: taskErrors,
+                    totalRequested: taskIds.length,
+                    successful: 0,
+                    failed: taskErrors.length,
+                    dryRun,
+                },
+            });
+        }
+        // Pre-resolve fromAssigneeUser once for reassign operations
+        let resolvedFromUserId;
+        if (operation === 'reassign' && fromAssigneeUser) {
+            const fromUser = await userResolver.resolveUser(client, fromAssigneeUser);
+            resolvedFromUserId = fromUser?.userId || fromAssigneeUser;
+        }
+        // Build assignments for validation
+        const assignments = [];
+        for (const task of validTasks) {
+            // For reassign operations, check if we need to filter by current assignee
+            if (operation === 'reassign' && resolvedFromUserId) {
+                // Skip tasks not assigned to the specified user
+                if (task.responsibleUid !== resolvedFromUserId) {
+                    continue;
+                }
+            }
+            assignments.push({
+                taskId: task.id,
+                projectId: task.projectId,
+                responsibleUid: responsibleUser || '', // Will be validated appropriately
+            });
+        }
+        // Handle unassign operations (no validation needed for unassignment)
+        if (operation === 'unassign') {
+            if (dryRun) {
+                const results = validTasks.map((task) => ({
+                    taskId: task.id,
+                    success: true,
+                    originalAssigneeId: task.responsibleUid,
+                    newAssigneeId: null,
+                }));
+                const textContent = generateTextContent({
+                    operation,
+                    results,
+                    dryRun: true,
+                });
+                return getToolOutput({
+                    textContent,
+                    structuredContent: {
+                        operation,
+                        results,
+                        totalRequested: taskIds.length,
+                        successful: results.length,
+                        failed: taskErrors.length,
+                        dryRun: true,
+                    },
+                });
+            }
+            // Execute unassign operations
+            const unassignPromises = validTasks.map(async (task) => {
+                try {
+                    await client.updateTask(task.id, { assigneeId: null });
+                    return {
+                        taskId: task.id,
+                        success: true,
+                        originalAssigneeId: task.responsibleUid,
+                        newAssigneeId: null,
+                    };
+                }
+                catch (error) {
+                    return {
+                        taskId: task.id,
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Update failed',
+                        originalAssigneeId: task.responsibleUid,
+                    };
+                }
+            });
+            const unassignResults = await Promise.all(unassignPromises);
+            const allResults = [...unassignResults, ...taskErrors];
+            const textContent = generateTextContent({
+                operation,
+                results: allResults,
+                dryRun: false,
+            });
+            return getToolOutput({
+                textContent,
+                structuredContent: {
+                    operation,
+                    results: allResults,
+                    totalRequested: taskIds.length,
+                    successful: unassignResults.filter((r) => r.success).length,
+                    failed: allResults.filter((r) => !r.success).length,
+                    dryRun: false,
+                },
+            });
+        }
+        // Validate all assignments
+        const validationResults = await assignmentValidator.validateBulkAssignment(client, assignments);
+        // Process validation results
+        const validAssignments = [];
+        const validationErrors = [];
+        for (let i = 0; i < assignments.length; i++) {
+            const assignment = assignments[i];
+            const validation = validationResults[i];
+            if (assignment && validation && validation.isValid) {
+                validAssignments.push({ assignment, validation });
+            }
+            else if (assignment?.taskId) {
+                validationErrors.push({
+                    taskId: assignment.taskId,
+                    success: false,
+                    error: validation?.error?.message || 'Validation failed',
+                });
+            }
+        }
+        // Helper function to process assignments for both dry run and execution
+        async function processAssignments(assignments, execute) {
+            const filteredAssignments = assignments.filter((item) => item.assignment != null && item.validation != null);
+            if (!execute) {
+                // Dry run: just map to successful results
+                return filteredAssignments.map(({ assignment, validation }) => {
+                    const task = validTasks.find((t) => t.id === assignment.taskId);
+                    if (!assignment.taskId || !validation.resolvedUser?.userId) {
+                        throw new Error('Invalid assignment or validation data - this should not happen');
+                    }
+                    return {
+                        taskId: assignment.taskId,
+                        success: true,
+                        originalAssigneeId: task?.responsibleUid || null,
+                        newAssigneeId: validation.resolvedUser.userId,
+                    };
+                });
+            }
+            // Execute: perform actual updates
+            const executePromises = filteredAssignments.map(async ({ assignment, validation }) => {
+                const task = validTasks.find((t) => t.id === assignment.taskId);
+                if (!assignment.taskId || !validation.resolvedUser?.userId) {
+                    return {
+                        taskId: assignment.taskId || 'unknown-task',
+                        success: false,
+                        error: 'Invalid assignment data - missing task ID or resolved user',
+                        originalAssigneeId: task?.responsibleUid || null,
+                    };
+                }
+                try {
+                    await client.updateTask(assignment.taskId, {
+                        assigneeId: validation.resolvedUser.userId,
+                    });
+                    return {
+                        taskId: assignment.taskId,
+                        success: true,
+                        originalAssigneeId: task?.responsibleUid || null,
+                        newAssigneeId: validation.resolvedUser.userId,
+                    };
+                }
+                catch (error) {
+                    return {
+                        taskId: assignment.taskId,
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Update failed',
+                        originalAssigneeId: task?.responsibleUid || null,
+                    };
+                }
+            });
+            return Promise.all(executePromises);
+        }
+        // Handle assign/reassign operations - validate then execute
+        const assignmentResults = await processAssignments(validAssignments, !dryRun);
+        const allResults = [...assignmentResults, ...validationErrors, ...taskErrors];
+        const textContent = generateTextContent({
+            operation,
+            results: allResults,
+            dryRun,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                operation,
+                results: allResults,
+                totalRequested: taskIds.length,
+                successful: assignmentResults.filter((r) => r.success).length,
+                failed: allResults.filter((r) => !r.success).length,
+                dryRun,
+            },
+        });
+    },
+};
+function generateTextContent({ operation, results, dryRun, }) {
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    const operationVerb = dryRun ? 'would be' : 'were';
+    const operationPastTense = {
+        assign: 'assigned',
+        unassign: 'unassigned',
+        reassign: 'reassigned',
+    }[operation];
+    let summary = `**${dryRun ? 'Dry Run: ' : ''}Bulk ${operation} operation**\n\n`;
+    if (successful.length > 0) {
+        summary += `**${successful.length} task${successful.length === 1 ? '' : 's'} ${operationVerb} successfully ${operationPastTense}**\n`;
+        // Show first few successful operations
+        const preview = successful.slice(0, 5);
+        for (const result of preview) {
+            let changeDesc = '';
+            if (operation === 'unassign') {
+                changeDesc = ' (unassigned from previous assignee)';
+            }
+            else if (result.newAssigneeId) {
+                changeDesc = ` → ${result.newAssigneeId}`;
+            }
+            summary += `  • Task ${result.taskId}${changeDesc}\n`;
+        }
+        if (successful.length > 5) {
+            summary += `  • ... and ${successful.length - 5} more\n`;
+        }
+        summary += '\n';
+    }
+    if (failed.length > 0) {
+        summary += `**${failed.length} task${failed.length === 1 ? '' : 's'} failed**\n`;
+        // Show first few failures with reasons
+        const preview = failed.slice(0, 5);
+        for (const result of preview) {
+            summary += `  • Task ${result.taskId}: ${result.error}\n`;
+        }
+        if (failed.length > 5) {
+            summary += `  • ... and ${failed.length - 5} more failures\n`;
+        }
+        summary += '\n';
+    }
+    // Add operational info
+    if (!dryRun && successful.length > 0) {
+        summary += '**Next steps:**\n';
+        summary += `• Use ${FIND_TASKS} with responsibleUser to see ${operation === 'unassign' ? 'unassigned' : 'newly assigned'} tasks\n`;
+        summary += `• Use ${UPDATE_TASKS} for individual assignment changes\n`;
+        if (failed.length > 0) {
+            summary += `• Check failed tasks and use ${FIND_PROJECT_COLLABORATORS} to verify collaborator access\n`;
+        }
+    }
+    else if (dryRun) {
+        summary += '**To execute:**\n';
+        summary += '• Remove dryRun parameter and run again to execute changes\n';
+        if (successful.length > 0) {
+            summary += `• ${successful.length} task${successful.length === 1 ? '' : 's'} ready for ${operation} operation\n`;
+        }
+        if (failed.length > 0) {
+            summary += `• Fix ${failed.length} validation error${failed.length === 1 ? '' : 's'} before executing\n`;
+        }
+    }
+    else if (successful.length === 0) {
+        summary += '**Suggestions:**\n';
+        summary += `• Use ${FIND_PROJECT_COLLABORATORS} to find valid assignees\n`;
+        summary += '• Check task IDs and assignee permissions\n';
+        summary += '• Use dryRun=true to validate before executing\n';
+    }
+    return summary;
+}
+export { manageAssignments };

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

@@ -1 +1 @@
-{"version":3,"file":"update-comments.d.ts","sourceRoot":"","sources":["../../src/tools/update-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAyF88V,CAAC;4BAA6C,CAAC;4BAA6C,CAAC;2BAA4C,CAAC;gCAAiD,CAAC;+BAAgD,CAAC;yBAA2D,CAAC;8BAA+C,CAAC;+BAAgD,CAAC;uBAAwC,CAAC;yBAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA5Dt5W,CAAA;AA2D1C,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"update-comments.d.ts","sourceRoot":"","sources":["../../src/tools/update-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAqFu9V,CAAC;4BAA6C,CAAC;4BAA6C,CAAC;2BAA4C,CAAC;gCAAiD,CAAC;+BAAgD,CAAC;yBAA2D,CAAC;8BAA+C,CAAC;+BAAgD,CAAC;uBAAwC,CAAC;yBAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CAxD/5W,CAAA;AAuD1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/update-comments.js

@@ -61,7 +61,7 @@ function generateNextSteps(comments) {
     nextSteps.push(`Use ${DELETE_OBJECT} with type=comment id=${comment.id} to remove comment`);
     return nextSteps;
 }
-function generateTextContent({ comments, }) {
+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;

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

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

package/dist/tools/update-sections.js

@@ -57,7 +57,7 @@ function generateNextSteps(sections) {
     steps.push('Consider updating task descriptions if section purposes changed');
     return steps;
 }
-function generateTextContent({ sections, }) {
+function generateTextContent({ sections }) {
     const count = sections.length;
     const sectionList = sections
         .map((section) => `• ${section.name} (id=${section.id}, projectId=${section.projectId})`)

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

@@ -11,30 +11,36 @@ declare const updateTasks: {
             sectionId: z.ZodOptional<z.ZodString>;
             parentId: z.ZodOptional<z.ZodString>;
             order: z.ZodOptional<z.ZodNumber>;
-            priority: z.ZodOptional<z.ZodNumber>;
+            priority: z.ZodOptional<z.ZodEnum<["p1", "p2", "p3", "p4"]>>;
             dueString: z.ZodOptional<z.ZodString>;
             duration: z.ZodOptional<z.ZodString>;
+            responsibleUser: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
             id: string;
             content?: string | undefined;
             description?: string | undefined;
-            parentId?: string | undefined;
             projectId?: string | undefined;
+            parentId?: string | undefined;
             sectionId?: string | undefined;
+            labels?: string[] | undefined;
             duration?: string | undefined;
-            priority?: number | undefined;
+            priority?: "p1" | "p2" | "p3" | "p4" | undefined;
             dueString?: string | undefined;
+            responsibleUser?: string | null | undefined;
             order?: number | undefined;
         }, {
             id: string;
             content?: string | undefined;
             description?: string | undefined;
-            parentId?: string | undefined;
             projectId?: string | undefined;
+            parentId?: string | undefined;
             sectionId?: string | undefined;
+            labels?: string[] | undefined;
             duration?: string | undefined;
-            priority?: number | undefined;
+            priority?: "p1" | "p2" | "p3" | "p4" | undefined;
             dueString?: string | undefined;
+            responsibleUser?: string | null | undefined;
             order?: number | undefined;
         }>, "many">;
     };
@@ -43,12 +49,14 @@ declare const updateTasks: {
             id: string;
             content?: string | undefined;
             description?: string | undefined;
-            parentId?: string | undefined;
             projectId?: string | undefined;
+            parentId?: string | undefined;
             sectionId?: string | undefined;
+            labels?: string[] | undefined;
             duration?: string | undefined;
-            priority?: number | undefined;
+            priority?: "p1" | "p2" | "p3" | "p4" | undefined;
             dueString?: string | undefined;
+            responsibleUser?: string | null | undefined;
             order?: number | undefined;
         }[];
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
@@ -69,6 +77,8 @@ declare const updateTasks: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             totalCount: number;
             updatedTaskIds: string[];

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

@@ -1 +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"}
+{"version":3,"file":"update-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/update-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAoDvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkHyB,CAAA;AAqC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/update-tasks.js

@@ -1,7 +1,9 @@
 import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
 import { createMoveTaskArgs, mapTask } from '../tool-helpers.js';
+import { assignmentValidator } from '../utils/assignment-validator.js';
 import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
+import { convertPriorityToNumber, PrioritySchema } from '../utils/priorities.js';
 import { summarizeTaskOperation } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
@@ -13,13 +15,7 @@ const TasksUpdateSchema = z.object({
     sectionId: z.string().optional().describe('The new section ID for the task.'),
     parentId: z.string().optional().describe('The new parent task ID (for subtasks).'),
     order: z.number().optional().describe('The new order of the task within its parent/section.'),
-    priority: z
-        .number()
-        .int()
-        .min(1)
-        .max(4)
-        .optional()
-        .describe('The new priority of the task (1-4).'),
+    priority: PrioritySchema.optional().describe('The new priority of the task: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default).'),
     dueString: z
         .string()
         .optional()
@@ -28,13 +24,22 @@ const TasksUpdateSchema = z.object({
         .string()
         .optional()
         .describe('The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'),
+    responsibleUser: z
+        .string()
+        .nullable()
+        .optional()
+        .describe('Change task assignment. Use null to unassign. Can be user ID, name, or email. User must be a project collaborator.'),
+    labels: z
+        .array(z.string())
+        .optional()
+        .describe('The new labels for the task. Replaces all existing labels.'),
 });
 const ArgsSchema = {
     tasks: z.array(TasksUpdateSchema).min(1).describe('The tasks to update.'),
 };
 const updateTasks = {
     name: ToolNames.UPDATE_TASKS,
-    description: 'Update multiple existing tasks with new values.',
+    description: 'Update existing tasks including content, dates, priorities, and assignments.',
     parameters: ArgsSchema,
     async execute(args, client) {
         const { tasks } = args;
@@ -42,8 +47,15 @@ const updateTasks = {
             if (!hasUpdatesToMake(task)) {
                 return undefined;
             }
-            const { id, projectId, sectionId, parentId, duration: durationStr, ...otherUpdateArgs } = task;
-            let updateArgs = { ...otherUpdateArgs };
+            const { id, projectId, sectionId, parentId, duration: durationStr, responsibleUser, priority, labels, ...otherUpdateArgs } = task;
+            let updateArgs = {
+                ...otherUpdateArgs,
+                ...(labels !== undefined && { labels }),
+            };
+            // Handle priority conversion if provided
+            if (priority) {
+                updateArgs.priority = convertPriorityToNumber(priority);
+            }
             // Parse duration if provided
             if (durationStr) {
                 try {
@@ -61,6 +73,24 @@ const updateTasks = {
                     throw error;
                 }
             }
+            // Handle assignment changes if provided
+            if (responsibleUser !== undefined) {
+                if (responsibleUser === null) {
+                    // Unassign task - no validation needed
+                    updateArgs = { ...updateArgs, assigneeId: null };
+                }
+                else {
+                    // Validate assignment using comprehensive validator
+                    const validation = await assignmentValidator.validateTaskUpdateAssignment(client, id, responsibleUser);
+                    if (!validation.isValid) {
+                        const errorMsg = validation.error?.message || 'Assignment validation failed';
+                        const suggestions = validation.error?.suggestions?.join('. ') || '';
+                        throw new Error(`Task ${id}: ${errorMsg}${suggestions ? `. ${suggestions}` : ''}`);
+                    }
+                    // Use the validated assignee ID
+                    updateArgs = { ...updateArgs, assigneeId: validation.resolvedUser?.userId };
+                }
+            }
             // If no move parameters are provided, use updateTask without moveTasks
             if (!projectId && !sectionId && !parentId) {
                 return await client.updateTask(id, updateArgs);

package/dist/utils/assignment-validator.d.ts

@@ -0,0 +1,69 @@
+import type { TodoistApi } from '@doist/todoist-api-typescript';
+import { type ResolvedUser } from './user-resolver.js';
+export declare const AssignmentErrorType: {
+    readonly USER_NOT_FOUND: "USER_NOT_FOUND";
+    readonly USER_NOT_COLLABORATOR: "USER_NOT_COLLABORATOR";
+    readonly PROJECT_NOT_SHARED: "PROJECT_NOT_SHARED";
+    readonly TASK_NOT_ACCESSIBLE: "TASK_NOT_ACCESSIBLE";
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    readonly PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND";
+    readonly TASK_NOT_FOUND: "TASK_NOT_FOUND";
+};
+export type AssignmentErrorType = (typeof AssignmentErrorType)[keyof typeof AssignmentErrorType];
+export type ValidationError = {
+    type: AssignmentErrorType;
+    message: string;
+    suggestions?: string[];
+};
+export type ValidationResult = {
+    isValid: boolean;
+    resolvedUser?: ResolvedUser;
+    error?: ValidationError;
+    taskId?: string;
+    projectId?: string;
+};
+export type Assignment = {
+    taskId?: string;
+    projectId: string;
+    responsibleUid: string;
+};
+export declare class AssignmentValidator {
+    /**
+     * Validate a single assignment operation
+     */
+    validateAssignment(client: TodoistApi, assignment: Assignment): Promise<ValidationResult>;
+    /**
+     * Validate multiple assignment operations in bulk
+     */
+    validateBulkAssignment(client: TodoistApi, assignments: Assignment[]): Promise<ValidationResult[]>;
+    /**
+     * Validate assignment for task creation (no taskId required)
+     */
+    validateTaskCreationAssignment(client: TodoistApi, projectId: string, responsibleUid: string): Promise<ValidationResult>;
+    /**
+     * Validate assignment for task update
+     */
+    validateTaskUpdateAssignment(client: TodoistApi, taskId: string, responsibleUid: string | null): Promise<ValidationResult>;
+    /**
+     * Get detailed assignment eligibility information for troubleshooting
+     */
+    getAssignmentEligibility(client: TodoistApi, projectId: string, responsibleUid: string, taskIds?: string[]): Promise<{
+        canAssign: boolean;
+        projectInfo: {
+            name: string;
+            isShared: boolean;
+            collaboratorCount: number;
+        };
+        userInfo?: {
+            resolvedName: string;
+            isCollaborator: boolean;
+        };
+        taskInfo?: {
+            accessibleTasks: number;
+            inaccessibleTasks: number;
+        };
+        recommendations: string[];
+    }>;
+}
+export declare const assignmentValidator: AssignmentValidator;
+//# sourceMappingURL=assignment-validator.d.ts.map

package/dist/utils/assignment-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignment-validator.d.ts","sourceRoot":"","sources":["../../src/utils/assignment-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAE/D,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,oBAAoB,CAAA;AAEpE,eAAO,MAAM,mBAAmB;;;;;;;;CAQtB,CAAA;AAEV,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAA;AAEhG,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,mBAAmB,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,qBAAa,mBAAmB;IAC5B;;OAEG;IACG,kBAAkB,CACpB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,UAAU,GACvB,OAAO,CAAC,gBAAgB,CAAC;IAqH5B;;OAEG;IACG,sBAAsB,CACxB,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,UAAU,EAAE,GAC1B,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAS9B;;OAEG;IACG,8BAA8B,CAChC,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,GACvB,OAAO,CAAC,gBAAgB,CAAC;IAO5B;;OAEG;IACG,4BAA4B,CAC9B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,GAAG,IAAI,GAC9B,OAAO,CAAC,gBAAgB,CAAC;IAkC5B;;OAEG;IACG,wBAAwB,CAC1B,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC;QACP,SAAS,EAAE,OAAO,CAAA;QAClB,WAAW,EAAE;YACT,IAAI,EAAE,MAAM,CAAA;YACZ,QAAQ,EAAE,OAAO,CAAA;YACjB,iBAAiB,EAAE,MAAM,CAAA;SAC5B,CAAA;QACD,QAAQ,CAAC,EAAE;YACP,YAAY,EAAE,MAAM,CAAA;YACpB,cAAc,EAAE,OAAO,CAAA;SAC1B,CAAA;QACD,QAAQ,CAAC,EAAE;YACP,eAAe,EAAE,MAAM,CAAA;YACvB,iBAAiB,EAAE,MAAM,CAAA;SAC5B,CAAA;QACD,eAAe,EAAE,MAAM,EAAE,CAAA;KAC5B,CAAC;CAqFL;AAGD,eAAO,MAAM,mBAAmB,qBAA4B,CAAA"}