@taazkareem/clickup-mcp-server 0.4.60 → 0.4.63

package/build/tools/utils.js

@@ -0,0 +1,150 @@
+/**
+ * Utility functions for ClickUp MCP tools
+ */
+/**
+ * Get a timestamp for a relative time
+ *
+ * @param hours Hours from now
+ * @param days Days from now
+ * @param weeks Weeks from now
+ * @param months Months from now
+ * @returns Timestamp in milliseconds
+ */
+export function getRelativeTimestamp(hours = 0, days = 0, weeks = 0, months = 0) {
+    const now = new Date();
+    if (hours)
+        now.setHours(now.getHours() + hours);
+    if (days)
+        now.setDate(now.getDate() + days);
+    if (weeks)
+        now.setDate(now.getDate() + (weeks * 7));
+    if (months)
+        now.setMonth(now.getMonth() + months);
+    return now.getTime();
+}
+/**
+ * Parse a due date string into a timestamp
+ * Supports ISO 8601 format or natural language like "tomorrow"
+ *
+ * @param dateString Date string to parse
+ * @returns Timestamp in milliseconds or undefined if parsing fails
+ */
+export function parseDueDate(dateString) {
+    if (!dateString)
+        return undefined;
+    try {
+        // Handle natural language dates
+        const lowerDate = dateString.toLowerCase();
+        const now = new Date();
+        if (lowerDate === 'today') {
+            const today = new Date();
+            today.setHours(23, 59, 59, 999);
+            return today.getTime();
+        }
+        // Handle relative dates with specific times
+        const relativeTimeRegex = /(?:(\d+)\s*(days?|weeks?|months?)\s*from\s*now|tomorrow|next\s+(?:week|month))\s*(?:at\s+(\d+)(?::(\d+))?\s*(am|pm)?)?/i;
+        const match = lowerDate.match(relativeTimeRegex);
+        if (match) {
+            const date = new Date();
+            const [_, amount, unit, hours, minutes, meridian] = match;
+            // Calculate the future date
+            if (amount && unit) {
+                const value = parseInt(amount);
+                if (unit.startsWith('day')) {
+                    date.setDate(date.getDate() + value);
+                }
+                else if (unit.startsWith('week')) {
+                    date.setDate(date.getDate() + (value * 7));
+                }
+                else if (unit.startsWith('month')) {
+                    date.setMonth(date.getMonth() + value);
+                }
+            }
+            else if (lowerDate.startsWith('tomorrow')) {
+                date.setDate(date.getDate() + 1);
+            }
+            else if (lowerDate.includes('next week')) {
+                date.setDate(date.getDate() + 7);
+            }
+            else if (lowerDate.includes('next month')) {
+                date.setMonth(date.getMonth() + 1);
+            }
+            // Set the time if specified
+            if (hours) {
+                let parsedHours = parseInt(hours);
+                const parsedMinutes = minutes ? parseInt(minutes) : 0;
+                // Convert to 24-hour format if meridian is specified
+                if (meridian?.toLowerCase() === 'pm' && parsedHours < 12)
+                    parsedHours += 12;
+                if (meridian?.toLowerCase() === 'am' && parsedHours === 12)
+                    parsedHours = 0;
+                date.setHours(parsedHours, parsedMinutes, 0, 0);
+            }
+            else {
+                // Default to end of day if no time specified
+                date.setHours(23, 59, 59, 999);
+            }
+            return date.getTime();
+        }
+        // Handle hours from now
+        const hoursRegex = /(\d+)\s*hours?\s*from\s*now/i;
+        const daysRegex = /(\d+)\s*days?\s*from\s*now/i;
+        const weeksRegex = /(\d+)\s*weeks?\s*from\s*now/i;
+        const monthsRegex = /(\d+)\s*months?\s*from\s*now/i;
+        if (hoursRegex.test(lowerDate)) {
+            const hours = parseInt(lowerDate.match(hoursRegex)[1]);
+            return getRelativeTimestamp(hours);
+        }
+        if (daysRegex.test(lowerDate)) {
+            const days = parseInt(lowerDate.match(daysRegex)[1]);
+            return getRelativeTimestamp(0, days);
+        }
+        if (weeksRegex.test(lowerDate)) {
+            const weeks = parseInt(lowerDate.match(weeksRegex)[1]);
+            return getRelativeTimestamp(0, 0, weeks);
+        }
+        if (monthsRegex.test(lowerDate)) {
+            const months = parseInt(lowerDate.match(monthsRegex)[1]);
+            return getRelativeTimestamp(0, 0, 0, months);
+        }
+        // Try to parse as a date string
+        const date = new Date(dateString);
+        if (!isNaN(date.getTime())) {
+            return date.getTime();
+        }
+        // If all parsing fails, return undefined
+        return undefined;
+    }
+    catch (error) {
+        console.warn(`Failed to parse due date: ${dateString}`, error);
+        return undefined;
+    }
+}
+/**
+ * Format a due date timestamp into a human-readable string
+ *
+ * @param timestamp Unix timestamp in milliseconds
+ * @returns Formatted date string or undefined if timestamp is invalid
+ */
+export function formatDueDate(timestamp) {
+    if (!timestamp)
+        return undefined;
+    try {
+        const date = new Date(timestamp);
+        if (isNaN(date.getTime()))
+            return undefined;
+        // Format: "March 10, 2025 at 10:56 PM"
+        return date.toLocaleString('en-US', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: '2-digit',
+            hour12: true
+        }).replace(' at', ',');
+    }
+    catch (error) {
+        console.warn(`Failed to format due date: ${timestamp}`, error);
+        return undefined;
+    }
+}

