@doist/todoist-ai 4.16.0 → 4.17.0

package/dist/utils/assignment-validator.js

@@ -1,253 +0,0 @@
-import { userResolver } from './user-resolver.js';
-export const AssignmentErrorType = {
-    USER_NOT_FOUND: 'USER_NOT_FOUND',
-    USER_NOT_COLLABORATOR: 'USER_NOT_COLLABORATOR',
-    PROJECT_NOT_SHARED: 'PROJECT_NOT_SHARED',
-    TASK_NOT_ACCESSIBLE: 'TASK_NOT_ACCESSIBLE',
-    PERMISSION_DENIED: 'PERMISSION_DENIED',
-    PROJECT_NOT_FOUND: 'PROJECT_NOT_FOUND',
-    TASK_NOT_FOUND: 'TASK_NOT_FOUND',
-};
-export class AssignmentValidator {
-    /**
-     * Validate a single assignment operation
-     */
-    async validateAssignment(client, assignment) {
-        const { taskId, projectId, responsibleUid } = assignment;
-        // First, resolve the user
-        const resolvedUser = await userResolver.resolveUser(client, responsibleUid);
-        if (!resolvedUser) {
-            return {
-                isValid: false,
-                taskId,
-                projectId,
-                error: {
-                    type: AssignmentErrorType.USER_NOT_FOUND,
-                    message: `User "${responsibleUid}" not found`,
-                    suggestions: [
-                        'Check the spelling of the user name or email',
-                        'Ensure the user is a collaborator on at least one shared project',
-                        "Try using the user's full email address",
-                    ],
-                },
-            };
-        }
-        // Validate the project exists and is accessible
-        try {
-            const targetProject = await client.getProject(projectId);
-            // Check if project is shared (required for assignments)
-            if (!targetProject.isShared) {
-                return {
-                    isValid: false,
-                    taskId,
-                    projectId,
-                    resolvedUser,
-                    error: {
-                        type: AssignmentErrorType.PROJECT_NOT_SHARED,
-                        message: `Project "${targetProject.name}" is not shared`,
-                        suggestions: [
-                            'Share the project with collaborators before assigning tasks',
-                            'Only shared projects support task assignments',
-                        ],
-                    },
-                };
-            }
-            // Validate the user is a collaborator on this specific project
-            const isCollaborator = await userResolver.validateProjectCollaborator(client, projectId, resolvedUser.userId);
-            if (!isCollaborator) {
-                return {
-                    isValid: false,
-                    taskId,
-                    projectId,
-                    resolvedUser,
-                    error: {
-                        type: AssignmentErrorType.USER_NOT_COLLABORATOR,
-                        message: `User "${resolvedUser.displayName}" is not a collaborator on project "${targetProject.name}"`,
-                        suggestions: [
-                            'Invite the user to collaborate on this project first',
-                            'Check if the user has been removed from the project',
-                            'Verify you have permission to see project collaborators',
-                        ],
-                    },
-                };
-            }
-            // If taskId is provided, validate the task exists and is accessible
-            if (taskId) {
-                try {
-                    await client.getTask(taskId);
-                }
-                catch (_error) {
-                    return {
-                        isValid: false,
-                        taskId,
-                        projectId,
-                        resolvedUser,
-                        error: {
-                            type: AssignmentErrorType.TASK_NOT_FOUND,
-                            message: `Task "${taskId}" not found or not accessible`,
-                            suggestions: [
-                                'Verify the task ID is correct',
-                                'Check if the task has been deleted',
-                                'Ensure you have access to the task',
-                            ],
-                        },
-                    };
-                }
-            }
-            return {
-                isValid: true,
-                taskId,
-                projectId,
-                resolvedUser,
-            };
-        }
-        catch (_error) {
-            return {
-                isValid: false,
-                taskId,
-                projectId,
-                resolvedUser,
-                error: {
-                    type: AssignmentErrorType.PERMISSION_DENIED,
-                    message: 'Permission denied or API error occurred',
-                    suggestions: [
-                        'Check your API permissions',
-                        'Verify you have access to the project',
-                        'Try again later if this is a temporary API issue',
-                    ],
-                },
-            };
-        }
-    }
-    /**
-     * Validate multiple assignment operations in bulk
-     */
-    async validateBulkAssignment(client, assignments) {
-        // Process assignments in parallel for better performance
-        const validationPromises = assignments.map((assignment) => this.validateAssignment(client, assignment));
-        return Promise.all(validationPromises);
-    }
-    /**
-     * Validate assignment for task creation (no taskId required)
-     */
-    async validateTaskCreationAssignment(client, projectId, responsibleUid) {
-        return this.validateAssignment(client, {
-            projectId,
-            responsibleUid,
-        });
-    }
-    /**
-     * Validate assignment for task update
-     */
-    async validateTaskUpdateAssignment(client, taskId, responsibleUid) {
-        // If responsibleUid is null, it's an unassignment - always valid
-        if (responsibleUid === null) {
-            return {
-                isValid: true,
-                taskId,
-            };
-        }
-        // Get the task to find its project
-        try {
-            const task = await client.getTask(taskId);
-            return this.validateAssignment(client, {
-                taskId,
-                projectId: task.projectId,
-                responsibleUid,
-            });
-        }
-        catch (_error) {
-            return {
-                isValid: false,
-                taskId,
-                error: {
-                    type: AssignmentErrorType.TASK_NOT_FOUND,
-                    message: `Task "${taskId}" not found or not accessible`,
-                    suggestions: [
-                        'Verify the task ID is correct',
-                        'Check if the task has been deleted',
-                        'Ensure you have access to the task',
-                    ],
-                },
-            };
-        }
-    }
-    /**
-     * Get detailed assignment eligibility information for troubleshooting
-     */
-    async getAssignmentEligibility(client, projectId, responsibleUid, taskIds) {
-        const recommendations = [];
-        let canAssign = false;
-        // Get project information
-        let project;
-        try {
-            project = await client.getProject(projectId);
-        }
-        catch {
-            return {
-                canAssign: false,
-                projectInfo: {
-                    name: 'Unknown',
-                    isShared: false,
-                    collaboratorCount: 0,
-                },
-                recommendations: ['Project not found or not accessible'],
-            };
-        }
-        const collaborators = await userResolver.getProjectCollaborators(client, projectId);
-        const projectInfo = {
-            name: project.name,
-            isShared: project.isShared,
-            collaboratorCount: collaborators.length,
-        };
-        if (!project.isShared) {
-            recommendations.push('Share this project to enable task assignments');
-            return { canAssign: false, projectInfo, recommendations };
-        }
-        // Resolve user
-        const resolvedUser = await userResolver.resolveUser(client, responsibleUid);
-        if (!resolvedUser) {
-            recommendations.push('User not found - check spelling or invite to a shared project');
-            return { canAssign: false, projectInfo, recommendations };
-        }
-        const isCollaborator = collaborators.some((c) => c.id === resolvedUser.userId);
-        const userInfo = {
-            resolvedName: resolvedUser.displayName,
-            isCollaborator,
-        };
-        if (!isCollaborator) {
-            recommendations.push(`Invite ${resolvedUser.displayName} to collaborate on project "${project.name}"`);
-            return { canAssign: false, projectInfo, userInfo, recommendations };
-        }
-        // Check task accessibility if provided
-        let taskInfo;
-        if (taskIds && taskIds.length > 0) {
-            let accessible = 0;
-            let inaccessible = 0;
-            for (const taskId of taskIds) {
-                try {
-                    await client.getTask(taskId);
-                    accessible++;
-                }
-                catch {
-                    inaccessible++;
-                }
-            }
-            taskInfo = { accessibleTasks: accessible, inaccessibleTasks: inaccessible };
-            if (inaccessible > 0) {
-                recommendations.push(`${inaccessible} task(s) are not accessible`);
-            }
-        }
-        canAssign = true;
-        recommendations.push(`Ready to assign tasks to ${resolvedUser.displayName}`);
-        return {
-            canAssign,
-            projectInfo,
-            userInfo,
-            taskInfo,
-            recommendations,
-        };
-    }
-}
-// Export singleton instance
-export const assignmentValidator = new AssignmentValidator();

