kynjal-cli 3.1.3 → 4.0.0

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

@@ -3,12 +3,57 @@
  *
  * 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
-const STORAGE_DIR = '.claude-flow';
-const TASK_DIR = 'tasks';
-const TASK_FILE = 'store.json';
+var STORAGE_DIR = '.claude-flow';
+var TASK_DIR = 'tasks';
+var TASK_FILE = 'store.json';
 function getTaskDir() {
     return join(process.cwd(), STORAGE_DIR, TASK_DIR);
 }
@@ -16,20 +61,20 @@ function getTaskPath() {
     return join(getTaskDir(), TASK_FILE);
 }
 function ensureTaskDir() {
-    const dir = getTaskDir();
+    var dir = getTaskDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadTaskStore() {
     try {
-        const path = getTaskPath();
+        var path = getTaskPath();
         if (existsSync(path)) {
-            const data = readFileSync(path, 'utf-8');
+            var data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
         }
     }
-    catch {
+    catch (_a) {
         // Return empty store on error
     }
     return { tasks: {}, version: '3.0.0' };
@@ -38,7 +83,7 @@ function saveTaskStore(store) {
     ensureTaskDir();
     writeFileSync(getTaskPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export const taskTools = [
+export var taskTools = [
     {
         name: 'task_create',
         description: 'Create a new task',
@@ -50,39 +95,42 @@ export const 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'],
-        },
-        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,
-            };
+            required: ['type', 'description']
         },
+        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',
@@ -91,35 +139,38 @@ export const taskTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                taskId: { type: 'string', description: 'Task ID' },
+                taskId: { type: 'string', description: 'Task ID' }
             },
-            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',
-            };
+            required: ['taskId']
         },
+        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',
@@ -132,52 +183,53 @@ export const 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' },
-            },
-        },
-        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));
+                limit: { type: 'number', description: 'Max tasks to return' }
             }
-            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',
@@ -187,33 +239,59 @@ export const 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'],
-        },
-        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);
-                return {
-                    taskId: task.taskId,
-                    status: task.status,
-                    completedAt: task.completedAt,
-                    result: task.result,
-                };
-            }
-            return {
-                taskId,
-                status: 'not_found',
-                error: 'Task not found',
-            };
+            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');
+                        }
+                        catch (_c) {
+                            // 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'
+                    }];
+            });
+        }); }
     },
     {
         name: 'task_update',
@@ -225,43 +303,130 @@ export const 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: 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();
+        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;
+                    }
+                    saveTaskStore(store);
+                    return [2 /*return*/, {
+                            success: true,
+                            taskId: task.taskId,
+                            status: task.status,
+                            progress: task.progress,
+                            assignedTo: task.assignedTo
+                        }];
                 }
-                if (typeof input.progress === 'number') {
-                    task.progress = Math.min(100, Math.max(0, input.progress));
+                return [2 /*return*/, {
+                        success: false,
+                        taskId: taskId,
+                        error: 'Task not found'
+                    }];
+            });
+        }); }
+    },
+    {
+        name: 'task_assign',
+        description: 'Assign a task to one or more agents',
+        category: 'task',
+        inputSchema: {
+            type: 'object',
+            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' }
+            },
+            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' }];
                 }
-                if (input.assignTo) {
-                    task.assignedTo = input.assignTo;
+                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 */_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 {
+                    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();
+                        }
+                    }
                 }
                 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',
-            };
-        },
+                agentDir = join(process.cwd(), STORAGE_DIR);
+                if (!existsSync(agentDir)) {
+                    mkdirSync(agentDir, { recursive: true });
+                }
+                writeFileSync(agentStorePath, JSON.stringify(agentStore, null, 2), 'utf-8');
+                return [2 /*return*/, {
+                        taskId: task.taskId,
+                        assignedTo: task.assignedTo,
+                        previouslyAssigned: previouslyAssigned,
+                        status: task.status
+                    }];
+            });
+        }); }
     },
     {
         name: 'task_cancel',
@@ -271,32 +436,35 @@ export const taskTools = [
             type: 'object',
             properties: {
                 taskId: { type: 'string', description: 'Task ID' },
-                reason: { type: 'string', description: 'Cancellation reason' },
+                reason: { type: 'string', description: 'Cancellation reason' }
             },
-            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',
-            };
+            required: ['taskId']
         },
+        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