@taazkareem/clickup-mcp-server 0.4.72 → 0.4.74

package/build/tools/cache.js

@@ -1,452 +0,0 @@
-/**
- * ClickUp MCP Cache Module
- *
- * This module provides caching for workspace data including:
- * - Workspace hierarchy (spaces, folders, lists)
- * - Task data (names, IDs, and metadata)
- *
- * The cache is initialized on server startup and updated when
- * tasks, lists, folders, or spaces are modified.
- */
-import { createClickUpServices } from '../services/clickup/index.js';
-import config from '../config.js';
-import { log } from '../logger.js';
-// Initialize ClickUp services
-const services = createClickUpServices({
-    apiKey: config.clickupApiKey,
-    teamId: config.clickupTeamId
-});
-const { workspace: workspaceService, task: taskService, list: listService, folder: folderService } = services;
-/**
- * Singleton cache instance
- */
-let workspaceCache = null;
-/**
- * Normalize a name for case-insensitive lookups
- */
-function normalizeName(name) {
-    return name.toLowerCase().trim();
-}
-/**
- * Generate a unique key for task name lookup
- */
-function getTaskNameKey(listId, taskName) {
-    return `${listId}:${normalizeName(taskName)}`;
-}
-/**
- * Initialize an empty cache structure
- */
-function createEmptyCache() {
-    return {
-        hierarchy: {
-            root: {
-                id: config.clickupTeamId,
-                name: 'Workspace',
-                children: []
-            }
-        },
-        tasksById: new Map(),
-        tasksByName: new Map(),
-        listIdsByName: new Map(),
-        folderIdsByName: new Map(),
-        spaceIdsByName: new Map(),
-        lastUpdated: new Date(),
-        initialized: false
-    };
-}
-/**
- * Process workspace hierarchy to populate ID lookup maps
- */
-function processHierarchy(hierarchy) {
-    if (!workspaceCache) {
-        workspaceCache = createEmptyCache();
-    }
-    // Clear existing maps
-    workspaceCache.listIdsByName.clear();
-    workspaceCache.folderIdsByName.clear();
-    workspaceCache.spaceIdsByName.clear();
-    // Recursively process all nodes
-    const processNode = (node) => {
-        const normalizedName = normalizeName(node.name);
-        // Store in appropriate map based on node type
-        switch (node.type) {
-            case 'space':
-                workspaceCache.spaceIdsByName.set(normalizedName, node.id);
-                break;
-            case 'folder':
-                workspaceCache.folderIdsByName.set(normalizedName, node.id);
-                break;
-            case 'list':
-                workspaceCache.listIdsByName.set(normalizedName, node.id);
-                break;
-        }
-        // Process children recursively
-        if (node.children && node.children.length > 0) {
-            node.children.forEach(child => processNode(child));
-        }
-    };
-    // Process all space nodes (children of the root)
-    hierarchy.root.children.forEach(node => processNode(node));
-}
-/**
- * Cache a single task
- */
-function cacheTask(task) {
-    if (!workspaceCache) {
-        workspaceCache = createEmptyCache();
-    }
-    // Create cached task object
-    const cachedTask = {
-        id: task.id,
-        name: task.name,
-        listId: task.list.id,
-        status: task.status?.status,
-        dueDate: task.due_date,
-        priority: task.priority?.priority ? Number(task.priority.priority) : null,
-        createdDate: task.date_created,
-        updatedDate: task.date_updated
-    };
-    // Store in maps
-    workspaceCache.tasksById.set(task.id, cachedTask);
-    workspaceCache.tasksByName.set(getTaskNameKey(task.list.id, task.name), task.id);
-}
-/**
- * Remove a task from the cache
- */
-function removeCachedTask(taskId) {
-    if (!workspaceCache || !workspaceCache.tasksById.has(taskId)) {
-        return;
-    }
-    // Get task details before removing
-    const task = workspaceCache.tasksById.get(taskId);
-    if (task) {
-        // Remove from name lookup
-        const nameKey = getTaskNameKey(task.listId, task.name);
-        workspaceCache.tasksByName.delete(nameKey);
-        // Remove from ID lookup
-        workspaceCache.tasksById.delete(taskId);
-    }
-}
-/**
- * Update a cached task with new data
- */
-function updateCachedTask(taskId, updates) {
-    if (!workspaceCache || !workspaceCache.tasksById.has(taskId)) {
-        return;
-    }
-    const task = workspaceCache.tasksById.get(taskId);
-    if (!task)
-        return;
-    // Handle name change - requires updating the tasksByName map
-    if (updates.name && updates.name !== task.name) {
-        // Remove old name lookup
-        const oldNameKey = getTaskNameKey(task.listId, task.name);
-        workspaceCache.tasksByName.delete(oldNameKey);
-        // Add new name lookup
-        const newNameKey = getTaskNameKey(task.listId, updates.name);
-        workspaceCache.tasksByName.set(newNameKey, taskId);
-    }
-    // Handle list change - requires updating the tasksByName map
-    if (updates.listId && updates.listId !== task.listId) {
-        // Remove old list-based lookup
-        const oldNameKey = getTaskNameKey(task.listId, task.name);
-        workspaceCache.tasksByName.delete(oldNameKey);
-        // Add new list-based lookup
-        const newNameKey = getTaskNameKey(updates.listId, task.name);
-        workspaceCache.tasksByName.set(newNameKey, taskId);
-    }
-    // Update the task object with all provided updates
-    Object.assign(task, updates);
-    // Update the task in the cache
-    workspaceCache.tasksById.set(taskId, task);
-    // Update last updated timestamp
-    workspaceCache.lastUpdated = new Date();
-}
-/**
- * Cache all tasks for a list
- */
-async function cacheTasksForList(listId) {
-    try {
-        log('debug', `Fetching tasks for list ${listId}...`);
-        const tasks = await taskService.getTasks(listId);
-        log('debug', `Caching ${tasks.length} tasks for list ${listId}`);
-        tasks.forEach(task => {
-            cacheTask(task);
-        });
-        // Update last updated timestamp
-        if (workspaceCache) {
-            workspaceCache.lastUpdated = new Date();
-        }
-    }
-    catch (error) {
-        log('error', `Error caching tasks for list ${listId}:`, error);
-    }
-}
-/**
- * Initialize the workspace cache
- * This should be called on server startup
- */
-export async function initializeCache() {
-    try {
-        log('info', 'Initializing workspace cache...');
-        // Create new cache
-        workspaceCache = createEmptyCache();
-        log('debug', 'Empty cache structure created');
-        // Get workspace hierarchy
-        log('debug', 'Fetching workspace hierarchy from ClickUp API...');
-        const hierarchy = await workspaceService.getWorkspaceHierarchy(true);
-        workspaceCache.hierarchy = hierarchy;
-        // Count spaces, folders, and lists in the hierarchy
-        const stats = countHierarchyItems(hierarchy);
-        log('info', 'Workspace hierarchy fetched successfully', stats);
-        // Process hierarchy to populate ID lookup maps
-        log('debug', 'Processing hierarchy to build lookup maps...');
-        processHierarchy(hierarchy);
-        // Log the number of items in each lookup map
-        log('info', 'Lookup maps populated', {
-            spaces: workspaceCache.spaceIdsByName.size,
-            folders: workspaceCache.folderIdsByName.size,
-            lists: workspaceCache.listIdsByName.size
-        });
-        // Cache tasks for each list
-        log('info', 'Beginning task caching process for all lists...');
-        // Function to find all list IDs in the hierarchy
-        const getAllListIds = (node) => {
-            let listIds = [];
-            if (node.type === 'list') {
-                listIds.push(node.id);
-            }
-            if (node.children && node.children.length > 0) {
-                node.children.forEach(child => {
-                    listIds = [...listIds, ...getAllListIds(child)];
-                });
-            }
-            return listIds;
-        };
-        // Get all list IDs from all spaces
-        const listIds = [];
-        hierarchy.root.children.forEach(spaceNode => {
-            listIds.push(...getAllListIds(spaceNode));
-        });
-        log('info', `Found ${listIds.length} lists to cache tasks from`);
-        // Cache tasks for each list (sequentially to avoid rate limiting)
-        let completedLists = 0;
-        let totalTasksCached = 0;
-        for (const listId of listIds) {
-            // Get list name if available
-            const listName = getListNameById(listId, hierarchy);
-            log('debug', `Processing list ${completedLists + 1}/${listIds.length}: ${listName || listId}`);
-            // Get task count before caching
-            const taskCountBefore = workspaceCache.tasksById.size;
-            await cacheTasksForList(listId);
-            // Calculate how many tasks were added
-            const taskCountAfter = workspaceCache.tasksById.size;
-            const tasksAdded = taskCountAfter - taskCountBefore;
-            totalTasksCached += tasksAdded;
-            completedLists++;
-            // Log progress every 5 lists or for the last list
-            if (completedLists % 5 === 0 || completedLists === listIds.length) {
-                log('info', `Cache progress: ${completedLists}/${listIds.length} lists processed (${Math.round(completedLists / listIds.length * 100)}%)`, {
-                    totalTasksCached,
-                    completedLists,
-                    remainingLists: listIds.length - completedLists
-                });
-            }
-            // Small delay to avoid rate limiting
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        // Mark cache as initialized
-        workspaceCache.initialized = true;
-        workspaceCache.lastUpdated = new Date();
-        // Log final cache stats
-        const cacheStats = getCacheStats();
-        log('info', `Workspace cache initialized successfully`, cacheStats);
-    }
-    catch (error) {
-        log('error', 'Error initializing workspace cache:', error);
-        // Reset cache on error
-        workspaceCache = null;
-        // Re-throw error
-        throw error;
-    }
-}
-/**
- * Helper function to count items in the hierarchy
- */
-function countHierarchyItems(hierarchy) {
-    let spaces = 0;
-    let folders = 0;
-    let lists = 0;
-    const countNode = (node) => {
-        switch (node.type) {
-            case 'space':
-                spaces++;
-                break;
-            case 'folder':
-                folders++;
-                break;
-            case 'list':
-                lists++;
-                break;
-        }
-        if (node.children && node.children.length > 0) {
-            node.children.forEach(countNode);
-        }
-    };
-    // Count all spaces (children of root)
-    hierarchy.root.children.forEach(countNode);
-    return { spaces, folders, lists };
-}
-/**
- * Helper function to get list name by ID
- */
-function getListNameById(listId, hierarchy) {
-    let result = null;
-    const findListName = (node) => {
-        if (node.type === 'list' && node.id === listId) {
-            result = node.name;
-            return true;
-        }
-        if (node.children) {
-            for (const child of node.children) {
-                if (findListName(child)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-    hierarchy.root.children.forEach(findListName);
-    return result;
-}
-/**
- * Check if the cache is initialized
- */
-export function isCacheInitialized() {
-    return !!(workspaceCache && workspaceCache.initialized);
-}
-/**
- * Get the workspace hierarchy from cache
- */
-export function getCachedHierarchy() {
-    return workspaceCache?.hierarchy || null;
-}
-/**
- * Find an entity ID by name from the cache
- */
-export function findIDByNameInCache(name, type) {
-    if (!workspaceCache || !workspaceCache.initialized) {
-        return null;
-    }
-    const normalizedName = normalizeName(name);
-    switch (type) {
-        case 'space':
-            return workspaceCache.spaceIdsByName.get(normalizedName) || null;
-        case 'folder':
-            return workspaceCache.folderIdsByName.get(normalizedName) || null;
-        case 'list':
-            return workspaceCache.listIdsByName.get(normalizedName) || null;
-        default:
-            return null;
-    }
-}
-/**
- * Find a task ID by name and list ID from the cache
- */
-export function findTaskIDByName(taskName, listId) {
-    if (!workspaceCache || !workspaceCache.initialized) {
-        return null;
-    }
-    const nameKey = getTaskNameKey(listId, taskName);
-    return workspaceCache.tasksByName.get(nameKey) || null;
-}
-/**
- * Get a task by ID from the cache
- */
-export function getTaskFromCache(taskId) {
-    if (!workspaceCache || !workspaceCache.initialized) {
-        return null;
-    }
-    return workspaceCache.tasksById.get(taskId) || null;
-}
-/**
- * Add a new task to the cache
- */
-export function addTaskToCache(task) {
-    if (!workspaceCache || !workspaceCache.initialized) {
-        return;
-    }
-    cacheTask(task);
-    workspaceCache.lastUpdated = new Date();
-}
-/**
- * Remove a task from the cache
- */
-export function removeTaskFromCache(taskId) {
-    if (!workspaceCache || !workspaceCache.initialized) {
-        return;
-    }
-    removeCachedTask(taskId);
-    workspaceCache.lastUpdated = new Date();
-}
-/**
- * Update a task in the cache
- */
-export function updateTaskInCache(taskId, updates) {
-    if (!workspaceCache || !workspaceCache.initialized) {
-        return;
-    }
-    updateCachedTask(taskId, updates);
-}
-/**
- * Refresh the tasks for a specific list in the cache
- */
-export async function refreshListTasksInCache(listId) {
-    if (!workspaceCache || !workspaceCache.initialized) {
-        return;
-    }
-    // Remove existing tasks for this list
-    const tasksToRemove = [];
-    workspaceCache.tasksById.forEach((task, id) => {
-        if (task.listId === listId) {
-            tasksToRemove.push(id);
-        }
-    });
-    tasksToRemove.forEach(taskId => {
-        removeCachedTask(taskId);
-    });
-    // Cache tasks for the list
-    await cacheTasksForList(listId);
-}
-/**
- * Refresh the entire workspace cache
- */
-export async function refreshCache() {
-    // Reset cache
-    workspaceCache = null;
-    // Re-initialize
-    await initializeCache();
-}
-/**
- * Get cache statistics for monitoring
- */
-export function getCacheStats() {
-    if (!workspaceCache) {
-        return {
-            initialized: false,
-            tasksCount: 0,
-            listsCount: 0,
-            foldersCount: 0,
-            spacesCount: 0,
-            lastUpdated: null
-        };
-    }
-    return {
-        initialized: workspaceCache.initialized,
-        tasksCount: workspaceCache.tasksById.size,
-        listsCount: workspaceCache.listIdsByName.size,
-        foldersCount: workspaceCache.folderIdsByName.size,
-        spacesCount: workspaceCache.spaceIdsByName.size,
-        lastUpdated: workspaceCache.lastUpdated
-    };
-}