package/dist/utils/constants.js

@@ -1,45 +0,0 @@
-/**
- * Application-wide constants
- *
- * This module centralizes magic numbers and configuration values
- * to improve maintainability and provide a single source of truth.
- */
-// API Pagination Limits
-export const ApiLimits = {
-    /** Default limit for task listings */
-    TASKS_DEFAULT: 10,
-    /** Maximum limit for task search and list operations */
-    TASKS_MAX: 100,
-    /** Default limit for completed tasks */
-    COMPLETED_TASKS_DEFAULT: 50,
-    /** Maximum limit for completed tasks */
-    COMPLETED_TASKS_MAX: 200,
-    /** Default limit for project listings */
-    PROJECTS_DEFAULT: 50,
-    /** Maximum limit for project listings */
-    PROJECTS_MAX: 100,
-    /** Batch size for fetching all tasks in a project */
-    TASKS_BATCH_SIZE: 50,
-    /** Default limit for comment listings */
-    COMMENTS_DEFAULT: 10,
-    /** Maximum limit for comment search and list operations */
-    COMMENTS_MAX: 10,
-    /** Default limit for activity log listings */
-    ACTIVITY_DEFAULT: 20,
-    /** Maximum limit for activity log search and list operations */
-    ACTIVITY_MAX: 100,
-};
-// UI Display Limits
-export const DisplayLimits = {
-    /** Maximum number of failures to show in detailed error messages */
-    MAX_FAILURES_SHOWN: 3,
-    /** Threshold for suggesting batch operations */
-    BATCH_OPERATION_THRESHOLD: 10,
-};
-// Response Builder Configuration
-export const ResponseConfig = {
-    /** Maximum characters per line in text responses */
-    MAX_LINE_LENGTH: 100,
-    /** Indentation for nested items */
-    INDENT_SIZE: 2,
-};

