kynjal-cli 3.1.3 → 4.0.0

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

@@ -3,12 +3,59 @@
  *
  * Tool definitions for workflow automation and orchestration.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
-const WORKFLOW_DIR = 'workflows';
-const WORKFLOW_FILE = 'store.json';
+var STORAGE_DIR = '.claude-flow';
+var WORKFLOW_DIR = 'workflows';
+var WORKFLOW_FILE = 'store.json';
 function getWorkflowDir() {
     return join(process.cwd(), STORAGE_DIR, WORKFLOW_DIR);
 }
@@ -16,20 +63,20 @@ function getWorkflowPath() {
     return join(getWorkflowDir(), WORKFLOW_FILE);
 }
 function ensureWorkflowDir() {
-    const dir = getWorkflowDir();
+    var dir = getWorkflowDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadWorkflowStore() {
     try {
-        const path = getWorkflowPath();
+        var path = getWorkflowPath();
         if (existsSync(path)) {
-            const data = readFileSync(path, 'utf-8');
+            var data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
         }
     }
-    catch {
+    catch (_a) {
         // Return default store on error
     }
     return { workflows: {}, templates: {}, version: '3.0.0' };
@@ -38,7 +85,99 @@ function saveWorkflowStore(store) {
     ensureWorkflowDir();
     writeFileSync(getWorkflowPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export const workflowTools = [
+export var workflowTools = [
+    {
+        name: 'workflow_run',
+        description: 'Run a workflow from a template or file',
+        category: 'workflow',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Template name to run' },
+                file: { type: 'string', description: 'Workflow file path' },
+                task: { type: 'string', description: 'Task description' },
+                options: {
+                    type: 'object',
+                    description: 'Workflow options',
+                    properties: {
+                        parallel: { type: 'boolean', description: 'Run stages in parallel' },
+                        maxAgents: { type: 'number', description: 'Maximum agents to use' },
+                        timeout: { type: 'number', description: 'Timeout in seconds' },
+                        dryRun: { type: 'boolean', description: 'Validate without executing' }
+                    }
+                }
+            }
+        },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, template, task, options, dryRun, workflowId, stages, templateName, stageNames, _i, stageNames_1, name, steps, workflow;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                template = input.template;
+                task = input.task;
+                options = input.options || {};
+                dryRun = options.dryRun;
+                workflowId = "workflow-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
+                stages = [];
+                templateName = template || 'custom';
+                stageNames = (function () {
+                    switch (templateName) {
+                        case 'feature':
+                            return ['Research', 'Design', 'Implement', 'Test', 'Review'];
+                        case 'bugfix':
+                            return ['Investigate', 'Fix', 'Test', 'Review'];
+                        case 'refactor':
+                            return ['Analyze', 'Refactor', 'Test', 'Review'];
+                        case 'security':
+                            return ['Scan', 'Analyze', 'Report'];
+                        default:
+                            return ['Execute'];
+                    }
+                })();
+                for (_i = 0, stageNames_1 = stageNames; _i < stageNames_1.length; _i++) {
+                    name = stageNames_1[_i];
+                    stages.push({
+                        name: name,
+                        status: dryRun ? 'validated' : 'pending',
+                        agents: []
+                    });
+                }
+                if (!dryRun) {
+                    steps = stageNames.map(function (name, i) { return ({
+                        stepId: "step-" + (i + 1),
+                        name: name,
+                        type: 'task',
+                        config: { task: task || name },
+                        status: 'pending'
+                    }); });
+                    workflow = {
+                        workflowId: workflowId,
+                        name: task || templateName + " workflow",
+                        description: task,
+                        steps: steps,
+                        status: 'running',
+                        currentStep: 0,
+                        variables: __assign({ template: templateName }, options),
+                        createdAt: new Date().toISOString(),
+                        startedAt: new Date().toISOString()
+                    };
+                    store.workflows[workflowId] = workflow;
+                    saveWorkflowStore(store);
+                }
+                return [2 /*return*/, {
+                        workflowId: workflowId,
+                        template: templateName,
+                        status: dryRun ? 'validated' : 'running',
+                        stages: stages,
+                        metrics: {
+                            totalStages: stages.length,
+                            completedStages: 0,
+                            agentsSpawned: 0,
+                            estimatedDuration: stages.length * 30 + "s"
+                        }
+                    }];
+            });
+        }); }
+    },
     {
         name: 'workflow_create',
         description: 'Create a new workflow',
@@ -55,45 +194,48 @@ export const workflowTools = [
                         type: 'object',
                         properties: {
                             name: { type: 'string' },
-                            type: { type: 'string', enum: ['task', 'condition', 'parallel', 'loop', 'wait'] },
-                            config: { type: 'object' },
-                        },
-                    },
+                            type: { type: 'string', "enum": ['task', 'condition', 'parallel', 'loop', 'wait'] },
+                            config: { type: 'object' }
+                        }
+                    }
                 },
