kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/task.js

@@ -1,12 +1,48 @@
 /**
  * V3 CLI Task Command
- * Task management for KynjalFlow
+ * Task management for Claude Flow
  */
+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 };
+    }
+};
 import { output } from '../output.js';
 import { select, confirm, input, multiSelect } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 // Task types
-const TASK_TYPES = [
+var TASK_TYPES = [
     { value: 'implementation', label: 'Implementation', hint: 'Feature implementation' },
     { value: 'bug-fix', label: 'Bug Fix', hint: 'Fix a bug or issue' },
     { value: 'refactoring', label: 'Refactoring', hint: 'Code refactoring' },
@@ -19,7 +55,7 @@ const TASK_TYPES = [
     { value: 'custom', label: 'Custom', hint: 'Custom task type' }
 ];
 // Task priorities
-const TASK_PRIORITIES = [
+var TASK_PRIORITIES = [
     { value: 'critical', label: 'Critical', hint: 'Highest priority' },
     { value: 'high', label: 'High', hint: 'Important task' },
     { value: 'normal', label: 'Normal', hint: 'Standard priority' },
@@ -59,7 +95,7 @@ function formatPriority(priority) {
     }
 }
 // Create subcommand
-const createCommand = {
+var createCommand = {
     name: 'create',
     aliases: ['new', 'add'],
     description: 'Create a new task',
@@ -69,7 +105,7 @@ const createCommand = {
             short: 't',
             description: 'Task type',
             type: 'string',
-            choices: TASK_TYPES.map(t => t.value)
+            choices: TASK_TYPES.map(function (t) { return t.value; })
         },
         {
             name: 'description',
@@ -82,8 +118,8 @@ const createCommand = {
             short: 'p',
             description: 'Task priority',
             type: 'string',
-            choices: TASK_PRIORITIES.map(p => p.value),
-            default: 'normal'
+            choices: TASK_PRIORITIES.map(function (p) { return p.value; }),
+            "default": 'normal'
         },
         {
             name: 'assign',
@@ -110,97 +146,115 @@ const createCommand = {
             name: 'timeout',
             description: 'Task timeout in seconds',
             type: 'number',
-            default: 300
+            "default": 300
         }
     ],
-    action: async (ctx) => {
-        let taskType = ctx.flags.type;
-        let description = ctx.flags.description;
-        let priority = ctx.flags.priority;
-        // Interactive mode
-        if (!taskType && ctx.interactive) {
-            taskType = await select({
-                message: 'Select task type:',
-                options: TASK_TYPES
-            });
-        }
-        if (!description && ctx.interactive) {
-            description = await input({
-                message: 'Task description:',
-                validate: (v) => v.length > 0 || 'Description is required'
-            });
-        }
-        if (!taskType || !description) {
-            output.printError('Task type and description are required');
-            output.printInfo('Use --type and --description flags, or run in interactive mode');
-            return { success: false, exitCode: 1 };
-        }
-        if (!priority && ctx.interactive) {
-            priority = await select({
-                message: 'Select priority:',
-                options: TASK_PRIORITIES,
-                default: 'normal'
-            });
-        }
-        // Parse tags and dependencies
-        const tags = ctx.flags.tags ? ctx.flags.tags.split(',').map(t => t.trim()) : [];
-        const dependencies = ctx.flags.dependencies
-            ? ctx.flags.dependencies.split(',').map(d => d.trim())
-            : [];
-        output.writeln();
-        output.printInfo(`Creating ${taskType} task...`);
-        try {
-            const result = await callMCPTool('task_create', {
-                type: taskType,
-                description,
-                priority: priority || 'normal',
-                assignedTo: ctx.flags.assign ? [ctx.flags.assign] : undefined,
-                parentId: ctx.flags.parent,
-                dependencies,
-                tags,
-                timeout: ctx.flags.timeout,
-                metadata: {
-                    source: 'cli',
-                    createdBy: 'user'
-                }
-            });
-            output.writeln();
-            output.printSuccess(`Task created: ${result.taskId}`);
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 40 }
-                ],
-                data: [
-                    { property: 'ID', value: result.taskId },
-                    { property: 'Type', value: result.type },
-                    { property: 'Description', value: result.description },
-                    { property: 'Priority', value: formatPriority(result.priority) },
-                    { property: 'Status', value: formatStatus(result.status) },
-                    { property: 'Assigned To', value: result.assignedTo?.join(', ') || 'Unassigned' },
-                    { property: 'Tags', value: result.tags.join(', ') || 'None' },
-                    { property: 'Created', value: new Date(result.createdAt).toLocaleString() }
-                ]
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to create task: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var taskType, description, priority, tags, dependencies, result, error_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    taskType = ctx.flags.type;
+                    description = ctx.flags.description;
+                    priority = ctx.flags.priority;
+                    if (!(!taskType && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, select({
+                            message: 'Select task type:',
+                            options: TASK_TYPES
+                        })];
+                case 1:
+                    taskType = _b.sent();
+                    _b.label = 2;
+                case 2:
+                    if (!(!description && ctx.interactive)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, input({
+                            message: 'Task description:',
+                            validate: function (v) { return v.length > 0 || 'Description is required'; }
+                        })];
+                case 3:
+                    description = _b.sent();
+                    _b.label = 4;
+                case 4:
+                    if (!taskType || !description) {
+                        output.printError('Task type and description are required');
+                        output.printInfo('Use --type and --description flags, or run in interactive mode');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    if (!(!priority && ctx.interactive)) return [3 /*break*/, 6];
+                    return [4 /*yield*/, select({
+                            message: 'Select priority:',
+                            options: TASK_PRIORITIES,
+                            "default": 'normal'
+                        })];
+                case 5:
+                    priority = _b.sent();
+                    _b.label = 6;
+                case 6:
+                    tags = ctx.flags.tags ? ctx.flags.tags.split(',').map(function (t) { return t.trim(); }) : [];
+                    dependencies = ctx.flags.dependencies
+                        ? ctx.flags.dependencies.split(',').map(function (d) { return d.trim(); })
+                        : [];
+                    output.writeln();
+                    output.printInfo("Creating " + taskType + " task...");
+                    _b.label = 7;
+                case 7:
+                    _b.trys.push([7, 9, , 10]);
+                    return [4 /*yield*/, callMCPTool('task_create', {
+                            type: taskType,
+                            description: description,
+                            priority: priority || 'normal',
+                            assignedTo: ctx.flags.assign ? [ctx.flags.assign] : undefined,
+                            parentId: ctx.flags.parent,
+                            dependencies: dependencies,
+                            tags: tags,
+                            timeout: ctx.flags.timeout,
+                            metadata: {
+                                source: 'cli',
+                                createdBy: 'user'
+                            }
+                        })];
+                case 8:
+                    result = _b.sent();
+                    output.writeln();
+                    output.printSuccess("Task created: " + result.taskId);
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 15 },
+                            { key: 'value', header: 'Value', width: 40 }
+                        ],
+                        data: [
+                            { property: 'ID', value: result.taskId },
+                            { property: 'Type', value: result.type },
+                            { property: 'Description', value: result.description },
+                            { property: 'Priority', value: formatPriority(result.priority) },
+                            { property: 'Status', value: formatStatus(result.status) },
+                            { property: 'Assigned To', value: ((_a = result.assignedTo) === null || _a === void 0 ? void 0 : _a.join(', ')) || 'Unassigned' },
+                            { property: 'Tags', value: result.tags.join(', ') || 'None' },
+                            { property: 'Created', value: new Date(result.createdAt).toLocaleString() }
+                        ]
+                    });
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 9:
+                    error_1 = _b.sent();
+                    if (error_1 instanceof MCPClientError) {
+                        output.printError("Failed to create task: " + error_1.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_1));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 10: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // List subcommand
-const listCommand = {
+var listCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List tasks',
@@ -235,75 +289,85 @@ const listCommand = {
             short: 'l',
             description: 'Maximum number of tasks to show',
             type: 'number',
-            default: 20
+            "default": 20
         },
         {
             name: 'all',
             description: 'Show all tasks including completed',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const status = ctx.flags.all ? 'all' : ctx.flags.status || 'pending,running';
-        const limit = ctx.flags.limit;
-        try {
-            const result = await callMCPTool('task_list', {
-                status,
-                type: ctx.flags.type,
-                priority: ctx.flags.priority,
-                agentId: ctx.flags.agent,
-                limit,
-                offset: 0
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Tasks'));
-            output.writeln();
-            if (result.tasks.length === 0) {
-                output.printInfo('No tasks found matching criteria');
-                return { success: true, data: result };
-            }
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'ID', width: 15 },
-                    { key: 'type', header: 'Type', width: 15 },
-                    { key: 'description', header: 'Description', width: 30 },
-                    { key: 'priority', header: 'Priority', width: 10 },
-                    { key: 'status', header: 'Status', width: 12 },
-                    { key: 'progress', header: 'Progress', width: 10 }
-                ],
-                data: result.tasks.map(t => ({
-                    id: t.id,
-                    type: t.type,
-                    description: t.description.length > 27
-                        ? t.description.slice(0, 27) + '...'
-                        : t.description,
-                    priority: formatPriority(t.priority),
-                    status: formatStatus(t.status),
-                    progress: `${t.progress}%`
-                }))
-            });
-            output.writeln();
-            output.printInfo(`Showing ${result.tasks.length} of ${result.total} tasks`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to list tasks: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var status, limit, result, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    status = ctx.flags.all ? 'all' : ctx.flags.status || 'pending,running';
+                    limit = ctx.flags.limit;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, callMCPTool('task_list', {
+                            status: status,
+                            type: ctx.flags.type,
+                            priority: ctx.flags.priority,
+                            agentId: ctx.flags.agent,
+                            limit: limit,
+                            offset: 0
+                        })];
+                case 2:
+                    result = _a.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold('Tasks'));
+                    output.writeln();
+                    if (result.tasks.length === 0) {
+                        output.printInfo('No tasks found matching criteria');
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.printTable({
+                        columns: [
+                            { key: 'id', header: 'ID', width: 15 },
+                            { key: 'type', header: 'Type', width: 15 },
+                            { key: 'description', header: 'Description', width: 30 },
+                            { key: 'priority', header: 'Priority', width: 10 },
+                            { key: 'status', header: 'Status', width: 12 },
+                            { key: 'progress', header: 'Progress', width: 10 }
+                        ],
+                        data: result.tasks.map(function (t) { return ({
+                            id: t.id,
+                            type: t.type,
+                            description: t.description.length > 27
+                                ? t.description.slice(0, 27) + '...'
+                                : t.description,
+                            priority: formatPriority(t.priority),
+                            status: formatStatus(t.status),
+                            progress: t.progress + "%"
+                        }); })
+                    });
+                    output.writeln();
+                    output.printInfo("Showing " + result.tasks.length + " of " + result.total + " tasks");
+                    return [2 /*return*/, { success: true, data: result }];
+                case 3:
+                    error_2 = _a.sent();
+                    if (error_2 instanceof MCPClientError) {
+                        output.printError("Failed to list tasks: " + error_2.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_2));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Status subcommand (get task details)
-const statusCommand = {
+var statusCommand = {
     name: 'status',
     aliases: ['info', 'get'],
     description: 'Get task status and details',
@@ -317,118 +381,133 @@ const statusCommand = {
             name: 'logs',
             description: 'Include execution logs',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        let taskId = ctx.args[0] || ctx.flags.id;
-        if (!taskId && ctx.interactive) {
-            taskId = await input({
-                message: 'Enter task ID:',
-                validate: (v) => v.length > 0 || 'Task ID is required'
-            });
-        }
-        if (!taskId) {
-            output.printError('Task ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('task_status', {
-                taskId,
-                includeLogs: ctx.flags.logs,
-                includeMetrics: true
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Type:        ${result.type}`,
-                `Status:      ${formatStatus(result.status)}`,
-                `Priority:    ${formatPriority(result.priority)}`,
-                `Progress:    ${result.progress}%`,
-                '',
-                `Description: ${result.description}`
-            ].join('\n'), `Task: ${result.id}`);
-            // Assignment info
-            output.writeln();
-            output.writeln(output.bold('Assignment'));
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 40 }
-                ],
-                data: [
-                    { property: 'Assigned To', value: result.assignedTo?.join(', ') || 'Unassigned' },
-                    { property: 'Parent Task', value: result.parentId || 'None' },
-                    { property: 'Dependencies', value: result.dependencies.join(', ') || 'None' },
-                    { property: 'Dependents', value: result.dependents.join(', ') || 'None' },
-                    { property: 'Tags', value: result.tags.join(', ') || 'None' }
-                ]
-            });
-            // Timeline
-            output.writeln();
-            output.writeln(output.bold('Timeline'));
-            output.printTable({
-                columns: [
-                    { key: 'event', header: 'Event', width: 15 },
-                    { key: 'time', header: 'Time', width: 30 }
-                ],
-                data: [
-                    { event: 'Created', time: new Date(result.createdAt).toLocaleString() },
-                    { event: 'Started', time: result.startedAt ? new Date(result.startedAt).toLocaleString() : '-' },
-                    { event: 'Completed', time: result.completedAt ? new Date(result.completedAt).toLocaleString() : '-' }
-                ]
-            });
-            // Metrics
-            if (result.metrics) {
-                output.writeln();
-                output.writeln(output.bold('Metrics'));
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 20 },
-                        { key: 'value', header: 'Value', width: 20, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Execution Time', value: `${(result.metrics.executionTime / 1000).toFixed(2)}s` },
-                        { metric: 'Retries', value: result.metrics.retries },
-                        { metric: 'Tokens Used', value: result.metrics.tokensUsed.toLocaleString() }
-                    ]
-                });
-            }
-            // Error if failed
-            if (result.status === 'failed' && result.error) {
-                output.writeln();
-                output.printError(`Error: ${result.error}`);
-            }
-            // Logs if requested
-            if (ctx.flags.logs && result.logs && result.logs.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Execution Logs'));
-                for (const log of result.logs.slice(-20)) {
-                    const time = new Date(log.timestamp).toLocaleTimeString();
-                    const level = log.level === 'error' ? output.error(`[${log.level}]`) :
-                        log.level === 'warn' ? output.warning(`[${log.level}]`) :
-                            output.dim(`[${log.level}]`);
-                    output.writeln(`  ${output.dim(time)} ${level} ${log.message}`);
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to get task status: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var taskId, result, _i, _a, log, time, level, error_3;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    taskId = ctx.args[0] || ctx.flags.id;
+                    if (!(!taskId && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, input({
+                            message: 'Enter task ID:',
+                            validate: function (v) { return v.length > 0 || 'Task ID is required'; }
+                        })];
+                case 1:
+                    taskId = _c.sent();
+                    _c.label = 2;
+                case 2:
+                    if (!taskId) {
+                        output.printError('Task ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    _c.label = 3;
+                case 3:
+                    _c.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, callMCPTool('task_status', {
+                            taskId: taskId,
+                            includeLogs: ctx.flags.logs,
+                            includeMetrics: true
+                        })];
+                case 4:
+                    result = _c.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.writeln();
+                    output.printBox([
+                        "Type:        " + result.type,
+                        "Status:      " + formatStatus(result.status),
+                        "Priority:    " + formatPriority(result.priority),
+                        "Progress:    " + result.progress + "%",
+                        '',
+                        "Description: " + result.description
+                    ].join('\n'), "Task: " + result.id);
+                    // Assignment info
+                    output.writeln();
+                    output.writeln(output.bold('Assignment'));
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 15 },
+                            { key: 'value', header: 'Value', width: 40 }
+                        ],
+                        data: [
+                            { property: 'Assigned To', value: ((_b = result.assignedTo) === null || _b === void 0 ? void 0 : _b.join(', ')) || 'Unassigned' },
+                            { property: 'Parent Task', value: result.parentId || 'None' },
+                            { property: 'Dependencies', value: result.dependencies.join(', ') || 'None' },
+                            { property: 'Dependents', value: result.dependents.join(', ') || 'None' },
+                            { property: 'Tags', value: result.tags.join(', ') || 'None' }
+                        ]
+                    });
+                    // Timeline
+                    output.writeln();
+                    output.writeln(output.bold('Timeline'));
+                    output.printTable({
+                        columns: [
+                            { key: 'event', header: 'Event', width: 15 },
+                            { key: 'time', header: 'Time', width: 30 }
+                        ],
+                        data: [
+                            { event: 'Created', time: new Date(result.createdAt).toLocaleString() },
+                            { event: 'Started', time: result.startedAt ? new Date(result.startedAt).toLocaleString() : '-' },
+                            { event: 'Completed', time: result.completedAt ? new Date(result.completedAt).toLocaleString() : '-' }
+                        ]
+                    });
+                    // Metrics
+                    if (result.metrics) {
+                        output.writeln();
+                        output.writeln(output.bold('Metrics'));
+                        output.printTable({
+                            columns: [
+                                { key: 'metric', header: 'Metric', width: 20 },
+                                { key: 'value', header: 'Value', width: 20, align: 'right' }
+                            ],
+                            data: [
+                                { metric: 'Execution Time', value: (result.metrics.executionTime / 1000).toFixed(2) + "s" },
+                                { metric: 'Retries', value: result.metrics.retries },
+                                { metric: 'Tokens Used', value: result.metrics.tokensUsed.toLocaleString() }
+                            ]
+                        });
+                    }
+                    // Error if failed
+                    if (result.status === 'failed' && result.error) {
+                        output.writeln();
+                        output.printError("Error: " + result.error);
+                    }
+                    // Logs if requested
+                    if (ctx.flags.logs && result.logs && result.logs.length > 0) {
+                        output.writeln();
+                        output.writeln(output.bold('Execution Logs'));
+                        for (_i = 0, _a = result.logs.slice(-20); _i < _a.length; _i++) {
+                            log = _a[_i];
+                            time = new Date(log.timestamp).toLocaleTimeString();
+                            level = log.level === 'error' ? output.error("[" + log.level + "]") :
+                                log.level === 'warn' ? output.warning("[" + log.level + "]") :
+                                    output.dim("[" + log.level + "]");
+                            output.writeln("  " + output.dim(time) + " " + level + " " + log.message);
+                        }
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 5:
+                    error_3 = _c.sent();
+                    if (error_3 instanceof MCPClientError) {
+                        output.printError("Failed to get task status: " + error_3.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_3));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 6: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Cancel subcommand
-const cancelCommand = {
+var cancelCommand = {
     name: 'cancel',
     aliases: ['abort', 'stop'],
     description: 'Cancel a running task',
@@ -438,7 +517,7 @@ const cancelCommand = {
             short: 'f',
             description: 'Force cancel without confirmation',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'reason',
@@ -447,50 +526,61 @@ const cancelCommand = {
             type: 'string'
         }
     ],
-    action: async (ctx) => {
-        const taskId = ctx.args[0];
-        const force = ctx.flags.force;
-        const reason = ctx.flags.reason;
-        if (!taskId) {
-            output.printError('Task ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Are you sure you want to cancel task ${taskId}?`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        try {
-            const result = await callMCPTool('task_cancel', {
-                taskId,
-                reason: reason || 'Cancelled by user via CLI'
-            });
-            output.writeln();
-            output.printSuccess(`Task ${taskId} cancelled`);
-            output.printInfo(`Previous status: ${result.previousStatus}`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to cancel task: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var taskId, force, reason, confirmed, result, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    taskId = ctx.args[0];
+                    force = ctx.flags.force;
+                    reason = ctx.flags.reason;
+                    if (!taskId) {
+                        output.printError('Task ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    if (!(!force && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, confirm({
+                            message: "Are you sure you want to cancel task " + taskId + "?",
+                            "default": false
+                        })];
+                case 1:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, callMCPTool('task_cancel', {
+                            taskId: taskId,
+                            reason: reason || 'Cancelled by user via CLI'
+                        })];
+                case 3:
+                    result = _a.sent();
+                    output.writeln();
+                    output.printSuccess("Task " + taskId + " cancelled");
+                    output.printInfo("Previous status: " + result.previousStatus);
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 4:
+                    error_4 = _a.sent();
+                    if (error_4 instanceof MCPClientError) {
+                        output.printError("Failed to cancel task: " + error_4.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_4));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 5: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Assign subcommand
-const assignCommand = {
+var assignCommand = {
     name: 'assign',
     description: 'Assign a task to agent(s)',
     options: [
@@ -504,90 +594,103 @@ const assignCommand = {
             name: 'unassign',
             description: 'Remove current assignment',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const taskId = ctx.args[0];
-        const agentIds = ctx.flags.agent;
-        const unassign = ctx.flags.unassign;
-        if (!taskId) {
-            output.printError('Task ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        if (!agentIds && !unassign) {
-            // Interactive agent selection
-            if (ctx.interactive) {
-                try {
-                    const agents = await callMCPTool('agent_list', { status: 'active,idle' });
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var taskId, agentIds, unassign, agents, selectedAgents, result, error_5, result, error_6;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    taskId = ctx.args[0];
+                    agentIds = ctx.flags.agent;
+                    unassign = ctx.flags.unassign;
+                    if (!taskId) {
+                        output.printError('Task ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    if (!(!agentIds && !unassign)) return [3 /*break*/, 7];
+                    if (!ctx.interactive) return [3 /*break*/, 6];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 5, , 6]);
+                    return [4 /*yield*/, callMCPTool('agent_list', { status: 'active,idle' })];
+                case 2:
+                    agents = _a.sent();
                     if (agents.agents.length === 0) {
                         output.printWarning('No available agents');
-                        return { success: false, exitCode: 1 };
-                    }
-                    const selectedAgents = await multiSelect({
-                        message: 'Select agent(s) to assign:',
-                        options: agents.agents.map(a => ({
-                            value: a.id,
-                            label: a.id,
-                            hint: `${a.type} - ${a.status}`
-                        })),
-                        required: true
-                    });
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    return [4 /*yield*/, multiSelect({
+                            message: 'Select agent(s) to assign:',
+                            options: agents.agents.map(function (a) { return ({
+                                value: a.id,
+                                label: a.id,
+                                hint: a.type + " - " + a.status
+                            }); }),
+                            required: true
+                        })];
+                case 3:
+                    selectedAgents = _a.sent();
                     if (selectedAgents.length === 0) {
                         output.printInfo('No agents selected');
-                        return { success: true };
+                        return [2 /*return*/, { success: true }];
                     }
-                    // Continue with assignment
-                    const result = await callMCPTool('task_assign', {
-                        taskId,
-                        agentIds: selectedAgents
-                    });
+                    return [4 /*yield*/, callMCPTool('task_assign', {
+                            taskId: taskId,
+                            agentIds: selectedAgents
+                        })];
+                case 4:
+                    result = _a.sent();
                     output.writeln();
-                    output.printSuccess(`Task ${taskId} assigned to ${result.assignedTo.join(', ')}`);
-                    return { success: true, data: result };
-                }
-                catch (error) {
-                    if (error instanceof Error && error.message === 'User cancelled') {
+                    output.printSuccess("Task " + taskId + " assigned to " + result.assignedTo.join(', '));
+                    return [2 /*return*/, { success: true, data: result }];
+                case 5:
+                    error_5 = _a.sent();
+                    if (error_5 instanceof Error && error_5.message === 'User cancelled') {
                         output.printInfo('Operation cancelled');
-                        return { success: true };
+                        return [2 /*return*/, { success: true }];
                     }
-                    throw error;
-                }
-            }
-            output.printError('Agent ID is required. Use --agent flag or run in interactive mode');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('task_assign', {
-                taskId,
-                agentIds: unassign ? [] : agentIds.split(',').map(id => id.trim()),
-                unassign
-            });
-            output.writeln();
-            if (unassign) {
-                output.printSuccess(`Task ${taskId} unassigned`);
-            }
-            else {
-                output.printSuccess(`Task ${taskId} assigned to ${result.assignedTo.join(', ')}`);
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to assign task: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+                    throw error_5;
+                case 6:
+                    output.printError('Agent ID is required. Use --agent flag or run in interactive mode');
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 7:
+                    _a.trys.push([7, 9, , 10]);
+                    return [4 /*yield*/, callMCPTool('task_assign', {
+                            taskId: taskId,
+                            agentIds: unassign ? [] : agentIds.split(',').map(function (id) { return id.trim(); }),
+                            unassign: unassign
+                        })];
+                case 8:
+                    result = _a.sent();
+                    output.writeln();
+                    if (unassign) {
+                        output.printSuccess("Task " + taskId + " unassigned");
+                    }
+                    else {
+                        output.printSuccess("Task " + taskId + " assigned to " + result.assignedTo.join(', '));
+                    }
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 9:
+                    error_6 = _a.sent();
+                    if (error_6 instanceof MCPClientError) {
+                        output.printError("Failed to assign task: " + error_6.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_6));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 10: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Retry subcommand
-const retryCommand = {
+var retryCommand = {
     name: 'retry',
     aliases: ['rerun'],
     description: 'Retry a failed task',
@@ -596,43 +699,53 @@ const retryCommand = {
             name: 'reset-state',
             description: 'Reset task state completely',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const taskId = ctx.args[0];
-        const resetState = ctx.flags['reset-state'];
-        if (!taskId) {
-            output.printError('Task ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('task_retry', {
-                taskId,
-                resetState
-            });
-            output.writeln();
-            output.printSuccess(`Task ${taskId} retried`);
-            output.printInfo(`New task ID: ${result.newTaskId}`);
-            output.printInfo(`Status: ${formatStatus(result.status)}`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to retry task: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var taskId, resetState, result, error_7;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    taskId = ctx.args[0];
+                    resetState = ctx.flags['reset-state'];
+                    if (!taskId) {
+                        output.printError('Task ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, callMCPTool('task_retry', {
+                            taskId: taskId,
+                            resetState: resetState
+                        })];
+                case 2:
+                    result = _a.sent();
+                    output.writeln();
+                    output.printSuccess("Task " + taskId + " retried");
+                    output.printInfo("New task ID: " + result.newTaskId);
+                    output.printInfo("Status: " + formatStatus(result.status));
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 3:
+                    error_7 = _a.sent();
+                    if (error_7 instanceof MCPClientError) {
+                        output.printError("Failed to retry task: " + error_7.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_7));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Main task command
-export const taskCommand = {
+export var taskCommand = {
     name: 'task',
     description: 'Task management commands',
     subcommands: [createCommand, listCommand, statusCommand, cancelCommand, assignCommand, retryCommand],
@@ -646,26 +759,28 @@ export const taskCommand = {
         { command: 'claude-flow task assign task-123 --agent coder-1', description: 'Assign task to agent' },
         { command: 'claude-flow task retry task-123', description: 'Retry a failed task' }
     ],
-    action: async (ctx) => {
-        // Show help if no subcommand
-        output.writeln();
-        output.writeln(output.bold('Task Management Commands'));
-        output.writeln();
-        output.writeln('Usage: claude-flow task <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('create')}  - Create a new task`,
-            `${output.highlight('list')}    - List tasks`,
-            `${output.highlight('status')}  - Get task details`,
-            `${output.highlight('cancel')}  - Cancel a running task`,
-            `${output.highlight('assign')}  - Assign task to agent(s)`,
-            `${output.highlight('retry')}   - Retry a failed task`
-        ]);
-        output.writeln();
-        output.writeln('Run "claude-flow task <subcommand> --help" for subcommand help');
-        return { success: true };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            // Show help if no subcommand
+            output.writeln();
+            output.writeln(output.bold('Task Management Commands'));
+            output.writeln();
+            output.writeln('Usage: claude-flow task <subcommand> [options]');
+            output.writeln();
+            output.writeln('Subcommands:');
+            output.printList([
+                output.highlight('create') + "  - Create a new task",
+                output.highlight('list') + "    - List tasks",
+                output.highlight('status') + "  - Get task details",
+                output.highlight('cancel') + "  - Cancel a running task",
+                output.highlight('assign') + "  - Assign task to agent(s)",
+                output.highlight('retry') + "   - Retry a failed task"
+            ]);
+            output.writeln();
+            output.writeln('Run "claude-flow task <subcommand> --help" for subcommand help');
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default taskCommand;
 //# sourceMappingURL=task.js.map