package/build/tools/workspace.js

@@ -0,0 +1,132 @@
+/**
+ * ClickUp MCP Workspace Tools
+ *
+ * This module defines workspace-related tools like retrieving workspace hierarchy.
+ * It handles the workspace tool definitions and the implementation of their handlers.
+ */
+// Use the workspace service imported from the server
+// This is defined when server.ts imports this module
+let workspaceService;
+/**
+ * Tool definition for retrieving the complete workspace hierarchy
+ */
+export const workspaceHierarchyTool = {
+    name: 'get_workspace_hierarchy',
+    description: 'Get the complete workspace hierarchy including spaces, folders, and lists.',
+    inputSchema: {
+        type: 'object',
+        properties: {}
+    }
+};
+/**
+ * Initialize the tool with services
+ */
+export function initializeWorkspaceTool(services) {
+    workspaceService = services.workspace;
+}
+/**
+ * Handler for the get_workspace_hierarchy tool
+ */
+export async function handleGetWorkspaceHierarchy() {
+    try {
+        // Get workspace hierarchy from the workspace service
+        const hierarchy = await workspaceService.getWorkspaceHierarchy();
+        const response = formatHierarchyResponse(hierarchy);
+        return response;
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error getting workspace hierarchy: ${error.message}`
+                }
+            ]
+        };
+    }
+}
+/**
+ * Format the hierarchy for the response
+ */
+function formatHierarchyResponse(hierarchy) {
+    try {
+        // Helper function to format nodes by type
+        const formatNodesByType = (nodes = []) => {
+            const result = {
+                spaces: [],
+                folders: [],
+                lists: []
+            };
+            for (const node of nodes) {
+                if (node.type === 'space') {
+                    const spaceResult = {
+                        id: node.id,
+                        name: node.name,
+                        type: node.type,
+                        lists: [],
+                        folders: []
+                    };
+                    // Process children of space
+                    if (node.children && node.children.length > 0) {
+                        const childrenByType = formatNodesByType(node.children);
+                        spaceResult.lists = childrenByType.lists;
+                        spaceResult.folders = childrenByType.folders;
+                    }
+                    result.spaces.push(spaceResult);
+                }
+                else if (node.type === 'folder') {
+                    const folderResult = {
+                        id: node.id,
+                        name: node.name,
+                        type: node.type,
+                        lists: []
+                    };
+                    // Process children of folder (only lists)
+                    if (node.children && node.children.length > 0) {
+                        folderResult.lists = node.children
+                            .filter(child => child.type === 'list')
+                            .map(list => ({
+                            id: list.id,
+                            name: list.name,
+                            type: list.type
+                        }));
+                    }
+                    result.folders.push(folderResult);
+                }
+                else if (node.type === 'list') {
+                    result.lists.push({
+                        id: node.id,
+                        name: node.name,
+                        type: node.type
+                    });
+                }
+            }
+            return result;
+        };
+        // Convert the workspace hierarchy to a simplified format
+        const rootChildren = formatNodesByType(hierarchy.root.children);
+        const formattedHierarchy = {
+            workspaceId: hierarchy.root.id,
+            workspaceName: hierarchy.root.name,
+            spaces: rootChildren.spaces
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(formattedHierarchy, null, 2)
+                }
+            ]
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error formatting workspace hierarchy: ${error.message}`
+                }
+            ]
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.4.60",
+  "version": "0.4.63",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",
@@ -44,6 +44,8 @@
   "homepage": "https://github.com/taazkareem/clickup-mcp-server#readme",
   "dependencies": {
     "@modelcontextprotocol/sdk": "0.6.0",
+    "@modelcontextprotocol/server-github": "^2025.1.23",
+    "@taazkareem/clickup-mcp-server": "^0.4.60",
     "axios": "^1.6.7",
     "dotenv": "^16.4.1"
   },