-                variables: { type: 'object', description: 'Initial variables' },
+                variables: { type: 'object', description: 'Initial variables' }
             },
-            required: ['name'],
-        },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const workflowId = `workflow-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const steps = (input.steps || []).map((s, i) => ({
-                stepId: `step-${i + 1}`,
-                name: s.name || `Step ${i + 1}`,
-                type: s.type || 'task',
-                config: s.config || {},
-                status: 'pending',
-            }));
-            const workflow = {
-                workflowId,
-                name: input.name,
-                description: input.description,
-                steps,
-                status: steps.length > 0 ? 'ready' : 'draft',
-                currentStep: 0,
-                variables: input.variables || {},
-                createdAt: new Date().toISOString(),
-            };
-            store.workflows[workflowId] = workflow;
-            saveWorkflowStore(store);
-            return {
-                workflowId,
-                name: workflow.name,
-                status: workflow.status,
-                stepCount: steps.length,
-                createdAt: workflow.createdAt,
-            };
+            required: ['name']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, steps, workflow;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflowId = "workflow-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
+                steps = (input.steps || []).map(function (s, i) { return ({
+                    stepId: "step-" + (i + 1),
+                    name: s.name || "Step " + (i + 1),
+                    type: s.type || 'task',
+                    config: s.config || {},
+                    status: 'pending'
+                }); });
+                workflow = {
+                    workflowId: workflowId,
+                    name: input.name,
+                    description: input.description,
+                    steps: steps,
+                    status: steps.length > 0 ? 'ready' : 'draft',
+                    currentStep: 0,
+                    variables: input.variables || {},
+                    createdAt: new Date().toISOString()
+                };
+                store.workflows[workflowId] = workflow;
+                saveWorkflowStore(store);
+                return [2 /*return*/, {
+                        workflowId: workflowId,
+                        name: workflow.name,
+                        status: workflow.status,
+                        stepCount: steps.length,
+                        createdAt: workflow.createdAt
+                    }];
+            });
+        }); }
     },
     {
         name: 'workflow_execute',
@@ -104,53 +246,55 @@ export const workflowTools = [
             properties: {
                 workflowId: { type: 'string', description: 'Workflow ID to execute' },
                 variables: { type: 'object', description: 'Runtime variables to inject' },
-                startFromStep: { type: 'number', description: 'Step to start from (0-indexed)' },
+                startFromStep: { type: 'number', description: 'Step to start from (0-indexed)' }
             },
-            required: ['workflowId'],
-        },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const workflowId = input.workflowId;
-            const workflow = store.workflows[workflowId];
-            if (!workflow) {
-                return { workflowId, error: 'Workflow not found' };
-            }
-            if (workflow.status === 'running') {
-                return { workflowId, error: 'Workflow already running' };
-            }
-            // Inject runtime variables
-            if (input.variables) {
-                workflow.variables = { ...workflow.variables, ...input.variables };
-            }
-            workflow.status = 'running';
-            workflow.startedAt = new Date().toISOString();
-            workflow.currentStep = input.startFromStep || 0;
-            // Execute steps (in real implementation, this would be async/event-driven)
-            const results = [];
-            for (let i = workflow.currentStep; i < workflow.steps.length; i++) {
-                const step = workflow.steps[i];
-                step.status = 'running';
-                step.startedAt = new Date().toISOString();
-                // For now, mark as completed (real implementation would execute actual tasks)
-                step.status = 'completed';
-                step.completedAt = new Date().toISOString();
-                step.result = { executed: true, stepType: step.type };
-                results.push({ stepId: step.stepId, status: step.status });
-                workflow.currentStep = i + 1;
-            }
-            workflow.status = 'completed';
-            workflow.completedAt = new Date().toISOString();
-            saveWorkflowStore(store);
-            return {
-                workflowId,
-                status: workflow.status,
-                stepsExecuted: results.length,
-                results,
-                startedAt: workflow.startedAt,
-                completedAt: workflow.completedAt,
-                duration: new Date(workflow.completedAt).getTime() - new Date(workflow.startedAt).getTime(),
-            };
+            required: ['workflowId']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, workflow, results, i, step;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflowId = input.workflowId;
+                workflow = store.workflows[workflowId];
+                if (!workflow) {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not found' }];
+                }
+                if (workflow.status === 'running') {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow already running' }];
+                }
+                // Inject runtime variables
+                if (input.variables) {
+                    workflow.variables = __assign(__assign({}, workflow.variables), input.variables);
+                }
+                workflow.status = 'running';
+                workflow.startedAt = new Date().toISOString();
+                workflow.currentStep = input.startFromStep || 0;
+                results = [];
+                for (i = workflow.currentStep; i < workflow.steps.length; i++) {
+                    step = workflow.steps[i];
+                    step.status = 'running';
+                    step.startedAt = new Date().toISOString();
+                    // For now, mark as completed (real implementation would execute actual tasks)
+                    step.status = 'completed';
+                    step.completedAt = new Date().toISOString();
+                    step.result = { executed: true, stepType: step.type };
+                    results.push({ stepId: step.stepId, status: step.status });
+                    workflow.currentStep = i + 1;
+                }
+                workflow.status = 'completed';
+                workflow.completedAt = new Date().toISOString();
+                saveWorkflowStore(store);
+                return [2 /*return*/, {
+                        workflowId: workflowId,
+                        status: workflow.status,
+                        stepsExecuted: results.length,
+                        results: results,
+                        startedAt: workflow.startedAt,
+                        completedAt: workflow.completedAt,
+                        duration: new Date(workflow.completedAt).getTime() - new Date(workflow.startedAt).getTime()
+                    }];
+            });
+        }); }
     },
     {
         name: 'workflow_status',
@@ -160,49 +304,46 @@ export const workflowTools = [
             type: 'object',
             properties: {
                 workflowId: { type: 'string', description: 'Workflow ID' },
-                verbose: { type: 'boolean', description: 'Include step details' },
+                verbose: { type: 'boolean', description: 'Include step details' }
             },
-            required: ['workflowId'],
+            required: ['workflowId']
         },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const workflowId = input.workflowId;
-            const workflow = store.workflows[workflowId];
-            if (!workflow) {
-                return { workflowId, error: 'Workflow not found' };
-            }
-            const completedSteps = workflow.steps.filter(s => s.status === 'completed').length;
-            const progress = workflow.steps.length > 0 ? (completedSteps / workflow.steps.length) * 100 : 0;
-            const status = {
-                workflowId: workflow.workflowId,
-                name: workflow.name,
-                status: workflow.status,
-                progress,
-                currentStep: workflow.currentStep,
-                totalSteps: workflow.steps.length,
-                completedSteps,
-                createdAt: workflow.createdAt,
-                startedAt: workflow.startedAt,
-                completedAt: workflow.completedAt,
-            };
-            if (input.verbose) {
-                return {
-                    ...status,
-                    description: workflow.description,
-                    variables: workflow.variables,
-                    steps: workflow.steps.map(s => ({
-                        stepId: s.stepId,
-                        name: s.name,
-                        type: s.type,
-                        status: s.status,
-                        startedAt: s.startedAt,
-                        completedAt: s.completedAt,
-                    })),
-                    error: workflow.error,
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, workflow, completedSteps, progress, status;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflowId = input.workflowId;
+                workflow = store.workflows[workflowId];
+                if (!workflow) {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not found' }];
+                }
+                completedSteps = workflow.steps.filter(function (s) { return s.status === 'completed'; }).length;
+                progress = workflow.steps.length > 0 ? (completedSteps / workflow.steps.length) * 100 : 0;
+                status = {
+                    workflowId: workflow.workflowId,
+                    name: workflow.name,
+                    status: workflow.status,
+                    progress: progress,
+                    currentStep: workflow.currentStep,
+                    totalSteps: workflow.steps.length,
+                    completedSteps: completedSteps,
+                    createdAt: workflow.createdAt,
+                    startedAt: workflow.startedAt,
+                    completedAt: workflow.completedAt
                 };
-            }
-            return status;
-        },
+                if (input.verbose) {
+                    return [2 /*return*/, __assign(__assign({}, status), { description: workflow.description, variables: workflow.variables, steps: workflow.steps.map(function (s) { return ({
+                                stepId: s.stepId,
+                                name: s.name,
+                                type: s.type,
+                                status: s.status,
+                                startedAt: s.startedAt,
+                                completedAt: s.completedAt
+                            }); }), error: workflow.error })];
+                }
+                return [2 /*return*/, status];
+            });
+        }); }
     },
     {
         name: 'workflow_list',
@@ -212,34 +353,36 @@ export const workflowTools = [
             type: 'object',
             properties: {
                 status: { type: 'string', description: 'Filter by status' },
-                limit: { type: 'number', description: 'Max workflows to return' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            let workflows = Object.values(store.workflows);
-            // Apply filters
-            if (input.status) {
-                workflows = workflows.filter(w => w.status === input.status);
+                limit: { type: 'number', description: 'Max workflows to return' }
             }
-            // Sort by creation date (newest first)
-            workflows.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-            // Apply limit
-            const limit = input.limit || 20;
-            workflows = workflows.slice(0, limit);
-            return {
-                workflows: workflows.map(w => ({
-                    workflowId: w.workflowId,
-                    name: w.name,
-                    status: w.status,
-                    stepCount: w.steps.length,
-                    createdAt: w.createdAt,
-                    completedAt: w.completedAt,
-                })),
-                total: workflows.length,
-                filters: { status: input.status },
-            };
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflows, limit;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflows = Object.values(store.workflows);
+                // Apply filters
+                if (input.status) {
+                    workflows = workflows.filter(function (w) { return w.status === input.status; });
+                }
+                // Sort by creation date (newest first)
+                workflows.sort(function (a, b) { return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(); });
+                limit = input.limit || 20;
+                workflows = workflows.slice(0, limit);
+                return [2 /*return*/, {
+                        workflows: workflows.map(function (w) { return ({
+                            workflowId: w.workflowId,
+                            name: w.name,
+                            status: w.status,
+                            stepCount: w.steps.length,
+                            createdAt: w.createdAt,
+                            completedAt: w.completedAt
+                        }); }),
+                        total: workflows.length,
+                        filters: { status: input.status }
+                    }];
+            });
+        }); }
     },
     {
         name: 'workflow_pause',
@@ -248,29 +391,32 @@ export const workflowTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                workflowId: { type: 'string', description: 'Workflow ID' },
+                workflowId: { type: 'string', description: 'Workflow ID' }
             },
-            required: ['workflowId'],
-        },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const workflowId = input.workflowId;
-            const workflow = store.workflows[workflowId];
-            if (!workflow) {
-                return { workflowId, error: 'Workflow not found' };
-            }
-            if (workflow.status !== 'running') {
-                return { workflowId, error: 'Workflow not running' };
-            }
-            workflow.status = 'paused';
-            saveWorkflowStore(store);
-            return {
-                workflowId,
-                status: workflow.status,
-                pausedAt: new Date().toISOString(),
-                currentStep: workflow.currentStep,
-            };
+            required: ['workflowId']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, workflow;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflowId = input.workflowId;
+                workflow = store.workflows[workflowId];
+                if (!workflow) {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not found' }];
+                }
+                if (workflow.status !== 'running') {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not running' }];
+                }
+                workflow.status = 'paused';
+                saveWorkflowStore(store);
+                return [2 /*return*/, {
+                        workflowId: workflowId,
+                        status: workflow.status,
+                        pausedAt: new Date().toISOString(),
+                        currentStep: workflow.currentStep
+                    }];
+            });
+        }); }
     },
     {
         name: 'workflow_resume',
@@ -279,45 +425,47 @@ export const workflowTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                workflowId: { type: 'string', description: 'Workflow ID' },
+                workflowId: { type: 'string', description: 'Workflow ID' }
             },
-            required: ['workflowId'],
-        },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const workflowId = input.workflowId;
-            const workflow = store.workflows[workflowId];
-            if (!workflow) {
-                return { workflowId, error: 'Workflow not found' };
-            }
-            if (workflow.status !== 'paused') {
-                return { workflowId, error: 'Workflow not paused' };
-            }
-            workflow.status = 'running';
-            saveWorkflowStore(store);
-            // Continue execution from current step
-            const results = [];
-            for (let i = workflow.currentStep; i < workflow.steps.length; i++) {
-                const step = workflow.steps[i];
-                step.status = 'running';
-                step.startedAt = new Date().toISOString();
-                step.status = 'completed';
-                step.completedAt = new Date().toISOString();
-                step.result = { executed: true };
-                results.push({ stepId: step.stepId, status: step.status });
-                workflow.currentStep = i + 1;
-            }
-            workflow.status = 'completed';
-            workflow.completedAt = new Date().toISOString();
-            saveWorkflowStore(store);
-            return {
-                workflowId,
-                status: workflow.status,
-                resumed: true,
-                stepsExecuted: results.length,
-                completedAt: workflow.completedAt,
-            };
+            required: ['workflowId']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, workflow, results, i, step;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflowId = input.workflowId;
+                workflow = store.workflows[workflowId];
+                if (!workflow) {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not found' }];
+                }
+                if (workflow.status !== 'paused') {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not paused' }];
+                }
+                workflow.status = 'running';
+                saveWorkflowStore(store);
+                results = [];
+                for (i = workflow.currentStep; i < workflow.steps.length; i++) {
+                    step = workflow.steps[i];
+                    step.status = 'running';
+                    step.startedAt = new Date().toISOString();
+                    step.status = 'completed';
+                    step.completedAt = new Date().toISOString();
+                    step.result = { executed: true };
+                    results.push({ stepId: step.stepId, status: step.status });
+                    workflow.currentStep = i + 1;
+                }
+                workflow.status = 'completed';
+                workflow.completedAt = new Date().toISOString();
+                saveWorkflowStore(store);
+                return [2 /*return*/, {
+                        workflowId: workflowId,
+                        status: workflow.status,
+                        resumed: true,
+                        stepsExecuted: results.length,
+                        completedAt: workflow.completedAt
+                    }];
+            });
+        }); }
     },
     {
         name: 'workflow_cancel',
@@ -327,36 +475,39 @@ export const workflowTools = [
             type: 'object',
             properties: {
                 workflowId: { type: 'string', description: 'Workflow ID' },
-                reason: { type: 'string', description: 'Cancellation reason' },
+                reason: { type: 'string', description: 'Cancellation reason' }
             },
-            required: ['workflowId'],
-        },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const workflowId = input.workflowId;
-            const workflow = store.workflows[workflowId];
-            if (!workflow) {
-                return { workflowId, error: 'Workflow not found' };
-            }
-            if (workflow.status === 'completed' || workflow.status === 'failed') {
-                return { workflowId, error: 'Workflow already finished' };
-            }
-            workflow.status = 'failed';
-            workflow.error = input.reason || 'Cancelled by user';
-            workflow.completedAt = new Date().toISOString();
-            // Mark remaining steps as skipped
-            for (let i = workflow.currentStep; i < workflow.steps.length; i++) {
-                workflow.steps[i].status = 'skipped';
-            }
-            saveWorkflowStore(store);
-            return {
-                workflowId,
-                status: workflow.status,
-                cancelledAt: workflow.completedAt,
-                reason: workflow.error,
-                skippedSteps: workflow.steps.length - workflow.currentStep,
-            };
+            required: ['workflowId']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, workflow, i;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflowId = input.workflowId;
+                workflow = store.workflows[workflowId];
+                if (!workflow) {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not found' }];
+                }
+                if (workflow.status === 'completed' || workflow.status === 'failed') {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow already finished' }];
+                }
+                workflow.status = 'failed';
+                workflow.error = input.reason || 'Cancelled by user';
+                workflow.completedAt = new Date().toISOString();
+                // Mark remaining steps as skipped
+                for (i = workflow.currentStep; i < workflow.steps.length; i++) {
+                    workflow.steps[i].status = 'skipped';
+                }
+                saveWorkflowStore(store);
+                return [2 /*return*/, {
+                        workflowId: workflowId,
+                        status: workflow.status,
+                        cancelledAt: workflow.completedAt,
+                        reason: workflow.error,
+                        skippedSteps: workflow.steps.length - workflow.currentStep
+                    }];
+            });
+        }); }
     },
     {
         name: 'workflow_delete',
@@ -365,28 +516,31 @@ export const workflowTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                workflowId: { type: 'string', description: 'Workflow ID' },
+                workflowId: { type: 'string', description: 'Workflow ID' }
             },
-            required: ['workflowId'],
-        },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const workflowId = input.workflowId;
-            if (!store.workflows[workflowId]) {
-                return { workflowId, error: 'Workflow not found' };
-            }
-            const workflow = store.workflows[workflowId];
-            if (workflow.status === 'running') {
-                return { workflowId, error: 'Cannot delete running workflow' };
-            }
-            delete store.workflows[workflowId];
-            saveWorkflowStore(store);
-            return {
-                workflowId,
-                deleted: true,
-                deletedAt: new Date().toISOString(),
-            };
+            required: ['workflowId']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, workflow;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                workflowId = input.workflowId;
+                if (!store.workflows[workflowId]) {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Workflow not found' }];
+                }
+                workflow = store.workflows[workflowId];
+                if (workflow.status === 'running') {
+                    return [2 /*return*/, { workflowId: workflowId, error: 'Cannot delete running workflow' }];
+                }
+                delete store.workflows[workflowId];
+                saveWorkflowStore(store);
+                return [2 /*return*/, {
+                        workflowId: workflowId,
+                        deleted: true,
+                        deletedAt: new Date().toISOString()
+                    }];
+            });
+        }); }
     },
     {
         name: 'workflow_template',
@@ -395,87 +549,69 @@ export const workflowTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', enum: ['save', 'create', 'list'], description: 'Template action' },
+                action: { type: 'string', "enum": ['save', 'create', 'list'], description: 'Template action' },
                 workflowId: { type: 'string', description: 'Workflow ID (for save)' },
                 templateId: { type: 'string', description: 'Template ID (for create)' },
                 templateName: { type: 'string', description: 'Template name (for save)' },
-                newName: { type: 'string', description: 'New workflow name (for create)' },
+                newName: { type: 'string', description: 'New workflow name (for create)' }
             },
-            required: ['action'],
+            required: ['action']
         },
-        handler: async (input) => {
-            const store = loadWorkflowStore();
-            const action = input.action;
-            if (action === 'save') {
-                const workflow = store.workflows[input.workflowId];
-                if (!workflow) {
-                    return { action, error: 'Workflow not found' };
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, action, workflow, templateId, template, template, workflowId, workflow;
+            return __generator(this, function (_a) {
+                store = loadWorkflowStore();
+                action = input.action;
+                if (action === 'save') {
+                    workflow = store.workflows[input.workflowId];
+                    if (!workflow) {
+                        return [2 /*return*/, { action: action, error: 'Workflow not found' }];
+                    }
+                    templateId = "template-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
+                    template = __assign(__assign({}, workflow), { workflowId: templateId, name: input.templateName || workflow.name + " Template", status: 'draft', currentStep: 0, createdAt: new Date().toISOString(), startedAt: undefined, completedAt: undefined });
+                    // Reset step statuses
+                    template.steps = template.steps.map(function (s) { return (__assign(__assign({}, s), { status: 'pending', result: undefined, startedAt: undefined, completedAt: undefined })); });
+                    store.templates[templateId] = template;
+                    saveWorkflowStore(store);
+                    return [2 /*return*/, {
+                            action: action,
+                            templateId: templateId,
+                            name: template.name,
+                            savedAt: new Date().toISOString()
+                        }];
                 }
-                const templateId = `template-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-                const template = {
-                    ...workflow,
-                    workflowId: templateId,
-                    name: input.templateName || `${workflow.name} Template`,
-                    status: 'draft',
-                    currentStep: 0,
-                    createdAt: new Date().toISOString(),
-                    startedAt: undefined,
-                    completedAt: undefined,
-                };
-                // Reset step statuses
-                template.steps = template.steps.map(s => ({
-                    ...s,
-                    status: 'pending',
-                    result: undefined,
-                    startedAt: undefined,
-                    completedAt: undefined,
-                }));
-                store.templates[templateId] = template;
-                saveWorkflowStore(store);
-                return {
-                    action,
-                    templateId,
-                    name: template.name,
-                    savedAt: new Date().toISOString(),
-                };
-            }
-            if (action === 'create') {
-                const template = store.templates[input.templateId];
-                if (!template) {
-                    return { action, error: 'Template not found' };
+                if (action === 'create') {
+                    template = store.templates[input.templateId];
+                    if (!template) {
+                        return [2 /*return*/, { action: action, error: 'Template not found' }];
+                    }
+                    workflowId = "workflow-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
+                    workflow = __assign(__assign({}, template), { workflowId: workflowId, name: input.newName || template.name.replace(' Template', ''), status: 'ready', createdAt: new Date().toISOString() });
+                    store.workflows[workflowId] = workflow;
+                    saveWorkflowStore(store);
+                    return [2 /*return*/, {
+                            action: action,
+                            workflowId: workflowId,
+                            name: workflow.name,
+                            fromTemplate: input.templateId,
+                            createdAt: workflow.createdAt
+                        }];
                 }
-                const workflowId = `workflow-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-                const workflow = {
-                    ...template,
-                    workflowId,
-                    name: input.newName || template.name.replace(' Template', ''),
-                    status: 'ready',
-                    createdAt: new Date().toISOString(),
-                };
-                store.workflows[workflowId] = workflow;
-                saveWorkflowStore(store);
-                return {
-                    action,
-                    workflowId,
-                    name: workflow.name,
-                    fromTemplate: input.templateId,
-                    createdAt: workflow.createdAt,
-                };
-            }
-            if (action === 'list') {
-                return {
-                    action,
-                    templates: Object.values(store.templates).map(t => ({
-                        templateId: t.workflowId,
-                        name: t.name,
-                        stepCount: t.steps.length,
-                        createdAt: t.createdAt,
-                    })),
-                    total: Object.keys(store.templates).length,
-                };
-            }
-            return { action, error: 'Unknown action' };
-        },
+                if (action === 'list') {
+                    return [2 /*return*/, {
+                            action: action,
+                            templates: Object.values(store.templates).map(function (t) { return ({
+                                templateId: t.workflowId,
+                                name: t.name,
+                                stepCount: t.steps.length,
+                                createdAt: t.createdAt
+                            }); }),
+                            total: Object.keys(store.templates).length
+                        }];
+                }
+                return [2 /*return*/, { action: action, error: 'Unknown action' }];
+            });
+        }); }
     },
 ];
 //# sourceMappingURL=workflow-tools.js.map