@taazkareem/clickup-mcp-server 0.8.4 → 0.9.0

package/build/utils/schema-compatibility.js

@@ -0,0 +1,222 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Universal Schema Compatibility for MCP Multi-LLM Support
+ *
+ * This module provides universal schema compatibility that works simultaneously
+ * with Claude, OpenAI, and Gemini clients without requiring client detection.
+ * The approach creates inherently compatible schemas rather than transforming them.
+ */
+/**
+ * Create a universal schema that works across all major LLM clients
+ * This approach uses flexible schema definitions that are inherently compatible
+ * with Claude, OpenAI, and Gemini without requiring client detection
+ */
+export function createUniversalSchema(originalSchema) {
+    if (!originalSchema || typeof originalSchema !== 'object') {
+        return originalSchema;
+    }
+    // Deep clone to avoid mutating original
+    const universalSchema = JSON.parse(JSON.stringify(originalSchema));
+    // Apply universal compatibility transformations
+    transformSchemaForUniversalCompatibility(universalSchema);
+    return universalSchema;
+}
+/**
+ * Transform a schema to be universally compatible with all LLM clients
+ * Uses flexible type definitions and multiple format support
+ */
+function transformSchemaForUniversalCompatibility(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return;
+    }
+    // Handle type field - make it flexible for all clients
+    if (schema.type) {
+        // Store original type for reference
+        const originalType = schema.type;
+        // For universal compatibility, we use an approach that works with all clients:
+        // 1. Keep the standard lowercase type (works with Claude/OpenAI)
+        // 2. Add format hints that Gemini can understand
+        // 3. Use flexible validation that doesn't break any client
+        switch (originalType.toLowerCase()) {
+            case 'string':
+                schema.type = 'string';
+                // Add format hints for better compatibility
+                if (!schema.format) {
+                    schema.format = 'text';
+                }
+                break;
+            case 'number':
+                schema.type = 'number';
+                break;
+            case 'integer':
+                schema.type = 'integer';
+                break;
+            case 'boolean':
+                schema.type = 'boolean';
+                break;
+            case 'array':
+                schema.type = 'array';
+                break;
+            case 'object':
+                schema.type = 'object';
+                break;
+            default:
+                // Keep original type for unknown types
+                schema.type = originalType;
+        }
+    }
+    // Recursively process nested schemas
+    if (schema.properties) {
+        Object.values(schema.properties).forEach((prop) => {
+            transformSchemaForUniversalCompatibility(prop);
+        });
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            schema.items.forEach((item) => transformSchemaForUniversalCompatibility(item));
+        }
+        else {
+            transformSchemaForUniversalCompatibility(schema.items);
+        }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        transformSchemaForUniversalCompatibility(schema.additionalProperties);
+    }
+    // Handle oneOf, anyOf, allOf
+    ['oneOf', 'anyOf', 'allOf'].forEach(key => {
+        if (schema[key] && Array.isArray(schema[key])) {
+            schema[key].forEach((subSchema) => transformSchemaForUniversalCompatibility(subSchema));
+        }
+    });
+}
+/**
+ * Transform JSON Schema types for Gemini compatibility
+ * Gemini requires uppercase type names and specific parameter structures
+ */
+function transformSchemaForGemini(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    const transformed = { ...schema };
+    // Transform type names to uppercase for Gemini
+    if (transformed.type) {
+        switch (transformed.type) {
+            case 'string':
+                transformed.type = 'STRING';
+                break;
+            case 'number':
+                transformed.type = 'NUMBER';
+                break;
+            case 'integer':
+                transformed.type = 'INTEGER';
+                break;
+            case 'boolean':
+                transformed.type = 'BOOLEAN';
+                break;
+            case 'array':
+                transformed.type = 'ARRAY';
+                break;
+            case 'object':
+                transformed.type = 'OBJECT';
+                break;
+        }
+    }
+    // Recursively transform nested properties
+    if (transformed.properties) {
+        const newProperties = {};
+        for (const [key, value] of Object.entries(transformed.properties)) {
+            newProperties[key] = transformSchemaForGemini(value);
+        }
+        transformed.properties = newProperties;
+    }
+    // Transform array items
+    if (transformed.items) {
+        transformed.items = transformSchemaForGemini(transformed.items);
+    }
+    // Transform oneOf/anyOf schemas
+    if (transformed.oneOf) {
+        transformed.oneOf = transformed.oneOf.map((item) => transformSchemaForGemini(item));
+    }
+    if (transformed.anyOf) {
+        transformed.anyOf = transformed.anyOf.map((item) => transformSchemaForGemini(item));
+    }
+    return transformed;
+}
+/**
+ * Transform tool schema for OpenAI compatibility
+ * OpenAI uses a wrapped function structure
+ */
+function transformSchemaForOpenAI(schema) {
+    // OpenAI expects a different structure - this is a placeholder
+    // for future OpenAI compatibility if needed
+    return schema;
+}
+/**
+ * Transform a tool definition based on client type
+ */
+export function transformToolForClient(tool, clientType) {
+    // Create a deep copy to avoid modifying the original
+    const transformedTool = JSON.parse(JSON.stringify(tool));
+    switch (clientType) {
+        case ClientType.GEMINI:
+            if (transformedTool.inputSchema) {
+                transformedTool.inputSchema = transformSchemaForGemini(transformedTool.inputSchema);
+            }
+            break;
+        case ClientType.OPENAI:
+            if (transformedTool.inputSchema) {
+                transformedTool.inputSchema = transformSchemaForOpenAI(transformedTool.inputSchema);
+            }
+            break;
+        case ClientType.CLAUDE:
+        case ClientType.UNKNOWN:
+        default:
+            // Claude and unknown clients use standard JSON Schema format
+            // No transformation needed
+            break;
+    }
+    return transformedTool;
+}
+/**
+ * Transform an array of tools based on client type
+ */
+export function transformToolsForClient(tools, clientType) {
+    return tools.map(tool => transformToolForClient(tool, clientType));
+}
+/**
+ * Enhanced error handling for client compatibility issues
+ */
+export function createCompatibilityError(clientType, originalError) {
+    const clientName = clientType.charAt(0).toUpperCase() + clientType.slice(1);
+    return new Error(`MCP Client Compatibility Issue (${clientName}): ${originalError.message}. ` +
+        `This may be due to differences in how ${clientName}-based clients handle MCP protocol. ` +
+        `Please ensure your client supports the MCP protocol version 2024-11-05 or later.`);
+}
+/**
+ * Log client compatibility information for debugging
+ */
+export function logClientCompatibilityInfo(clientType, toolCount, clientInfo) {
+    console.log(`[MCP Compatibility] Detected LLM model type: ${clientType}`);
+    console.log(`[MCP Compatibility] Serving ${toolCount} tools with ${clientType}-compatible schemas`);
+    if (clientInfo) {
+        console.log(`[MCP Compatibility] Client details:`, {
+            name: clientInfo.name,
+            version: clientInfo.version,
+            title: clientInfo.title
+        });
+    }
+    if (clientType === ClientType.GEMINI) {
+        console.log(`[MCP Compatibility] Applied Gemini-specific transformations: uppercase types, parameter structure adjustments`);
+    }
+    else if (clientType === ClientType.CLAUDE) {
+        console.log(`[MCP Compatibility] Using Claude-compatible standard JSON Schema format`);
+    }
+    else if (clientType === ClientType.OPENAI) {
+        console.log(`[MCP Compatibility] Using OpenAI-compatible schema format`);
+    }
+    else if (clientType === ClientType.UNKNOWN) {
+        console.log(`[MCP Compatibility] Using standard JSON Schema format for unknown LLM model`);
+    }
+}

