@taazkareem/clickup-mcp-server 0.8.4 → 0.9.0

package/build/tools/task/time-tracking.js

@@ -15,6 +15,7 @@ import { timeTrackingService } from "../../services/shared.js";
 import { getTaskId } from "./utilities.js";
 import { Logger } from "../../logger.js";
 import { parseDueDate } from "../../utils/date-utils.js";
+import { sponsorService } from "../../utils/sponsor-service.js";
 // Logger instance
 const logger = new Logger('TimeTrackingTools');
 /**
@@ -196,12 +197,7 @@ export async function handleGetTaskTimeEntries(params) {
         // Resolve task ID
         const taskId = await getTaskId(params.taskId, params.taskName, params.listName);
         if (!taskId) {
-            return {
-                success: false,
-                error: {
-                    message: "Task not found. Please provide a valid taskId or taskName + listName combination."
-                }
-            };
+            return sponsorService.createErrorResponse("Task not found. Please provide a valid taskId or taskName + listName combination.");
         }
         // Parse date filters
         let startDate;
@@ -215,46 +211,37 @@ export async function handleGetTaskTimeEntries(params) {
         // Get time entries
         const result = await timeTrackingService.getTimeEntries(taskId, startDate, endDate);
         if (!result.success) {
-            return {
-                success: false,
-                error: {
-                    message: result.error?.message || "Failed to get time entries"
-                }
-            };
+            return sponsorService.createErrorResponse(result.error?.message || "Failed to get time entries");
         }
         const timeEntries = result.data || [];
         // Format the response
-        return {
+        return sponsorService.createResponse({
             success: true,
+            count: timeEntries.length,
             time_entries: timeEntries.map(entry => ({
                 id: entry.id,
-                description: entry.description,
+                description: entry.description || "",
                 start: entry.start,
                 end: entry.end,
-                duration: formatDuration(entry.duration),
-                duration_ms: entry.duration,
-                billable: entry.billable,
-                tags: entry.tags,
-                user: {
+                duration: formatDuration(entry.duration || 0),
+                duration_ms: entry.duration || 0,
+                billable: entry.billable || false,
+                tags: entry.tags || [],
+                user: entry.user ? {
                     id: entry.user.id,
                     username: entry.user.username
-                },
-                task: {
+                } : null,
+                task: entry.task ? {
                     id: entry.task.id,
                     name: entry.task.name,
-                    status: entry.task.status.status
-                }
+                    status: entry.task.status?.status || "Unknown"
+                } : null
             }))
-        };
+        }, true);
     }
     catch (error) {
         logger.error("Error getting task time entries", error);
-        return {
-            success: false,
-            error: {
-                message: error.message || "An unknown error occurred"
-            }
-        };
+        return sponsorService.createErrorResponse(error.message || "An unknown error occurred");
     }
 }
 /**
@@ -266,31 +253,22 @@ export async function handleStartTimeTracking(params) {
         // Resolve task ID
         const taskId = await getTaskId(params.taskId, params.taskName, params.listName);
         if (!taskId) {
-            return {
-                success: false,
-                error: {
-                    message: "Task not found. Please provide a valid taskId or taskName + listName combination."
-                }
-            };
+            return sponsorService.createErrorResponse("Task not found. Please provide a valid taskId or taskName + listName combination.");
         }
         // Check for currently running timer
         const currentTimerResult = await timeTrackingService.getCurrentTimeEntry();
         if (currentTimerResult.success && currentTimerResult.data) {
-            return {
-                success: false,
-                error: {
-                    message: "A timer is already running. Please stop the current timer before starting a new one.",
-                    timer: {
-                        id: currentTimerResult.data.id,
-                        task: {
-                            id: currentTimerResult.data.task.id,
-                            name: currentTimerResult.data.task.name
-                        },
-                        start: currentTimerResult.data.start,
-                        description: currentTimerResult.data.description
-                    }
+            return sponsorService.createErrorResponse("A timer is already running. Please stop the current timer before starting a new one.", {
+                timer: {
+                    id: currentTimerResult.data.id,
+                    task: {
+                        id: currentTimerResult.data.task.id,
+                        name: currentTimerResult.data.task.name
+                    },
+                    start: currentTimerResult.data.start,
+                    description: currentTimerResult.data.description
                 }
-            };
+            });
         }
         // Prepare request data
         const requestData = {
@@ -302,25 +280,16 @@ export async function handleStartTimeTracking(params) {
         // Start time tracking
         const result = await timeTrackingService.startTimeTracking(requestData);
         if (!result.success) {
-            return {
-                success: false,
-                error: {
-                    message: result.error?.message || "Failed to start time tracking"
-                }
-            };
+            return sponsorService.createErrorResponse(result.error?.message || "Failed to start time tracking");
         }
         const timeEntry = result.data;
         if (!timeEntry) {
-            return {
-                success: false,
-                error: {
-                    message: "No time entry data returned from API"
-                }
-            };
+            return sponsorService.createErrorResponse("No time entry data returned from API");
         }
         // Format the response
-        return {
+        return sponsorService.createResponse({
             success: true,
+            message: "Time tracking started successfully",
             time_entry: {
                 id: timeEntry.id,
                 description: timeEntry.description,
@@ -333,16 +302,11 @@ export async function handleStartTimeTracking(params) {
                 billable: timeEntry.billable,
                 tags: timeEntry.tags
             }
-        };
+        }, true);
     }
     catch (error) {
         logger.error("Error starting time tracking", error);
-        return {
-            success: false,
-            error: {
-                message: error.message || "An unknown error occurred"
-            }
-        };
+        return sponsorService.createErrorResponse(error.message || "An unknown error occurred");
     }
 }
 /**
@@ -354,12 +318,7 @@ export async function handleStopTimeTracking(params) {
         // Check for currently running timer
         const currentTimerResult = await timeTrackingService.getCurrentTimeEntry();
         if (currentTimerResult.success && !currentTimerResult.data) {
-            return {
-                success: false,
-                error: {
-                    message: "No timer is currently running. Start a timer before trying to stop it."
-                }
-            };
+            return sponsorService.createErrorResponse("No timer is currently running. Start a timer before trying to stop it.");
         }
         // Prepare request data
         const requestData = {
@@ -369,25 +328,16 @@ export async function handleStopTimeTracking(params) {
         // Stop time tracking
         const result = await timeTrackingService.stopTimeTracking(requestData);
         if (!result.success) {
-            return {
-                success: false,
-                error: {
-                    message: result.error?.message || "Failed to stop time tracking"
-                }
-            };
+            return sponsorService.createErrorResponse(result.error?.message || "Failed to stop time tracking");
         }
         const timeEntry = result.data;
         if (!timeEntry) {
-            return {
-                success: false,
-                error: {
-                    message: "No time entry data returned from API"
-                }
-            };
+            return sponsorService.createErrorResponse("No time entry data returned from API");
         }
         // Format the response
-        return {
+        return sponsorService.createResponse({
             success: true,
+            message: "Time tracking stopped successfully",
             time_entry: {
                 id: timeEntry.id,
                 description: timeEntry.description,
@@ -402,16 +352,11 @@ export async function handleStopTimeTracking(params) {
                 billable: timeEntry.billable,
                 tags: timeEntry.tags
             }
-        };
+        }, true);
     }
     catch (error) {
         logger.error("Error stopping time tracking", error);
-        return {
-            success: false,
-            error: {
-                message: error.message || "An unknown error occurred"
-            }
-        };
+        return sponsorService.createErrorResponse(error.message || "An unknown error occurred");
     }
 }
 /**
@@ -423,32 +368,17 @@ export async function handleAddTimeEntry(params) {
         // Resolve task ID
         const taskId = await getTaskId(params.taskId, params.taskName, params.listName);
         if (!taskId) {
-            return {
-                success: false,
-                error: {
-                    message: "Task not found. Please provide a valid taskId or taskName + listName combination."
-                }
-            };
+            return sponsorService.createErrorResponse("Task not found. Please provide a valid taskId or taskName + listName combination.");
         }
         // Parse start time
         const startTime = parseDueDate(params.start);
         if (!startTime) {
-            return {
-                success: false,
-                error: {
-                    message: "Invalid start time format. Use a Unix timestamp (in milliseconds) or a natural language date string."
-                }
-            };
+            return sponsorService.createErrorResponse("Invalid start time format. Use a Unix timestamp (in milliseconds) or a natural language date string.");
         }
         // Parse duration
         const durationMs = parseDuration(params.duration);
         if (durationMs === 0) {
-            return {
-                success: false,
-                error: {
-                    message: "Invalid duration format. Use 'Xh Ym' format (e.g., '1h 30m') or just minutes (e.g., '90m')."
-                }
-            };
+            return sponsorService.createErrorResponse("Invalid duration format. Use 'Xh Ym' format (e.g., '1h 30m') or just minutes (e.g., '90m').");
         }
         // Prepare request data
         const requestData = {
@@ -462,25 +392,16 @@ export async function handleAddTimeEntry(params) {
         // Add time entry
         const result = await timeTrackingService.addTimeEntry(requestData);
         if (!result.success) {
-            return {
-                success: false,
-                error: {
-                    message: result.error?.message || "Failed to add time entry"
-                }
-            };
+            return sponsorService.createErrorResponse(result.error?.message || "Failed to add time entry");
         }
         const timeEntry = result.data;
         if (!timeEntry) {
-            return {
-                success: false,
-                error: {
-                    message: "No time entry data returned from API"
-                }
-            };
+            return sponsorService.createErrorResponse("No time entry data returned from API");
         }
         // Format the response
-        return {
+        return sponsorService.createResponse({
             success: true,
+            message: "Time entry added successfully",
             time_entry: {
                 id: timeEntry.id,
                 description: timeEntry.description,
@@ -495,16 +416,11 @@ export async function handleAddTimeEntry(params) {
                 billable: timeEntry.billable,
                 tags: timeEntry.tags
             }
-        };
+        }, true);
     }
     catch (error) {
         logger.error("Error adding time entry", error);
-        return {
-            success: false,
-            error: {
-                message: error.message || "An unknown error occurred"
-            }
-        };
+        return sponsorService.createErrorResponse(error.message || "An unknown error occurred");
     }
 }
 /**
@@ -515,37 +431,22 @@ export async function handleDeleteTimeEntry(params) {
     try {
         const { timeEntryId } = params;
         if (!timeEntryId) {
-            return {
-                success: false,
-                error: {
-                    message: "Time entry ID is required."
-                }
-            };
+            return sponsorService.createErrorResponse("Time entry ID is required.");
         }
         // Delete time entry
         const result = await timeTrackingService.deleteTimeEntry(timeEntryId);
         if (!result.success) {
-            return {
-                success: false,
-                error: {
-                    message: result.error?.message || "Failed to delete time entry"
-                }
-            };
+            return sponsorService.createErrorResponse(result.error?.message || "Failed to delete time entry");
         }
         // Format the response
-        return {
+        return sponsorService.createResponse({
             success: true,
             message: "Time entry deleted successfully."
-        };
+        }, true);
     }
     catch (error) {
         logger.error("Error deleting time entry", error);
-        return {
-            success: false,
-            error: {
-                message: error.message || "An unknown error occurred"
-            }
-        };
+        return sponsorService.createErrorResponse(error.message || "An unknown error occurred");
     }
 }
 /**
@@ -557,25 +458,20 @@ export async function handleGetCurrentTimeEntry(params) {
         // Get current time entry
         const result = await timeTrackingService.getCurrentTimeEntry();
         if (!result.success) {
-            return {
-                success: false,
-                error: {
-                    message: result.error?.message || "Failed to get current time entry"
-                }
-            };
+            return sponsorService.createErrorResponse(result.error?.message || "Failed to get current time entry");
         }
         const timeEntry = result.data;
         // If no timer is running
         if (!timeEntry) {
-            return {
+            return sponsorService.createResponse({
                 success: true,
                 timer_running: false,
                 message: "No timer is currently running."
-            };
+            }, true);
         }
         // Format the response
         const elapsedTime = calculateElapsedTime(timeEntry.start);
-        return {
+        return sponsorService.createResponse({
             success: true,
             timer_running: true,
             time_entry: {
@@ -591,16 +487,11 @@ export async function handleGetCurrentTimeEntry(params) {
                 billable: timeEntry.billable,
                 tags: timeEntry.tags
             }
-        };
+        }, true);
     }
     catch (error) {
         logger.error("Error getting current time entry", error);
-        return {
-            success: false,
-            error: {
-                message: error.message || "An unknown error occurred"
-            }
-        };
+        return sponsorService.createErrorResponse(error.message || "An unknown error occurred");
     }
 }
 /**

package/build/tools/task/utilities.js

@@ -65,6 +65,62 @@ export function formatTaskData(task, additional = {}) {
         ...additional
     };
 }
+//=============================================================================
+// TASK ID DETECTION UTILITIES
+//=============================================================================
+/**
+ * Detects if a task ID is a custom task ID based on common patterns
+ * Custom task IDs typically:
+ * - Contain hyphens (e.g., "DEV-1234", "PROJ-456")
+ * - Have uppercase prefixes followed by numbers
+ * - Are not 9-character alphanumeric strings (regular ClickUp task IDs)
+ *
+ * @param taskId The task ID to check
+ * @returns true if the ID appears to be a custom task ID
+ */
+export function isCustomTaskId(taskId) {
+    if (!taskId || typeof taskId !== 'string') {
+        return false;
+    }
+    // Trim whitespace
+    taskId = taskId.trim();
+    // Regular ClickUp task IDs are typically 9 characters, alphanumeric
+    // Custom task IDs usually have different patterns
+    // Check if it's a standard 9-character ClickUp ID (letters and numbers only)
+    const standardIdPattern = /^[a-zA-Z0-9]{9}$/;
+    if (standardIdPattern.test(taskId)) {
+        return false;
+    }
+    // Check for common custom task ID patterns:
+    // 1. Contains hyphens (most common pattern: PREFIX-NUMBER)
+    if (taskId.includes('-')) {
+        // Additional validation: should have letters before hyphen and numbers after
+        const hyphenPattern = /^[A-Za-z]+[-][0-9]+$/;
+        return hyphenPattern.test(taskId);
+    }
+    // 2. Contains underscores (another common pattern: PREFIX_NUMBER)
+    if (taskId.includes('_')) {
+        const underscorePattern = /^[A-Za-z]+[_][0-9]+$/;
+        return underscorePattern.test(taskId);
+    }
+    // 3. Contains uppercase letters followed by numbers (without separators)
+    const customIdPattern = /^[A-Z]+\d+$/;
+    if (customIdPattern.test(taskId)) {
+        return true;
+    }
+    // 4. Mixed case with numbers but not 9 characters (less common)
+    const mixedCasePattern = /^[A-Za-z]+\d+$/;
+    if (mixedCasePattern.test(taskId) && taskId.length !== 9) {
+        return true;
+    }
+    // 5. Contains dots (some organizations use PROJECT.TASK format)
+    if (taskId.includes('.')) {
+        const dotPattern = /^[A-Za-z]+[.][0-9]+$/;
+        return dotPattern.test(taskId);
+    }
+    // If none of the patterns match, assume it's a regular task ID
+    return false;
+}
 /**
  * Validates task identification parameters
  *
@@ -169,28 +225,6 @@ export function parseBulkOptions(rawOptions) {
     }
     return rawOptions;
 }
-//=============================================================================
-// ID DETECTION UTILITIES
-//=============================================================================
-/**
- * Determines if an ID is a custom ID based on its format
- * Custom IDs typically have an uppercase prefix followed by a hyphen and number (e.g., DEV-1234)
- * Regular task IDs are always 9 characters long
- *
- * @param id The task ID to check
- * @returns True if the ID appears to be a custom ID
- */
-export function isCustomTaskId(id) {
-    if (!id)
-        return false;
-    // Regular task IDs are exactly 9 characters
-    if (id.length === 9) {
-        return false;
-    }
-    // Custom IDs have an uppercase prefix followed by a hyphen and numbers
-    const customIdPattern = /^[A-Z]+-\d+$/;
-    return customIdPattern.test(id);
-}
 /**
  * Resolves a list ID from either direct ID or name
  * Handles validation and throws appropriate errors