@taazkareem/clickup-mcp-server 0.8.4 → 0.9.0

package/build/services/clickup/task/task-search.js

@@ -9,14 +9,22 @@
  * - Global workspace task lookup
  * - Task summaries and detailed task data
  */
-import { TaskServiceCore } from './task-core.js';
 import { isNameMatch } from '../../../utils/resolver-utils.js';
 import { findListIDByName } from '../../../tools/list.js';
 import { estimateTokensFromObject, wouldExceedTokenLimit } from '../../../utils/token-utils.js';
 /**
  * Search functionality for the TaskService
+ *
+ * This service handles all search and lookup operations for ClickUp tasks.
+ * It uses composition to access core functionality instead of inheritance.
+ *
+ * REFACTORED: Now uses composition instead of inheritance.
+ * Only depends on TaskServiceCore for base functionality.
  */
-export class TaskServiceSearch extends TaskServiceCore {
+export class TaskServiceSearch {
+    constructor(core) {
+        this.core = core;
+    }
     /**
      * Find a task by name within a specific list
      * @param listId The ID of the list to search in
@@ -24,13 +32,13 @@ export class TaskServiceSearch extends TaskServiceCore {
      * @returns The task if found, otherwise null
      */
     async findTaskByName(listId, taskName) {
-        this.logOperation('findTaskByName', { listId, taskName });
+        this.core.logOperation('findTaskByName', { listId, taskName });
         try {
-            const tasks = await this.getTasks(listId);
+            const tasks = await this.core.getTasks(listId);
             return this.findTaskInArray(tasks, taskName);
         }
         catch (error) {
-            throw this.handleError(error, `Failed to find task by name: ${error instanceof Error ? error.message : String(error)}`);
+            throw this.core.handleError(error, `Failed to find task by name: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
@@ -102,7 +110,7 @@ export class TaskServiceSearch extends TaskServiceCore {
             },
             due_date: task.due_date,
             url: task.url,
-            priority: this.extractPriorityValue(task),
+            priority: this.core.extractPriorityValue(task),
             tags: task.tags.map(tag => ({
                 name: tag.name,
                 tag_bg: tag.tag_bg,
@@ -125,10 +133,10 @@ export class TaskServiceSearch extends TaskServiceCore {
      */
     async getWorkspaceTasks(filters = {}) {
         try {
-            this.logOperation('getWorkspaceTasks', { filters });
-            const params = this.buildTaskFilterParams(filters);
-            const response = await this.makeRequest(async () => {
-                return await this.client.get(`/team/${this.teamId}/task`, {
+            this.core.logOperation('getWorkspaceTasks', { filters });
+            const params = this.core.buildTaskFilterParams(filters);
+            const response = await this.core.makeRequest(async () => {
+                return await this.core.client.get(`/team/${this.core.teamId}/task`, {
                     params
                 });
             });
@@ -147,7 +155,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 // First check with a sample task - if one task exceeds the limit, we definitely need summary
                 const sampleTask = tasks[0];
                 // Check if all tasks would exceed the token limit
-                const estimatedTokensPerTask = this.estimateTaskTokens(sampleTask);
+                const estimatedTokensPerTask = this.core.estimateTaskTokens(sampleTask);
                 const estimatedTotalTokens = estimatedTokensPerTask * tasks.length;
                 // Add 10% overhead for the response wrapper
                 tokensExceedLimit = estimatedTotalTokens * 1.1 > TOKEN_LIMIT;
@@ -159,15 +167,15 @@ export class TaskServiceSearch extends TaskServiceCore {
             }
             // Determine if we should return summary or detailed based on request and token limit
             const shouldUseSummary = filters.detail_level === 'summary' || tokensExceedLimit;
-            this.logOperation('getWorkspaceTasks', {
+            this.core.logOperation('getWorkspaceTasks', {
                 totalTasks: tasks.length,
-                estimatedTokens: tasks.reduce((count, task) => count + this.estimateTaskTokens(task), 0),
+                estimatedTokens: tasks.reduce((count, task) => count + this.core.estimateTaskTokens(task), 0),
                 usingDetailedFormat: !shouldUseSummary,
                 requestedFormat: filters.detail_level || 'auto'
             });
             if (shouldUseSummary) {
                 return {
-                    summaries: tasks.map(task => this.formatTaskSummary(task)),
+                    summaries: tasks.map(task => this.core.formatTaskSummary(task)),
                     total_count: totalCount,
                     has_more: hasMore,
                     next_page: nextPage
@@ -181,8 +189,8 @@ export class TaskServiceSearch extends TaskServiceCore {
             };
         }
         catch (error) {
-            this.logOperation('getWorkspaceTasks', { error: error.message, status: error.response?.status });
-            throw this.handleError(error, 'Failed to get workspace tasks');
+            this.core.logOperation('getWorkspaceTasks', { error: error.message, status: error.response?.status });
+            throw this.core.handleError(error, 'Failed to get workspace tasks');
         }
     }
     /**
@@ -200,13 +208,13 @@ export class TaskServiceSearch extends TaskServiceCore {
      */
     async getListViews(listId) {
         try {
-            this.logOperation('getListViews', { listId });
-            const response = await this.makeRequest(async () => {
-                return await this.client.get(`/list/${listId}/view`);
+            this.core.logOperation('getListViews', { listId });
+            const response = await this.core.makeRequest(async () => {
+                return await this.core.client.get(`/list/${listId}/view`);
             });
             // First try to get the default list view from required_views.list
             if (response.data.required_views?.list?.id) {
-                this.logOperation('getListViews', {
+                this.core.logOperation('getListViews', {
                     listId,
                     foundDefaultView: response.data.required_views.list.id,
                     source: 'required_views.list'
@@ -217,7 +225,7 @@ export class TaskServiceSearch extends TaskServiceCore {
             const listView = response.data.views?.find(view => view.type?.toLowerCase() === 'list' ||
                 view.name?.toLowerCase().includes('list'));
             if (listView?.id) {
-                this.logOperation('getListViews', {
+                this.core.logOperation('getListViews', {
                     listId,
                     foundDefaultView: listView.id,
                     source: 'views_array_fallback',
@@ -228,7 +236,7 @@ export class TaskServiceSearch extends TaskServiceCore {
             // If no specific list view found, use the first available view
             if (response.data.views?.length > 0) {
                 const firstView = response.data.views[0];
-                this.logOperation('getListViews', {
+                this.core.logOperation('getListViews', {
                     listId,
                     foundDefaultView: firstView.id,
                     source: 'first_available_view',
@@ -237,7 +245,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 });
                 return firstView.id;
             }
-            this.logOperation('getListViews', {
+            this.core.logOperation('getListViews', {
                 listId,
                 error: 'No views found for list',
                 responseData: response.data
@@ -245,12 +253,12 @@ export class TaskServiceSearch extends TaskServiceCore {
             return null;
         }
         catch (error) {
-            this.logOperation('getListViews', {
+            this.core.logOperation('getListViews', {
                 listId,
                 error: error.message,
                 status: error.response?.status
             });
-            throw this.handleError(error, `Failed to get views for list ${listId}`);
+            throw this.core.handleError(error, `Failed to get views for list ${listId}`);
         }
     }
     /**
@@ -261,7 +269,7 @@ export class TaskServiceSearch extends TaskServiceCore {
      */
     async getTasksFromView(viewId, filters = {}) {
         try {
-            this.logOperation('getTasksFromView', { viewId, filters });
+            this.core.logOperation('getTasksFromView', { viewId, filters });
             // Build query parameters for supported filters
             const params = {};
             // Map supported filters to query parameters
@@ -309,8 +317,8 @@ export class TaskServiceSearch extends TaskServiceCore {
             let pageCount = 0;
             while (hasMore && pageCount < maxPages) {
                 const pageParams = { ...params, page: currentPage };
-                const response = await this.makeRequest(async () => {
-                    return await this.client.get(`/view/${viewId}/task`, {
+                const response = await this.core.makeRequest(async () => {
+                    return await this.core.client.get(`/view/${viewId}/task`, {
                         params: pageParams
                     });
                 });
@@ -320,7 +328,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 hasMore = response.data.has_more === true && tasks.length > 0;
                 currentPage++;
                 pageCount++;
-                this.logOperation('getTasksFromView', {
+                this.core.logOperation('getTasksFromView', {
                     viewId,
                     page: currentPage - 1,
                     tasksInPage: tasks.length,
@@ -334,13 +342,13 @@ export class TaskServiceSearch extends TaskServiceCore {
                 }
             }
             if (pageCount >= maxPages) {
-                this.logOperation('getTasksFromView', {
+                this.core.logOperation('getTasksFromView', {
                     viewId,
                     warning: `Reached maximum page limit (${maxPages}) while fetching tasks`,
                     totalTasks: allTasks.length
                 });
             }
-            this.logOperation('getTasksFromView', {
+            this.core.logOperation('getTasksFromView', {
                 viewId,
                 totalTasks: allTasks.length,
                 totalPages: pageCount
@@ -348,12 +356,12 @@ export class TaskServiceSearch extends TaskServiceCore {
             return allTasks;
         }
         catch (error) {
-            this.logOperation('getTasksFromView', {
+            this.core.logOperation('getTasksFromView', {
                 viewId,
                 error: error.message,
                 status: error.response?.status
             });
-            throw this.handleError(error, `Failed to get tasks from view ${viewId}`);
+            throw this.core.handleError(error, `Failed to get tasks from view ${viewId}`);
         }
     }
     /**
@@ -388,7 +396,7 @@ export class TaskServiceSearch extends TaskServiceCore {
      */
     async findTasks({ taskId, customTaskId, taskName, listId, listName, allowMultipleMatches = false, useSmartDisambiguation = true, includeFullDetails = true, includeListContext = false, requireExactMatch = false }) {
         try {
-            this.logOperation('findTasks', {
+            this.core.logOperation('findTasks', {
                 taskId,
                 customTaskId,
                 taskName,
@@ -403,15 +411,15 @@ export class TaskServiceSearch extends TaskServiceCore {
                 // Resolve list ID if we have a list name
                 let resolvedListId = listId;
                 if (listName && !listId) {
-                    const listInfo = await findListIDByName(this.workspaceService, listName);
+                    const listInfo = await findListIDByName(this.core.workspaceService, listName);
                     if (listInfo) {
                         resolvedListId = listInfo.id;
                     }
                 }
                 // Try to get cached task ID
-                const cachedTaskId = this.getCachedTaskId(taskName, resolvedListId);
+                const cachedTaskId = this.core.getCachedTaskId(taskName, resolvedListId);
                 if (cachedTaskId) {
-                    this.logOperation('findTasks', {
+                    this.core.logOperation('findTasks', {
                         message: 'Using cached task ID for name lookup',
                         taskName,
                         cachedTaskId
@@ -423,7 +431,7 @@ export class TaskServiceSearch extends TaskServiceCore {
             if (taskId) {
                 // Check if it looks like a custom ID
                 if (taskId.includes('-') && /^[A-Z]+\-\d+$/.test(taskId)) {
-                    this.logOperation('findTasks', { detectedCustomId: taskId });
+                    this.core.logOperation('findTasks', { detectedCustomId: taskId });
                     try {
                         // Try to get it as a custom ID first
                         let resolvedListId;
@@ -431,25 +439,25 @@ export class TaskServiceSearch extends TaskServiceCore {
                             resolvedListId = listId;
                         }
                         else if (listName) {
-                            const listInfo = await findListIDByName(this.workspaceService, listName);
+                            const listInfo = await findListIDByName(this.core.workspaceService, listName);
                             if (listInfo) {
                                 resolvedListId = listInfo.id;
                             }
                         }
-                        const foundTask = await this.getTaskByCustomId(taskId, resolvedListId);
+                        const foundTask = await this.core.getTaskByCustomId(taskId, resolvedListId);
                         return foundTask;
                     }
                     catch (error) {
                         // If it fails as a custom ID, try as a regular ID
-                        this.logOperation('findTasks', {
+                        this.core.logOperation('findTasks', {
                             message: `Failed to find task with custom ID "${taskId}", falling back to regular ID`,
                             error: error.message
                         });
-                        return await this.getTask(taskId);
+                        return await this.core.getTask(taskId);
                     }
                 }
                 // Regular task ID
-                return await this.getTask(taskId);
+                return await this.core.getTask(taskId);
             }
             // Case 2: Explicit custom task ID lookup
             if (customTaskId) {
@@ -458,12 +466,12 @@ export class TaskServiceSearch extends TaskServiceCore {
                     resolvedListId = listId;
                 }
                 else if (listName) {
-                    const listInfo = await findListIDByName(this.workspaceService, listName);
+                    const listInfo = await findListIDByName(this.core.workspaceService, listName);
                     if (listInfo) {
                         resolvedListId = listInfo.id;
                     }
                 }
-                return await this.getTaskByCustomId(customTaskId, resolvedListId);
+                return await this.core.getTaskByCustomId(customTaskId, resolvedListId);
             }
             // Case 3: Task name lookup (requires either list context or global lookup)
             if (taskName) {
@@ -474,28 +482,28 @@ export class TaskServiceSearch extends TaskServiceCore {
                         resolvedListId = listId;
                     }
                     else {
-                        const listInfo = await findListIDByName(this.workspaceService, listName);
+                        const listInfo = await findListIDByName(this.core.workspaceService, listName);
                         if (!listInfo) {
                             throw new Error(`List "${listName}" not found`);
                         }
                         resolvedListId = listInfo.id;
                     }
-                    const foundTask = this.findTaskInArray(await this.getTasks(resolvedListId), taskName, includeListContext);
+                    const foundTask = this.core.findTaskInArray(await this.core.getTasks(resolvedListId), taskName, includeListContext);
                     if (!foundTask) {
                         throw new Error(`Task "${taskName}" not found in list`);
                     }
                     // Cache the task name to ID mapping with list context
-                    this.cacheTaskNameToId(taskName, foundTask.id, resolvedListId);
+                    this.core.cacheTaskNameToId(taskName, foundTask.id, resolvedListId);
                     // If includeFullDetails is true and we need context not already in the task,
                     // get full details, otherwise return what we already have
                     if (includeFullDetails && (!foundTask.list || !foundTask.list.name || !foundTask.status)) {
-                        return await this.getTask(foundTask.id);
+                        return await this.core.getTask(foundTask.id);
                     }
                     return foundTask;
                 }
                 // Case 3b: Task name without list context - global lookup across workspace
                 // Get lightweight task summaries for efficient first-pass filtering
-                this.logOperation('findTasks', {
+                this.core.logOperation('findTasks', {
                     message: `Starting global task search for "${taskName}"`,
                     includeFullDetails,
                     useSmartDisambiguation,
@@ -509,11 +517,11 @@ export class TaskServiceSearch extends TaskServiceCore {
                     include_closed_lists: true,
                     subtasks: true
                 });
-                if (!this.workspaceService) {
+                if (!this.core.workspaceService) {
                     throw new Error("Workspace service required for global task lookup");
                 }
                 // Create an index to efficiently look up list context information
-                const hierarchy = await this.workspaceService.getWorkspaceHierarchy();
+                const hierarchy = await this.core.workspaceService.getWorkspaceHierarchy();
                 const listContextMap = new Map();
                 // Function to recursively build list context map
                 function buildListContextMap(nodes, spaceId, spaceName, folderId, folderName) {
@@ -551,7 +559,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 let taskCount = 0;
                 let matchesFound = 0;
                 // Add additional logging to debug task matching
-                this.logOperation('findTasks', {
+                this.core.logOperation('findTasks', {
                     total_tasks_in_response: response.summaries.length,
                     search_term: taskName,
                     requireExactMatch
@@ -564,7 +572,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                     // For debugging, log every 20th task or any task with a similar name
                     if (taskCount % 20 === 0 || taskSummary.name.toLowerCase().includes(taskName.toLowerCase()) ||
                         taskName.toLowerCase().includes(taskSummary.name.toLowerCase())) {
-                        this.logOperation('findTasks:matching', {
+                        this.core.logOperation('findTasks:matching', {
                             task_name: taskSummary.name,
                             search_term: taskName,
                             list_name: taskSummary.list?.name || 'Unknown list',
@@ -589,7 +597,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                         }
                     }
                 }
-                this.logOperation('findTasks', {
+                this.core.logOperation('findTasks', {
                     globalSearch: true,
                     searchTerm: taskName,
                     tasksSearched: taskCount,
@@ -641,7 +649,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                     // If there's a single best match with score 80+, use it directly
                     const exactMatches = initialMatches.filter(m => m.matchScore >= 80);
                     if (exactMatches.length === 1 && !allowMultipleMatches) {
-                        this.logOperation('findTasks', {
+                        this.core.logOperation('findTasks', {
                             message: `Found single exact match with score ${exactMatches[0].matchScore}, prioritizing over other matches`,
                             matchReason: exactMatches[0].matchReason
                         });
@@ -668,7 +676,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                             return match.task;
                         }
                         // Otherwise, get the full details
-                        const fullTask = await this.getTask(exactMatches[0].id);
+                        const fullTask = await this.core.getTask(exactMatches[0].id);
                         if (includeListContext) {
                             const match = exactMatches[0];
                             // Enhance task with context information
@@ -696,7 +704,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 try {
                     // Process in sequence for better reliability
                     for (const match of initialMatches) {
-                        const fullTask = await this.getTask(match.id);
+                        const fullTask = await this.core.getTask(match.id);
                         matchScoreMap.set(fullTask.id, match.matchScore);
                         if (includeListContext) {
                             // Enhance task with context information
@@ -734,7 +742,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                     }
                 }
                 catch (error) {
-                    this.logOperation('findTasks', {
+                    this.core.logOperation('findTasks', {
                         error: error.message,
                         message: "Failed to get detailed task information"
                     });
@@ -780,7 +788,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 // After finding the task in global search, cache the mapping
                 if (initialMatches.length === 1 || useSmartDisambiguation) {
                     const bestMatch = fullMatches[0];
-                    this.cacheTaskNameToId(taskName, bestMatch.id, bestMatch.list?.id);
+                    this.core.cacheTaskNameToId(taskName, bestMatch.id, bestMatch.list?.id);
                     return bestMatch;
                 }
                 // Return results based on options
@@ -822,7 +830,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 throw error;
             }
             // Unexpected errors
-            throw this.handleError(error, `Error finding task: ${error.message}`);
+            throw this.core.handleError(error, `Error finding task: ${error.message}`);
         }
     }
     /**
@@ -833,16 +841,16 @@ export class TaskServiceSearch extends TaskServiceCore {
      * @returns The updated task
      */
     async updateTaskByName(listId, taskName, updateData) {
-        this.logOperation('updateTaskByName', { listId, taskName, ...updateData });
+        this.core.logOperation('updateTaskByName', { listId, taskName, ...updateData });
         try {
             const task = await this.findTaskByName(listId, taskName);
             if (!task) {
                 throw new Error(`Task "${taskName}" not found in list ${listId}`);
             }
-            return await this.updateTask(task.id, updateData);
+            return await this.core.updateTask(task.id, updateData);
         }
         catch (error) {
-            throw this.handleError(error, `Failed to update task by name: ${error instanceof Error ? error.message : String(error)}`);
+            throw this.core.handleError(error, `Failed to update task by name: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
@@ -854,7 +862,7 @@ export class TaskServiceSearch extends TaskServiceCore {
      * @returns The best matching task or null if no match found
      */
     async findTaskByNameGlobally(taskName) {
-        this.logOperation('findTaskByNameGlobally', { taskName });
+        this.core.logOperation('findTaskByNameGlobally', { taskName });
         // Use a static cache for task data to avoid redundant API calls
         // This dramatically reduces API usage across multiple task lookups
         if (!this.constructor.hasOwnProperty('_taskCache')) {
@@ -873,7 +881,7 @@ export class TaskServiceSearch extends TaskServiceCore {
             // Use cached tasks if available and not expired
             let tasks = [];
             if (cache.tasks.length > 0 && (now - cache.lastFetch) < cache.cacheTTL) {
-                this.logOperation('findTaskByNameGlobally', {
+                this.core.logOperation('findTaskByNameGlobally', {
                     usedCache: true,
                     cacheAge: now - cache.lastFetch,
                     taskCount: cache.tasks.length
@@ -890,7 +898,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                 // Update cache
                 cache.tasks = tasks;
                 cache.lastFetch = now;
-                this.logOperation('findTaskByNameGlobally', {
+                this.core.logOperation('findTaskByNameGlobally', {
                     usedCache: false,
                     fetchedTaskCount: tasks.length
                 });
@@ -904,7 +912,7 @@ export class TaskServiceSearch extends TaskServiceCore {
                     updatedAt: task.date_updated ? parseInt(task.date_updated, 10) : 0
                 };
             }).filter(result => result.matchResult.isMatch);
-            this.logOperation('findTaskByNameGlobally', {
+            this.core.logOperation('findTaskByNameGlobally', {
                 taskCount: tasks.length,
                 matchCount: taskMatches.length,
                 taskName
@@ -939,15 +947,15 @@ export class TaskServiceSearch extends TaskServiceCore {
                 updatedAt: match.updatedAt,
                 list: match.task.list?.name || 'Unknown list'
             }));
-            this.logOperation('findTaskByNameGlobally', { topMatches });
+            this.core.logOperation('findTaskByNameGlobally', { topMatches });
             // Return the best match
             return bestMatches[0].task;
         }
         catch (error) {
-            this.logOperation('findTaskByNameGlobally', { error: error.message });
+            this.core.logOperation('findTaskByNameGlobally', { error: error.message });
             // If there's an error (like rate limit), try to use cached data even if expired
             if (cache.tasks.length > 0) {
-                this.logOperation('findTaskByNameGlobally', {
+                this.core.logOperation('findTaskByNameGlobally', {
                     message: 'Using expired cache due to API error',
                     cacheAge: now - cache.lastFetch
                 });

package/build/services/clickup/task/task-service.js

@@ -4,22 +4,101 @@
  *
  * ClickUp Task Service
  *
- * Main entry point for the ClickUp Task Service.
- * Combines all task-related functionality through inheritance:
- * - Core operations (CRUD)
- * - Search capabilities
- * - File attachments
- * - Comments
- * - Tags
- * - Custom fields
+ * Complete task service combining all task-related functionality
+ *
+ * REFACTORED: Now uses composition instead of linear inheritance.
+ * Extends TaskServiceCore and composes other services as properties.
  */
+import { TaskServiceCore } from './task-core.js';
+import { TaskServiceSearch } from './task-search.js';
+import { TaskServiceAttachments } from './task-attachments.js';
+import { TaskServiceComments } from './task-comments.js';
+import { TaskServiceTags } from './task-tags.js';
 import { TaskServiceCustomFields } from './task-custom-fields.js';
 /**
  * Complete TaskService combining all task-related functionality
+ *
+ * This service uses composition to provide access to all task operations
+ * while maintaining clean separation of concerns and eliminating artificial
+ * dependencies between service modules.
  */
-export class TaskService extends TaskServiceCustomFields {
+export class TaskService extends TaskServiceCore {
     constructor(apiKey, teamId, baseUrl, workspaceService) {
         super(apiKey, teamId, baseUrl, workspaceService);
         this.logOperation('constructor', { initialized: true });
+        // Initialize composed services with core as dependency
+        this.search = new TaskServiceSearch(this);
+        this.attachments = new TaskServiceAttachments(this);
+        this.comments = new TaskServiceComments(this);
+        this.tags = new TaskServiceTags(this);
+        this.customFields = new TaskServiceCustomFields(this);
+    }
+    // ===== DELEGATED SEARCH METHODS =====
+    async findTaskByName(listId, taskName) {
+        return this.search.findTaskByName(listId, taskName);
+    }
+    async getWorkspaceTasks(filters = {}) {
+        return this.search.getWorkspaceTasks(filters);
+    }
+    async getTaskSummaries(filters = {}) {
+        return this.search.getTaskSummaries(filters);
+    }
+    async getListViews(listId) {
+        return this.search.getListViews(listId);
+    }
+    async getTasksFromView(viewId, filters = {}) {
+        return this.search.getTasksFromView(viewId, filters);
+    }
+    async getTaskDetails(filters = {}) {
+        return this.search.getTaskDetails(filters);
+    }
+    async updateTaskByName(listId, taskName, updateData) {
+        return this.search.updateTaskByName(listId, taskName, updateData);
+    }
+    async findTaskByNameGlobally(taskName) {
+        return this.search.findTaskByNameGlobally(taskName);
+    }
+    async findTasks(params) {
+        return this.search.findTasks(params);
+    }
+    // ===== DELEGATED ATTACHMENT METHODS =====
+    async uploadTaskAttachment(taskId, fileData, fileName) {
+        return this.attachments.uploadTaskAttachment(taskId, fileData, fileName);
+    }
+    async uploadTaskAttachmentFromUrl(taskId, fileUrl, fileName, authHeader) {
+        return this.attachments.uploadTaskAttachmentFromUrl(taskId, fileUrl, fileName, authHeader);
+    }
+    // ===== DELEGATED COMMENT METHODS =====
+    async getTaskComments(taskId, start, startId) {
+        return this.comments.getTaskComments(taskId, start, startId);
+    }
+    async createTaskComment(taskId, commentText, notifyAll, assignee) {
+        return this.comments.createTaskComment(taskId, commentText, notifyAll, assignee);
+    }
+    // ===== DELEGATED TAG METHODS =====
+    async addTagToTask(taskId, tagName) {
+        return this.tags.addTagToTask(taskId, tagName);
+    }
+    async removeTagFromTask(taskId, tagName) {
+        return this.tags.removeTagFromTask(taskId, tagName);
+    }
+    async getTaskTags(taskId) {
+        return this.tags.getTaskTags(taskId);
+    }
+    async updateTaskTags(taskId, tagNames) {
+        return this.tags.updateTaskTags(taskId, tagNames);
+    }
+    // ===== DELEGATED CUSTOM FIELD METHODS =====
+    async setCustomFieldValue(taskId, fieldId, value) {
+        return this.customFields.setCustomFieldValue(taskId, fieldId, value);
+    }
+    async setCustomFieldValues(taskId, customFields) {
+        return this.customFields.setCustomFieldValues(taskId, customFields);
+    }
+    async getCustomFieldValues(taskId) {
+        return this.customFields.getCustomFieldValues(taskId);
+    }
+    async getCustomFieldValue(taskId, fieldId) {
+        return this.customFields.getCustomFieldValue(taskId, fieldId);
     }
 }