kynjal-cli 4.0.0 → 4.0.1

package/dist/src/mcp-tools/task-tools.js

@@ -3,57 +3,12 @@
  *
  * Tool definitions for task management with file persistence.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-var STORAGE_DIR = '.claude-flow';
-var TASK_DIR = 'tasks';
-var TASK_FILE = 'store.json';
+const STORAGE_DIR = '.claude-flow';
+const TASK_DIR = 'tasks';
+const TASK_FILE = 'store.json';
 function getTaskDir() {
     return join(process.cwd(), STORAGE_DIR, TASK_DIR);
 }
@@ -61,20 +16,20 @@ function getTaskPath() {
     return join(getTaskDir(), TASK_FILE);
 }
 function ensureTaskDir() {
-    var dir = getTaskDir();
+    const dir = getTaskDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadTaskStore() {
     try {
-        var path = getTaskPath();
+        const path = getTaskPath();
         if (existsSync(path)) {
-            var data = readFileSync(path, 'utf-8');
+            const data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
         }
     }
-    catch (_a) {
+    catch {
         // Return empty store on error
     }
     return { tasks: {}, version: '3.0.0' };
@@ -83,7 +38,7 @@ function saveTaskStore(store) {
     ensureTaskDir();
     writeFileSync(getTaskPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export var taskTools = [
+export const taskTools = [
     {
         name: 'task_create',
         description: 'Create a new task',
@@ -95,42 +50,39 @@ export var taskTools = [
                 description: { type: 'string', description: 'Task description' },
                 priority: { type: 'string', description: 'Task priority (low, normal, high, critical)' },
                 assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-                tags: { type: 'array', items: { type: 'string' }, description: 'Task tags' }
+                tags: { type: 'array', items: { type: 'string' }, description: 'Task tags' },
             },
-            required: ['type', 'description']
+            required: ['type', 'description'],
+        },
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const task = {
+                taskId,
+                type: input.type,
+                description: input.description,
+                priority: input.priority || 'normal',
+                status: 'pending',
+                progress: 0,
+                assignedTo: input.assignTo || [],
+                tags: input.tags || [],
+                createdAt: new Date().toISOString(),
+                startedAt: null,
+                completedAt: null,
+            };
+            store.tasks[taskId] = task;
+            saveTaskStore(store);
+            return {
+                taskId,
+                type: task.type,
+                description: task.description,
+                priority: task.priority,
+                status: task.status,
+                createdAt: task.createdAt,
+                assignedTo: task.assignedTo,
+                tags: task.tags,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, taskId, task;
-            return __generator(this, function (_a) {
-                store = loadTaskStore();
-                taskId = "task-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
-                task = {
-                    taskId: taskId,
-                    type: input.type,
-                    description: input.description,
-                    priority: input.priority || 'normal',
-                    status: 'pending',
-                    progress: 0,
-                    assignedTo: input.assignTo || [],
-                    tags: input.tags || [],
-                    createdAt: new Date().toISOString(),
-                    startedAt: null,
-                    completedAt: null
-                };
-                store.tasks[taskId] = task;
-                saveTaskStore(store);
-                return [2 /*return*/, {
-                        taskId: taskId,
-                        type: task.type,
-                        description: task.description,
-                        priority: task.priority,
-                        status: task.status,
-                        createdAt: task.createdAt,
-                        assignedTo: task.assignedTo,
-                        tags: task.tags
-                    }];
-            });
-        }); }
     },
     {
         name: 'task_status',
@@ -139,38 +91,35 @@ export var taskTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                taskId: { type: 'string', description: 'Task ID' }
+                taskId: { type: 'string', description: 'Task ID' },
             },
-            required: ['taskId']
+            required: ['taskId'],
+        },
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = input.taskId;
+            const task = store.tasks[taskId];
+            if (task) {
+                return {
+                    taskId: task.taskId,
+                    type: task.type,
+                    description: task.description,
+                    status: task.status,
+                    progress: task.progress,
+                    priority: task.priority,
+                    assignedTo: task.assignedTo,
+                    tags: task.tags,
+                    createdAt: task.createdAt,
+                    startedAt: task.startedAt,
+                    completedAt: task.completedAt,
+                };
+            }
+            return {
+                taskId,
+                status: 'not_found',
+                error: 'Task not found',
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, taskId, task;
-            return __generator(this, function (_a) {
-                store = loadTaskStore();
-                taskId = input.taskId;
-                task = store.tasks[taskId];
-                if (task) {
-                    return [2 /*return*/, {
-                            taskId: task.taskId,
-                            type: task.type,
-                            description: task.description,
-                            status: task.status,
-                            progress: task.progress,
-                            priority: task.priority,
-                            assignedTo: task.assignedTo,
-                            tags: task.tags,
-                            createdAt: task.createdAt,
-                            startedAt: task.startedAt,
-                            completedAt: task.completedAt
-                        }];
-                }
-                return [2 /*return*/, {
-                        taskId: taskId,
-                        status: 'not_found',
-                        error: 'Task not found'
-                    }];
-            });
-        }); }
     },
     {
         name: 'task_list',
@@ -183,53 +132,52 @@ export var taskTools = [
                 type: { type: 'string', description: 'Filter by type' },
                 assignedTo: { type: 'string', description: 'Filter by assigned agent' },
                 priority: { type: 'string', description: 'Filter by priority' },
-                limit: { type: 'number', description: 'Max tasks to return' }
+                limit: { type: 'number', description: 'Max tasks to return' },
+            },
+        },
+        handler: async (input) => {
+            const store = loadTaskStore();
+            let tasks = Object.values(store.tasks);
+            // Apply filters
+            if (input.status) {
+                // Support comma-separated status values
+                const statuses = input.status.split(',').map(s => s.trim());
+                tasks = tasks.filter(t => statuses.includes(t.status));
+            }
+            if (input.type) {
+                tasks = tasks.filter(t => t.type === input.type);
             }
+            if (input.assignedTo) {
+                tasks = tasks.filter(t => t.assignedTo.includes(input.assignedTo));
+            }
+            if (input.priority) {
+                tasks = tasks.filter(t => t.priority === input.priority);
+            }
+            // Sort by creation date (newest first)
+            tasks.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+            // Apply limit
+            const limit = input.limit || 50;
+            tasks = tasks.slice(0, limit);
+            return {
+                tasks: tasks.map(t => ({
+                    taskId: t.taskId,
+                    type: t.type,
+                    description: t.description,
+                    status: t.status,
+                    progress: t.progress,
+                    priority: t.priority,
+                    assignedTo: t.assignedTo,
+                    createdAt: t.createdAt,
+                })),
+                total: tasks.length,
+                filters: {
+                    status: input.status,
+                    type: input.type,
+                    assignedTo: input.assignedTo,
+                    priority: input.priority,
+                },
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, tasks, statuses_1, limit;
-            return __generator(this, function (_a) {
-                store = loadTaskStore();
-                tasks = Object.values(store.tasks);
-                // Apply filters
-                if (input.status) {
-                    statuses_1 = input.status.split(',').map(function (s) { return s.trim(); });
-                    tasks = tasks.filter(function (t) { return statuses_1.includes(t.status); });
-                }
-                if (input.type) {
-                    tasks = tasks.filter(function (t) { return t.type === input.type; });
-                }
-                if (input.assignedTo) {
-                    tasks = tasks.filter(function (t) { return t.assignedTo.includes(input.assignedTo); });
-                }
-                if (input.priority) {
-                    tasks = tasks.filter(function (t) { return t.priority === input.priority; });
-                }
-                // Sort by creation date (newest first)
-                tasks.sort(function (a, b) { return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(); });
-                limit = input.limit || 50;
-                tasks = tasks.slice(0, limit);
-                return [2 /*return*/, {
-                        tasks: tasks.map(function (t) { return ({
-                            taskId: t.taskId,
-                            type: t.type,
-                            description: t.description,
-                            status: t.status,
-                            progress: t.progress,
-                            priority: t.priority,
-                            assignedTo: t.assignedTo,
-                            createdAt: t.createdAt
-                        }); }),
-                        total: tasks.length,
-                        filters: {
-                            status: input.status,
-                            type: input.type,
-                            assignedTo: input.assignedTo,
-                            priority: input.priority
-                        }
-                    }];
-            });
-        }); }
     },
     {
         name: 'task_complete',
@@ -239,59 +187,55 @@ export var taskTools = [
             type: 'object',
             properties: {
                 taskId: { type: 'string', description: 'Task ID' },
-                result: { type: 'object', description: 'Task result data' }
+                result: { type: 'object', description: 'Task result data' },
             },
-            required: ['taskId']
+            required: ['taskId'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, taskId, task, agentStorePath, agentStore, _i, _a, agentId;
-            return __generator(this, function (_b) {
-                store = loadTaskStore();
-                taskId = input.taskId;
-                task = store.tasks[taskId];
-                if (task) {
-                    task.status = 'completed';
-                    task.progress = 100;
-                    task.completedAt = new Date().toISOString();
-                    task.result = input.result || {};
-                    saveTaskStore(store);
-                    // Sync assigned agents back to idle and increment taskCount
-                    if (task.assignedTo.length > 0) {
-                        agentStorePath = join(process.cwd(), STORAGE_DIR, 'agents.json');
-                        try {
-                            agentStore = { agents: {} };
-                            if (existsSync(agentStorePath)) {
-                                agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
-                            }
-                            for (_i = 0, _a = task.assignedTo; _i < _a.length; _i++) {
-                                agentId = _a[_i];
-                                if (agentStore.agents[agentId]) {
-                                    agentStore.agents[agentId].status = 'idle';
-                                    agentStore.agents[agentId].currentTask = null;
-                                    agentStore.agents[agentId].taskCount =
-                                        (agentStore.agents[agentId].taskCount || 0) + 1;
-                                }
-                            }
-                            writeFileSync(agentStorePath, JSON.stringify(agentStore, null, 2), 'utf-8');
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = input.taskId;
+            const task = store.tasks[taskId];
+            if (task) {
+                task.status = 'completed';
+                task.progress = 100;
+                task.completedAt = new Date().toISOString();
+                task.result = input.result || {};
+                saveTaskStore(store);
+                // Sync assigned agents back to idle and increment taskCount
+                if (task.assignedTo.length > 0) {
+                    const agentStorePath = join(process.cwd(), STORAGE_DIR, 'agents.json');
+                    try {
+                        let agentStore = { agents: {} };
+                        if (existsSync(agentStorePath)) {
+                            agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
                         }
-                        catch (_c) {
-                            // Best-effort agent sync
+                        for (const agentId of task.assignedTo) {
+                            if (agentStore.agents[agentId]) {
+                                agentStore.agents[agentId].status = 'idle';
+                                agentStore.agents[agentId].currentTask = null;
+                                agentStore.agents[agentId].taskCount =
+                                    (agentStore.agents[agentId].taskCount || 0) + 1;
+                            }
                         }
+                        writeFileSync(agentStorePath, JSON.stringify(agentStore, null, 2), 'utf-8');
+                    }
+                    catch {
+                        // Best-effort agent sync
                     }
-                    return [2 /*return*/, {
-                            taskId: task.taskId,
-                            status: task.status,
-                            completedAt: task.completedAt,
-                            result: task.result
-                        }];
                 }
-                return [2 /*return*/, {
-                        taskId: taskId,
-                        status: 'not_found',
-                        error: 'Task not found'
-                    }];
-            });
-        }); }
+                return {
+                    taskId: task.taskId,
+                    status: task.status,
+                    completedAt: task.completedAt,
+                    result: task.result,
+                };
+            }
+            return {
+                taskId,
+                status: 'not_found',
+                error: 'Task not found',
+            };
+        },
     },
     {
         name: 'task_update',
@@ -303,46 +247,43 @@ export var taskTools = [
                 taskId: { type: 'string', description: 'Task ID' },
                 status: { type: 'string', description: 'New status' },
                 progress: { type: 'number', description: 'Progress percentage (0-100)' },
-                assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' }
+                assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
             },
-            required: ['taskId']
+            required: ['taskId'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, taskId, task, newStatus;
-            return __generator(this, function (_a) {
-                store = loadTaskStore();
-                taskId = input.taskId;
-                task = store.tasks[taskId];
-                if (task) {
-                    if (input.status) {
-                        newStatus = input.status;
-                        task.status = newStatus;
-                        if (newStatus === 'in_progress' && !task.startedAt) {
-                            task.startedAt = new Date().toISOString();
-                        }
-                    }
-                    if (typeof input.progress === 'number') {
-                        task.progress = Math.min(100, Math.max(0, input.progress));
-                    }
-                    if (input.assignTo) {
-                        task.assignedTo = input.assignTo;
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = input.taskId;
+            const task = store.tasks[taskId];
+            if (task) {
+                if (input.status) {
+                    const newStatus = input.status;
+                    task.status = newStatus;
+                    if (newStatus === 'in_progress' && !task.startedAt) {
+                        task.startedAt = new Date().toISOString();
                     }
-                    saveTaskStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            taskId: task.taskId,
-                            status: task.status,
-                            progress: task.progress,
-                            assignedTo: task.assignedTo
-                        }];
                 }
-                return [2 /*return*/, {
-                        success: false,
-                        taskId: taskId,
-                        error: 'Task not found'
-                    }];
-            });
-        }); }
+                if (typeof input.progress === 'number') {
+                    task.progress = Math.min(100, Math.max(0, input.progress));
+                }
+                if (input.assignTo) {
+                    task.assignedTo = input.assignTo;
+                }
+                saveTaskStore(store);
+                return {
+                    success: true,
+                    taskId: task.taskId,
+                    status: task.status,
+                    progress: task.progress,
+                    assignedTo: task.assignedTo,
+                };
+            }
+            return {
+                success: false,
+                taskId,
+                error: 'Task not found',
+            };
+        },
     },
     {
         name: 'task_assign',
@@ -353,80 +294,76 @@ export var taskTools = [
             properties: {
                 taskId: { type: 'string', description: 'Task ID to assign' },
                 agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-                unassign: { type: 'boolean', description: 'Unassign all agents from task' }
+                unassign: { type: 'boolean', description: 'Unassign all agents from task' },
             },
-            required: ['taskId']
+            required: ['taskId'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, taskId, task, previouslyAssigned, agentStorePath, agentStore, _i, previouslyAssigned_1, agentId, agentIds, _a, previouslyAssigned_2, agentId, _b, agentIds_1, agentId, agentDir;
-            return __generator(this, function (_c) {
-                store = loadTaskStore();
-                taskId = input.taskId;
-                task = store.tasks[taskId];
-                if (!task) {
-                    return [2 /*return*/, { taskId: taskId, error: 'Task not found' }];
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = input.taskId;
+            const task = store.tasks[taskId];
+            if (!task) {
+                return { taskId, error: 'Task not found' };
+            }
+            const previouslyAssigned = [...task.assignedTo];
+            // Load agent store to sync worker state
+            const agentStorePath = join(process.cwd(), STORAGE_DIR, 'agents.json');
+            let agentStore = { agents: {} };
+            try {
+                if (existsSync(agentStorePath)) {
+                    agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
                 }
-                previouslyAssigned = __spreadArray([], task.assignedTo, true);
-                agentStorePath = join(process.cwd(), STORAGE_DIR, 'agents.json');
-                agentStore = { agents: {} };
-                try {
-                    if (existsSync(agentStorePath)) {
-                        agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+            }
+            catch { /* ignore */ }
+            if (input.unassign) {
+                // Revert previously assigned agents to idle
+                for (const agentId of previouslyAssigned) {
+                    if (agentStore.agents[agentId]) {
+                        agentStore.agents[agentId].status = 'idle';
+                        agentStore.agents[agentId].currentTask = null;
                     }
                 }
-                catch ( /* ignore */_d) { /* ignore */ }
-                if (input.unassign) {
-                    // Revert previously assigned agents to idle
-                    for (_i = 0, previouslyAssigned_1 = previouslyAssigned; _i < previouslyAssigned_1.length; _i++) {
-                        agentId = previouslyAssigned_1[_i];
-                        if (agentStore.agents[agentId]) {
-                            agentStore.agents[agentId].status = 'idle';
-                            agentStore.agents[agentId].currentTask = null;
-                        }
+                task.assignedTo = [];
+            }
+            else {
+                const agentIds = input.agentIds || [];
+                // Revert old agents to idle
+                for (const agentId of previouslyAssigned) {
+                    if (!agentIds.includes(agentId) && agentStore.agents[agentId]) {
+                        agentStore.agents[agentId].status = 'idle';
+                        agentStore.agents[agentId].currentTask = null;
                     }
-                    task.assignedTo = [];
                 }
-                else {
-                    agentIds = input.agentIds || [];
-                    // Revert old agents to idle
-                    for (_a = 0, previouslyAssigned_2 = previouslyAssigned; _a < previouslyAssigned_2.length; _a++) {
-                        agentId = previouslyAssigned_2[_a];
-                        if (!agentIds.includes(agentId) && agentStore.agents[agentId]) {
-                            agentStore.agents[agentId].status = 'idle';
-                            agentStore.agents[agentId].currentTask = null;
-                        }
-                    }
-                    // Set new agents to active
-                    for (_b = 0, agentIds_1 = agentIds; _b < agentIds_1.length; _b++) {
-                        agentId = agentIds_1[_b];
-                        if (agentStore.agents[agentId]) {
-                            agentStore.agents[agentId].status = 'active';
-                            agentStore.agents[agentId].currentTask = taskId;
-                        }
-                    }
-                    task.assignedTo = agentIds;
-                    // Auto-transition task to in_progress if pending
-                    if (task.status === 'pending' && agentIds.length > 0) {
-                        task.status = 'in_progress';
-                        if (!task.startedAt) {
-                            task.startedAt = new Date().toISOString();
-                        }
+                // Set new agents to active
+                for (const agentId of agentIds) {
+                    if (agentStore.agents[agentId]) {
+                        agentStore.agents[agentId].status = 'active';
+                        agentStore.agents[agentId].currentTask = taskId;
                     }
                 }
-                saveTaskStore(store);
-                agentDir = join(process.cwd(), STORAGE_DIR);
-                if (!existsSync(agentDir)) {
-                    mkdirSync(agentDir, { recursive: true });
+                task.assignedTo = agentIds;
+                // Auto-transition task to in_progress if pending
+                if (task.status === 'pending' && agentIds.length > 0) {
+                    task.status = 'in_progress';
+                    if (!task.startedAt) {
+                        task.startedAt = new Date().toISOString();
+                    }
                 }
-                writeFileSync(agentStorePath, JSON.stringify(agentStore, null, 2), 'utf-8');
-                return [2 /*return*/, {
-                        taskId: task.taskId,
-                        assignedTo: task.assignedTo,
-                        previouslyAssigned: previouslyAssigned,
-                        status: task.status
-                    }];
-            });
-        }); }
+            }
+            saveTaskStore(store);
+            // Save agent store
+            const agentDir = join(process.cwd(), STORAGE_DIR);
+            if (!existsSync(agentDir)) {
+                mkdirSync(agentDir, { recursive: true });
+            }
+            writeFileSync(agentStorePath, JSON.stringify(agentStore, null, 2), 'utf-8');
+            return {
+                taskId: task.taskId,
+                assignedTo: task.assignedTo,
+                previouslyAssigned,
+                status: task.status,
+            };
+        },
     },
     {
         name: 'task_cancel',
@@ -436,35 +373,32 @@ export var taskTools = [
             type: 'object',
             properties: {
                 taskId: { type: 'string', description: 'Task ID' },
-                reason: { type: 'string', description: 'Cancellation reason' }
+                reason: { type: 'string', description: 'Cancellation reason' },
             },
-            required: ['taskId']
+            required: ['taskId'],
+        },
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = input.taskId;
+            const task = store.tasks[taskId];
+            if (task) {
+                task.status = 'cancelled';
+                task.completedAt = new Date().toISOString();
+                task.result = { cancelReason: input.reason || 'Cancelled by user' };
+                saveTaskStore(store);
+                return {
+                    success: true,
+                    taskId: task.taskId,
+                    status: task.status,
+                    cancelledAt: task.completedAt,
+                };
+            }
+            return {
+                success: false,
+                taskId,
+                error: 'Task not found',
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, taskId, task;
-            return __generator(this, function (_a) {
-                store = loadTaskStore();
-                taskId = input.taskId;
-                task = store.tasks[taskId];
-                if (task) {
-                    task.status = 'cancelled';
-                    task.completedAt = new Date().toISOString();
-                    task.result = { cancelReason: input.reason || 'Cancelled by user' };
-                    saveTaskStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            taskId: task.taskId,
-                            status: task.status,
-                            cancelledAt: task.completedAt
-                        }];
-                }
-                return [2 /*return*/, {
-                        success: false,
-                        taskId: taskId,
-                        error: 'Task not found'
-                    }];
-            });
-        }); }
     },
 ];
 //# sourceMappingURL=task-tools.js.map