package/dist/utils/duration-parser.js

@@ -1,96 +0,0 @@
-/**
- * Duration parser utility for converting human-readable duration strings
- * to minutes using a restricted, language-neutral syntax.
- *
- * Supported formats:
- * - "2h" (hours only)
- * - "90m" (minutes only)
- * - "2h30m" (hours + minutes)
- * - "1.5h" (decimal hours)
- * - Supports optional spaces: "2h 30m"
- */
-export class DurationParseError extends Error {
-    constructor(input, reason) {
-        super(`Invalid duration format "${input}": ${reason}`);
-        this.name = 'DurationParseError';
-    }
-}
-/**
- * Parses duration string in restricted syntax to minutes.
- * Max duration: 1440 minutes (24 hours)
- *
- * @param durationStr - Duration string like "2h30m", "45m", "1.5h"
- * @returns Parsed duration in minutes
- * @throws DurationParseError for invalid formats
- */
-export function parseDuration(durationStr) {
-    if (!durationStr || typeof durationStr !== 'string') {
-        throw new DurationParseError(durationStr, 'Duration must be a non-empty string');
-    }
-    // Remove all spaces and convert to lowercase
-    const normalized = durationStr.trim().toLowerCase().replace(/\s+/g, '');
-    // Check for empty string after trimming
-    if (!normalized) {
-        throw new DurationParseError(durationStr, 'Duration must be a non-empty string');
-    }
-    // Validate format with strict ordering: hours must come before minutes
-    // This regex ensures: optional hours followed by optional minutes, no duplicates
-    const match = normalized.match(/^(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?$/);
-    if (!match || (!match[1] && !match[2])) {
-        throw new DurationParseError(durationStr, 'Use format like "2h", "30m", "2h30m", or "1.5h"');
-    }
-    let totalMinutes = 0;
-    const [, hoursStr, minutesStr] = match;
-    // Parse hours if present
-    if (hoursStr) {
-        const hours = Number.parseFloat(hoursStr);
-        if (Number.isNaN(hours) || hours < 0) {
-            throw new DurationParseError(durationStr, 'Hours must be a positive number');
-        }
-        totalMinutes += hours * 60;
-    }
-    // Parse minutes if present
-    if (minutesStr) {
-        const minutes = Number.parseFloat(minutesStr);
-        if (Number.isNaN(minutes) || minutes < 0) {
-            throw new DurationParseError(durationStr, 'Minutes must be a positive number');
-        }
-        // Don't allow decimal minutes
-        if (minutes % 1 !== 0) {
-            throw new DurationParseError(durationStr, 'Minutes must be a whole number (use decimal hours instead)');
-        }
-        totalMinutes += minutes;
-    }
-    // The regex already ensures at least one unit is present
-    // Round to nearest minute (handles decimal hours)
-    totalMinutes = Math.round(totalMinutes);
-    // Validate minimum duration
-    if (totalMinutes === 0) {
-        throw new DurationParseError(durationStr, 'Duration must be greater than 0 minutes');
-    }
-    // Validate maximum duration (24 hours = 1440 minutes)
-    if (totalMinutes > 1440) {
-        throw new DurationParseError(durationStr, 'Duration cannot exceed 24 hours (1440 minutes)');
-    }
-    return { minutes: totalMinutes };
-}
-/**
- * Formats minutes back to a human-readable duration string.
- * Used when returning task data to LLMs.
- *
- * @param minutes - Duration in minutes
- * @returns Formatted duration string like "2h30m" or "45m"
- */
-export function formatDuration(minutes) {
-    if (minutes <= 0)
-        return '0m';
-    const hours = Math.floor(minutes / 60);
-    const remainingMinutes = minutes % 60;
-    if (hours === 0) {
-        return `${remainingMinutes}m`;
-    }
-    if (remainingMinutes === 0) {
-        return `${hours}h`;
-    }
-    return `${hours}h${remainingMinutes}m`;
-}

package/dist/utils/duration-parser.test.d.ts

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

package/dist/utils/duration-parser.test.d.ts.map

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

package/dist/utils/duration-parser.test.js

@@ -1,147 +0,0 @@
-import { DurationParseError, formatDuration, parseDuration } from './duration-parser.js';
-describe('parseDuration', () => {
-    describe('valid formats', () => {
-        it('should parse hours only', () => {
-            expect(parseDuration('2h')).toEqual({ minutes: 120 });
-            expect(parseDuration('1h')).toEqual({ minutes: 60 });
-            expect(parseDuration('24h')).toEqual({ minutes: 1440 });
-        });
-        it('should parse minutes only', () => {
-            expect(parseDuration('90m')).toEqual({ minutes: 90 });
-            expect(parseDuration('45m')).toEqual({ minutes: 45 });
-            expect(parseDuration('1m')).toEqual({ minutes: 1 });
-            expect(parseDuration('1440m')).toEqual({ minutes: 1440 });
-        });
-        it('should parse hours and minutes combined', () => {
-            expect(parseDuration('2h30m')).toEqual({ minutes: 150 });
-            expect(parseDuration('1h45m')).toEqual({ minutes: 105 });
-            expect(parseDuration('0h30m')).toEqual({ minutes: 30 });
-            expect(parseDuration('23h59m')).toEqual({ minutes: 1439 });
-        });
-        it('should parse decimal hours', () => {
-            expect(parseDuration('1.5h')).toEqual({ minutes: 90 });
-            expect(parseDuration('2.25h')).toEqual({ minutes: 135 });
-            expect(parseDuration('0.5h')).toEqual({ minutes: 30 });
-            expect(parseDuration('0.75h')).toEqual({ minutes: 45 });
-        });
-        it('should handle spaces in input', () => {
-            expect(parseDuration('2h 30m')).toEqual({ minutes: 150 });
-            expect(parseDuration(' 1h45m ')).toEqual({ minutes: 105 });
-            expect(parseDuration('  2h  ')).toEqual({ minutes: 120 });
-            expect(parseDuration(' 90m ')).toEqual({ minutes: 90 });
-        });
-        it('should handle case insensitive input', () => {
-            expect(parseDuration('2H')).toEqual({ minutes: 120 });
-            expect(parseDuration('90M')).toEqual({ minutes: 90 });
-            expect(parseDuration('2H30M')).toEqual({ minutes: 150 });
-            expect(parseDuration('1.5H')).toEqual({ minutes: 90 });
-        });
-        it('should round decimal minutes from decimal hours', () => {
-            expect(parseDuration('1.33h')).toEqual({ minutes: 80 }); // 1.33 * 60 = 79.8 -> 80
-            expect(parseDuration('1.67h')).toEqual({ minutes: 100 }); // 1.67 * 60 = 100.2 -> 100
-        });
-    });
-    describe('invalid formats', () => {
-        it('should throw error for empty or null input', () => {
-            expect(() => parseDuration('')).toThrow(DurationParseError);
-            expect(() => parseDuration('   ')).toThrow('Duration must be a non-empty string');
-            // biome-ignore lint/suspicious/noExplicitAny: Testing error cases with invalid types
-            expect(() => parseDuration(null)).toThrow('Duration must be a non-empty string');
-            // biome-ignore lint/suspicious/noExplicitAny: Testing error cases with invalid types
-            expect(() => parseDuration(undefined)).toThrow('Duration must be a non-empty string');
-        });
-        it('should throw error for invalid format', () => {
-            expect(() => parseDuration('2')).toThrow('Use format like "2h", "30m", "2h30m", or "1.5h"');
-            expect(() => parseDuration('2hours')).toThrow('Use format like');
-            expect(() => parseDuration('2h30')).toThrow('Use format like');
-            expect(() => parseDuration('h30m')).toThrow('Use format like');
-            expect(() => parseDuration('2x30m')).toThrow('Use format like');
-            expect(() => parseDuration('2h30s')).toThrow('Use format like');
-        });
-        it('should throw error for decimal minutes', () => {
-            expect(() => parseDuration('90.5m')).toThrow('Minutes must be a whole number');
-            expect(() => parseDuration('1h30.5m')).toThrow('Minutes must be a whole number');
-        });
-        it('should throw error for negative values', () => {
-            expect(() => parseDuration('-2h')).toThrow('Use format like');
-            expect(() => parseDuration('-30m')).toThrow('Use format like');
-            expect(() => parseDuration('2h-30m')).toThrow('Use format like');
-        });
-        it('should throw error for zero duration', () => {
-            expect(() => parseDuration('0h')).toThrow('Duration must be greater than 0 minutes');
-            expect(() => parseDuration('0m')).toThrow('Duration must be greater than 0 minutes');
-            expect(() => parseDuration('0h0m')).toThrow('Duration must be greater than 0 minutes');
-        });
-        it('should throw error for duration exceeding 24 hours', () => {
-            expect(() => parseDuration('25h')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-            expect(() => parseDuration('1441m')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-            expect(() => parseDuration('24h1m')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-            expect(() => parseDuration('24.1h')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-        });
-        it('should throw error for malformed numbers', () => {
-            expect(() => parseDuration('2.h')).toThrow('Use format like');
-            expect(() => parseDuration('2h.m')).toThrow('Use format like');
-            expect(() => parseDuration('2..5h')).toThrow('Use format like');
-        });
-        it('should throw error for duplicate units', () => {
-            expect(() => parseDuration('2h3h')).toThrow('Use format like');
-            expect(() => parseDuration('30m45m')).toThrow('Use format like');
-        });
-        it('should throw error for wrong order (minutes before hours)', () => {
-            expect(() => parseDuration('30m2h')).toThrow('Use format like');
-            expect(() => parseDuration('45m1h')).toThrow('Use format like');
-        });
-        it('should throw error for invalid mixed formats with correct order', () => {
-            expect(() => parseDuration('2h30m15h')).toThrow('Use format like');
-            expect(() => parseDuration('1h2h30m')).toThrow('Use format like');
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle maximum allowed duration', () => {
-            expect(parseDuration('24h')).toEqual({ minutes: 1440 });
-            expect(parseDuration('1440m')).toEqual({ minutes: 1440 });
-            expect(parseDuration('23h60m')).toEqual({ minutes: 1440 });
-        });
-        it('should handle minimum allowed duration', () => {
-            expect(parseDuration('1m')).toEqual({ minutes: 1 });
-            expect(parseDuration('0.017h')).toEqual({ minutes: 1 }); // 0.017 * 60 = 1.02 -> 1
-        });
-    });
-});
-describe('formatDuration', () => {
-    it('should format minutes only', () => {
-        expect(formatDuration(45)).toBe('45m');
-        expect(formatDuration(1)).toBe('1m');
-        expect(formatDuration(59)).toBe('59m');
-    });
-    it('should format hours only', () => {
-        expect(formatDuration(60)).toBe('1h');
-        expect(formatDuration(120)).toBe('2h');
-        expect(formatDuration(1440)).toBe('24h');
-    });
-    it('should format hours and minutes combined', () => {
-        expect(formatDuration(90)).toBe('1h30m');
-        expect(formatDuration(150)).toBe('2h30m');
-        expect(formatDuration(105)).toBe('1h45m');
-        expect(formatDuration(1439)).toBe('23h59m');
-    });
-    it('should handle edge cases', () => {
-        expect(formatDuration(0)).toBe('0m');
-        expect(formatDuration(-5)).toBe('0m');
-    });
-});
-describe('round trip parsing and formatting', () => {
-    const testCases = [
-        { input: '2h', expectedMinutes: 120, expectedFormat: '2h' },
-        { input: '45m', expectedMinutes: 45, expectedFormat: '45m' },
-        { input: '2h30m', expectedMinutes: 150, expectedFormat: '2h30m' },
-        { input: '1.5h', expectedMinutes: 90, expectedFormat: '1h30m' },
-    ];
-    for (const { input, expectedMinutes, expectedFormat } of testCases) {
-        it(`should parse "${input}" and format back consistently`, () => {
-            const parsed = parseDuration(input);
-            expect(parsed.minutes).toBe(expectedMinutes);
-            expect(formatDuration(parsed.minutes)).toBe(expectedFormat);
-        });
-    }
-});

package/dist/utils/labels.js

@@ -1,18 +0,0 @@
-import { z } from 'zod';
-const LABELS_OPERATORS = ['and', 'or'];
-export const LabelsSchema = {
-    labels: z.string().array().optional().describe('The labels to filter the tasks by'),
-    labelsOperator: z
-        .enum(LABELS_OPERATORS)
-        .optional()
-        .describe('The operator to use when filtering by labels. This will dictate whether a task has all labels, or some of them. Default is "or".'),
-};
-export function generateLabelsFilter(labels = [], labelsOperator = 'or') {
-    if (labels.length === 0)
-        return '';
-    const operator = labelsOperator === 'and' ? ' & ' : ' | ';
-    // Add @ prefix to labels for Todoist API query
-    const prefixedLabels = labels.map((label) => (label.startsWith('@') ? label : `@${label}`));
-    const labelStr = prefixedLabels.join(` ${operator} `);
-    return `(${labelStr})`;
-}

package/dist/utils/priorities.js

@@ -1,20 +0,0 @@
-import { z } from 'zod';
-const PRIORITY_VALUES = ['p1', 'p2', 'p3', 'p4'];
-export const PrioritySchema = z.enum(PRIORITY_VALUES, {
-    description: 'Task priority: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default)',
-});
-export function convertPriorityToNumber(priority) {
-    // Todoist API uses inverse mapping: p1=4 (highest), p2=3, p3=2, p4=1 (lowest)
-    const priorityMap = { p1: 4, p2: 3, p3: 2, p4: 1 };
-    return priorityMap[priority];
-}
-export function convertNumberToPriority(priority) {
-    // Convert Todoist API numbers back to our enum
-    const numberMap = { 4: 'p1', 3: 'p2', 2: 'p3', 1: 'p4' };
-    return numberMap[priority];
-}
-export function formatPriorityForDisplay(priority) {
-    // Convert Todoist API numbers to display format (P1, P2, P3, P4)
-    const displayMap = { 4: 'P1', 3: 'P2', 2: 'P3', 1: 'P4' };
-    return displayMap[priority] || '';
-}