package/build/utils/universal-schema-compatibility.js

@@ -0,0 +1,171 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Universal Schema Compatibility for MCP Multi-LLM Support
+ *
+ * This module provides universal schema compatibility that works simultaneously
+ * with Claude, OpenAI, and Gemini clients without requiring client detection.
+ * The approach creates inherently compatible schemas rather than transforming them.
+ */
+/**
+ * Create a universal schema that works across all major LLM clients
+ * This approach uses flexible schema definitions that are inherently compatible
+ * with Claude, OpenAI, and Gemini without requiring client detection
+ */
+export function createUniversalSchema(originalSchema) {
+    if (!originalSchema || typeof originalSchema !== 'object') {
+        return originalSchema;
+    }
+    // Deep clone to avoid mutating original
+    const universalSchema = JSON.parse(JSON.stringify(originalSchema));
+    // Apply universal compatibility transformations
+    transformSchemaForUniversalCompatibility(universalSchema);
+    return universalSchema;
+}
+/**
+ * Transform a schema to be universally compatible with all LLM clients
+ * Uses flexible type definitions and multiple format support
+ */
+function transformSchemaForUniversalCompatibility(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return;
+    }
+    // Handle type field - make it flexible for all clients
+    if (schema.type) {
+        // Store original type for reference
+        const originalType = schema.type;
+        // For universal compatibility, we use an approach that works with all clients:
+        // 1. Keep the standard lowercase type (works with Claude/OpenAI)
+        // 2. Add format hints that Gemini can understand
+        // 3. Use flexible validation that doesn't break any client
+        switch (originalType.toLowerCase()) {
+            case 'string':
+                schema.type = 'string';
+                // Add format hints for better compatibility
+                if (!schema.format) {
+                    schema.format = 'text';
+                }
+                break;
+            case 'number':
+                schema.type = 'number';
+                break;
+            case 'integer':
+                schema.type = 'integer';
+                break;
+            case 'boolean':
+                schema.type = 'boolean';
+                break;
+            case 'array':
+                schema.type = 'array';
+                break;
+            case 'object':
+                schema.type = 'object';
+                break;
+            default:
+                // Keep original type for unknown types
+                schema.type = originalType;
+        }
+    }
+    // Recursively process nested schemas
+    if (schema.properties) {
+        Object.values(schema.properties).forEach((prop) => {
+            transformSchemaForUniversalCompatibility(prop);
+        });
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            schema.items.forEach((item) => transformSchemaForUniversalCompatibility(item));
+        }
+        else {
+            transformSchemaForUniversalCompatibility(schema.items);
+        }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        transformSchemaForUniversalCompatibility(schema.additionalProperties);
+    }
+    // Handle oneOf, anyOf, allOf
+    ['oneOf', 'anyOf', 'allOf'].forEach(key => {
+        if (schema[key] && Array.isArray(schema[key])) {
+            schema[key].forEach((subSchema) => transformSchemaForUniversalCompatibility(subSchema));
+        }
+    });
+}
+/**
+ * Transform tools to use universal schema compatibility
+ * This replaces the old client-specific transformation approach
+ */
+export function createUniversalTools(tools) {
+    return tools.map(tool => createUniversalTool(tool));
+}
+/**
+ * Transform a single tool to use universal schema compatibility
+ */
+export function createUniversalTool(tool) {
+    // Deep clone to avoid mutating original
+    const universalTool = JSON.parse(JSON.stringify(tool));
+    // Apply universal schema transformation to input schema
+    if (universalTool.inputSchema) {
+        universalTool.inputSchema = createUniversalSchema(universalTool.inputSchema);
+    }
+    // Apply universal schema transformation to output schema if present
+    if (universalTool.outputSchema) {
+        universalTool.outputSchema = createUniversalSchema(universalTool.outputSchema);
+    }
+    return universalTool;
+}
+/**
+ * Enhanced schema validation that works across all LLM clients
+ * This ensures schemas are robust and compatible
+ */
+export function validateUniversalSchema(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return false;
+    }
+    // Check for required fields
+    if (schema.type && typeof schema.type !== 'string') {
+        return false;
+    }
+    // Validate properties structure
+    if (schema.properties) {
+        if (typeof schema.properties !== 'object') {
+            return false;
+        }
+        // Recursively validate nested properties
+        for (const prop of Object.values(schema.properties)) {
+            if (!validateUniversalSchema(prop)) {
+                return false;
+            }
+        }
+    }
+    // Validate array items
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            for (const item of schema.items) {
+                if (!validateUniversalSchema(item)) {
+                    return false;
+                }
+            }
+        }
+        else if (!validateUniversalSchema(schema.items)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Log universal compatibility information for debugging
+ */
+export function logUniversalCompatibilityInfo(toolCount) {
+    console.log(`[MCP Universal Compatibility] Serving ${toolCount} tools with universal schema format`);
+    console.log(`[MCP Universal Compatibility] Compatible with Claude, OpenAI, and Gemini clients simultaneously`);
+    console.log(`[MCP Universal Compatibility] No client detection required - works with all MCP clients`);
+}
+/**
+ * Create enhanced error messages for universal compatibility
+ */
+export function createUniversalCompatibilityError(originalError) {
+    return new Error(`MCP Universal Compatibility Issue: ${originalError.message}. ` +
+        `This server uses universal schema format compatible with Claude, OpenAI, and Gemini clients. ` +
+        `Please ensure your client supports MCP protocol version 2024-11-05 or later.`);
+}

package/build/virtual-sdk/generator.js

@@ -0,0 +1,53 @@
+function mapJsonTypeToTs(prop, indentLevel = 0) {
+    if (!prop)
+        return "any";
+    const indent = "  ".repeat(indentLevel);
+    if (prop.type === "array") {
+        return `${mapJsonTypeToTs(prop.items, indentLevel)}[]`;
+    }
+    if (prop.type === "object" && prop.properties) {
+        const lines = ["{"];
+        for (const [key, value] of Object.entries(prop.properties)) {
+            const isRequired = prop.required?.includes(key);
+            const childType = mapJsonTypeToTs(value, indentLevel + 1);
+            const doc = value.description ? `\n${indent}  /** ${value.description} */\n` : "";
+            lines.push(`${doc}${indent}  ${key}${isRequired ? "" : "?"}: ${childType};`);
+        }
+        lines.push(`${indent}}`);
+        return lines.join("\n");
+    }
+    if (prop.enum) {
+        return prop.enum.map((e) => typeof e === 'string' ? `"${e}"` : e).join(" | ");
+    }
+    if (prop.oneOf) {
+        return prop.oneOf.map((sub) => mapJsonTypeToTs(sub, indentLevel)).join(" | ");
+    }
+    switch (prop.type) {
+        case "string": return "string";
+        case "number": return "number";
+        case "integer": return "number";
+        case "boolean": return "boolean";
+        default: return "any";
+    }
+}
+export function generateVirtualFile(tools, moduleName) {
+    const header = `// ClickUp SDK - ${moduleName} module
+// This is a virtual file generated by the ClickUp MCP Server.
+// Use these functions to interact with the ClickUp API.
+import { callMCPTool } from "mcp-client"; // Abstracted client
+`;
+    const definitions = tools.map(tool => {
+        const funcName = tool.name;
+        const interfaceName = funcName.charAt(0).toUpperCase() + funcName.slice(1) + "Args";
+        const schema = tool.inputSchema;
+        const typeDef = `export interface ${interfaceName} ${mapJsonTypeToTs(schema, 0)}`;
+        const docBlock = `/**
+ * ${tool.description?.replace(/\n/g, "\n * ") || ""}
+ */`;
+        const funcDef = `export async function ${funcName}(args: ${interfaceName}): Promise<any> {
+  return await callMCPTool('${funcName}', args);
+}`;
+        return `${typeDef}\n\n${docBlock}\n${funcDef}`;
+    });
+    return [header, ...definitions].join("\n\n");
+}

package/build/virtual-sdk/registry.js

@@ -0,0 +1,45 @@
+import { generateVirtualFile } from "./generator.js";
+// Import all definitions
+import { createTaskTool, updateTaskTool, moveTaskTool, duplicateTaskTool, getTaskTool, deleteTaskTool, getTasksTool, getTaskCommentsTool, createTaskCommentTool } from "../tools/task/single-operations.js";
+import { attachTaskFileTool } from "../tools/task/attachments.js";
+import { createBulkTasksTool, updateBulkTasksTool, moveBulkTasksTool, deleteBulkTasksTool } from "../tools/task/bulk-operations.js";
+import { getTaskTimeEntriesTool, startTimeTrackingTool, stopTimeTrackingTool, addTimeEntryTool, deleteTimeEntryTool, getCurrentTimeEntryTool } from "../tools/task/time-tracking.js";
+import { getWorkspaceTasksTool } from "../tools/task/workspace-operations.js";
+import { createListTool, createListInFolderTool, getListTool, updateListTool, deleteListTool } from "../tools/list.js";
+import { createFolderTool, getFolderTool, updateFolderTool, deleteFolderTool } from "../tools/folder.js";
+import { getSpaceTagsTool, createSpaceTagTool, updateSpaceTagTool, deleteSpaceTagTool, addTagToTaskTool, removeTagFromTaskTool } from "../tools/tag.js";
+import { workspaceHierarchyTool } from "../tools/workspace.js";
+import { getWorkspaceMembersTool, findMemberByNameTool, resolveAssigneesTool } from "../tools/member.js";
+import { createDocumentTool, getDocumentTool, listDocumentsTool, listDocumentPagesTool, getDocumentPagesTool, createDocumentPageTool, updateDocumentPageTool } from "../tools/documents.js";
+const MODULES = {
+    "tasks": [createTaskTool, getTaskTool, updateTaskTool, deleteTaskTool, moveTaskTool, duplicateTaskTool, getTasksTool, attachTaskFileTool],
+    "bulk": [createBulkTasksTool, updateBulkTasksTool, moveBulkTasksTool, deleteBulkTasksTool],
+    "search": [getWorkspaceTasksTool],
+    "comments": [getTaskCommentsTool, createTaskCommentTool],
+    "time": [getTaskTimeEntriesTool, startTimeTrackingTool, stopTimeTrackingTool, addTimeEntryTool, deleteTimeEntryTool, getCurrentTimeEntryTool],
+    "lists": [createListTool, createListInFolderTool, getListTool, updateListTool, deleteListTool],
+    "folders": [createFolderTool, getFolderTool, updateFolderTool, deleteFolderTool],
+    "tags": [getSpaceTagsTool, createSpaceTagTool, updateSpaceTagTool, deleteSpaceTagTool, addTagToTaskTool, removeTagFromTaskTool],
+    "members": [getWorkspaceMembersTool, findMemberByNameTool, resolveAssigneesTool],
+    "docs": [createDocumentTool, getDocumentTool, listDocumentsTool, listDocumentPagesTool, getDocumentPagesTool, createDocumentPageTool, updateDocumentPageTool],
+    "workspace": [workspaceHierarchyTool]
+};
+export class VirtualSDKRegistry {
+    getResourcesList() {
+        return Object.keys(MODULES).map(module => ({
+            uri: `source://clickup/${module}.ts`,
+            name: `ClickUp ${module} SDK`,
+            description: `TypeScript definitions for ${module} operations`,
+            mimeType: "application/typescript"
+        }));
+    }
+    getResourceContent(uri) {
+        const url = new URL(uri);
+        const path = url.pathname.replace(/^\//, '');
+        const moduleKey = path.replace('clickup/', '').replace('.ts', '');
+        if (MODULES[moduleKey]) {
+            return generateVirtualFile(MODULES[moduleKey], moduleKey);
+        }
+        throw new Error(`Virtual file not found: ${uri}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taazkareem/clickup-mcp-server",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "description": "ClickUp MCP Server - Integrate ClickUp tasks with AI through Model Context Protocol",
   "type": "module",
   "main": "build/index.js",
@@ -45,7 +45,7 @@
     "project-organization"
   ],
   "author": "Talib Kareem",
-  "license": "MIT",
+  "license": "UNLICENSED",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/taazkareem/clickup-mcp-server.git"