kynjal-cli 3.1.3 → 4.0.0

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

@@ -8,12 +8,48 @@
  * - No distributed network communication
  * - Useful for workflow orchestration and state tracking
  */
+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 DAA_DIR = 'daa';
-const DAA_FILE = 'store.json';
+var STORAGE_DIR = '.claude-flow';
+var DAA_DIR = 'daa';
+var DAA_FILE = 'store.json';
 function getDAADir() {
     return join(process.cwd(), STORAGE_DIR, DAA_DIR);
 }
@@ -21,19 +57,19 @@ function getDAAPath() {
     return join(getDAADir(), DAA_FILE);
 }
 function ensureDAADir() {
-    const dir = getDAADir();
+    var dir = getDAADir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadDAAStore() {
     try {
-        const path = getDAAPath();
+        var path = getDAAPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (_a) {
         // Return empty store
     }
     return { agents: {}, workflows: {}, knowledge: {}, version: '3.0.0' };
@@ -42,7 +78,7 @@ function saveDAAStore(store) {
     ensureDAADir();
     writeFileSync(getDAAPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export const daaTools = [
+export var daaTools = [
     {
         name: 'daa_agent_create',
         description: 'Create a decentralized autonomous agent',
@@ -53,48 +89,52 @@ export const daaTools = [
                 id: { type: 'string', description: 'Agent ID' },
                 name: { type: 'string', description: 'Agent name' },
                 type: { type: 'string', description: 'Agent type' },
-                cognitivePattern: { type: 'string', enum: ['convergent', 'divergent', 'lateral', 'systems', 'critical', 'adaptive'], description: 'Cognitive pattern' },
+                cognitivePattern: { type: 'string', "enum": ['convergent', 'divergent', 'lateral', 'systems', 'critical', 'adaptive'], description: 'Cognitive pattern' },
                 learningRate: { type: 'number', description: 'Learning rate (0-1)' },
                 enableMemory: { type: 'boolean', description: 'Enable persistent memory' },
-                capabilities: { type: 'array', description: 'Agent capabilities' },
+                capabilities: { type: 'array', items: { type: 'string' }, description: 'Agent capabilities' }
             },
-            required: ['id'],
-        },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const id = input.id;
-            const agent = {
-                id,
-                name: input.name || `DAA-${id}`,
-                type: input.type || 'autonomous',
-                status: 'active',
-                cognitivePattern: input.cognitivePattern || 'adaptive',
-                learningRate: input.learningRate || 0.01,
-                memory: input.enableMemory ?? true,
-                capabilities: input.capabilities || ['reasoning', 'learning'],
-                metrics: {
-                    tasksCompleted: 0,
-                    successRate: 1.0,
-                    adaptations: 0,
-                },
-                createdAt: new Date().toISOString(),
-                lastActivity: new Date().toISOString(),
-            };
-            store.agents[id] = agent;
-            saveDAAStore(store);
-            return {
-                success: true,
-                agent: {
-                    id: agent.id,
-                    name: agent.name,
-                    type: agent.type,
-                    status: agent.status,
-                    cognitivePattern: agent.cognitivePattern,
-                    capabilities: agent.capabilities,
-                },
-                createdAt: agent.createdAt,
-            };
+            required: ['id']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, id, agent;
+            var _a;
+            return __generator(this, function (_b) {
+                store = loadDAAStore();
+                id = input.id;
+                agent = {
+                    id: id,
+                    name: input.name || "DAA-" + id,
+                    type: input.type || 'autonomous',
+                    status: 'active',
+                    cognitivePattern: input.cognitivePattern || 'adaptive',
+                    learningRate: input.learningRate || 0.01,
+                    memory: (_a = input.enableMemory) !== null && _a !== void 0 ? _a : true,
+                    capabilities: input.capabilities || ['reasoning', 'learning'],
+                    metrics: {
+                        tasksCompleted: 0,
+                        successRate: 1.0,
+                        adaptations: 0
+                    },
+                    createdAt: new Date().toISOString(),
+                    lastActivity: new Date().toISOString()
+                };
+                store.agents[id] = agent;
+                saveDAAStore(store);
+                return [2 /*return*/, {
+                        success: true,
+                        agent: {
+                            id: agent.id,
+                            name: agent.name,
+                            type: agent.type,
+                            status: agent.status,
+                            cognitivePattern: agent.cognitivePattern,
+                            capabilities: agent.capabilities
+                        },
+                        createdAt: agent.createdAt
+                    }];
+            });
+        }); }
     },
     {
         name: 'daa_agent_adapt',
@@ -106,39 +146,48 @@ export const daaTools = [
                 agentId: { type: 'string', description: 'Agent ID' },
                 feedback: { type: 'string', description: 'Feedback message' },
                 performanceScore: { type: 'number', description: 'Performance score (0-1)' },
-                suggestions: { type: 'array', description: 'Improvement suggestions' },
+                suggestions: { type: 'array', items: { type: 'string' }, description: 'Improvement suggestions' }
             },
-            required: ['agentId'],
-        },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const agentId = input.agentId;
-            const agent = store.agents[agentId];
-            if (!agent) {
-                return { success: false, error: 'Agent not found' };
-            }
-            const performanceScore = input.performanceScore || 0.8;
-            // Update agent metrics
-            agent.metrics.adaptations++;
-            agent.metrics.successRate = (agent.metrics.successRate + performanceScore) / 2;
-            agent.lastActivity = new Date().toISOString();
-            agent.status = 'learning';
-            // Simulate adaptation delay
-            await new Promise(resolve => setTimeout(resolve, 50));
-            agent.status = 'active';
-            saveDAAStore(store);
-            return {
-                success: true,
-                agentId,
-                adaptation: {
-                    feedback: input.feedback,
-                    performanceScore,
-                    adaptations: agent.metrics.adaptations,
-                    newSuccessRate: agent.metrics.successRate,
-                },
-                status: agent.status,
-            };
+            required: ['agentId']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, agentId, agent, performanceScore;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        store = loadDAAStore();
+                        agentId = input.agentId;
+                        agent = store.agents[agentId];
+                        if (!agent) {
+                            return [2 /*return*/, { success: false, error: 'Agent not found' }];
+                        }
+                        performanceScore = input.performanceScore || 0.8;
+                        // Update agent metrics
+                        agent.metrics.adaptations++;
+                        agent.metrics.successRate = (agent.metrics.successRate + performanceScore) / 2;
+                        agent.lastActivity = new Date().toISOString();
+                        agent.status = 'learning';
+                        // Simulate adaptation delay
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 50); })];
+                    case 1:
+                        // Simulate adaptation delay
+                        _a.sent();
+                        agent.status = 'active';
+                        saveDAAStore(store);
+                        return [2 /*return*/, {
+                                success: true,
+                                agentId: agentId,
+                                adaptation: {
+                                    feedback: input.feedback,
+                                    performanceScore: performanceScore,
+                                    adaptations: agent.metrics.adaptations,
+                                    newSuccessRate: agent.metrics.successRate
+                                },
+                                status: agent.status
+                            }];
+                }
+            });
+        }); }
     },
     {
         name: 'daa_workflow_create',
@@ -149,37 +198,40 @@ export const daaTools = [
             properties: {
                 id: { type: 'string', description: 'Workflow ID' },
                 name: { type: 'string', description: 'Workflow name' },
-                steps: { type: 'array', description: 'Workflow steps' },
-                strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive'], description: 'Execution strategy' },
-                dependencies: { type: 'object', description: 'Step dependencies' },
+                steps: { type: 'array', items: { type: 'object' }, description: 'Workflow steps' },
+                strategy: { type: 'string', "enum": ['parallel', 'sequential', 'adaptive'], description: 'Execution strategy' },
+                dependencies: { type: 'object', description: 'Step dependencies' }
             },
-            required: ['id', 'name'],
+            required: ['id', 'name']
         },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const id = input.id;
-            const workflow = {
-                id,
-                name: input.name,
-                status: 'pending',
-                steps: (input.steps || []).map((s, i) => ({
-                    name: typeof s === 'string' ? s : `Step ${i + 1}`,
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, id, workflow;
+            return __generator(this, function (_a) {
+                store = loadDAAStore();
+                id = input.id;
+                workflow = {
+                    id: id,
+                    name: input.name,
                     status: 'pending',
-                })),
-                strategy: input.strategy || 'adaptive',
-                createdAt: new Date().toISOString(),
-            };
-            store.workflows[id] = workflow;
-            saveDAAStore(store);
-            return {
-                success: true,
-                workflowId: id,
-                name: workflow.name,
-                steps: workflow.steps.length,
-                strategy: workflow.strategy,
-                createdAt: workflow.createdAt,
-            };
-        },
+                    steps: (input.steps || []).map(function (s, i) { return ({
+                        name: typeof s === 'string' ? s : "Step " + (i + 1),
+                        status: 'pending'
+                    }); }),
+                    strategy: input.strategy || 'adaptive',
+                    createdAt: new Date().toISOString()
+                };
+                store.workflows[id] = workflow;
+                saveDAAStore(store);
+                return [2 /*return*/, {
+                        success: true,
+                        workflowId: id,
+                        name: workflow.name,
+                        steps: workflow.steps.length,
+                        strategy: workflow.strategy,
+                        createdAt: workflow.createdAt
+                    }];
+            });
+        }); }
     },
     {
         name: 'daa_workflow_execute',
@@ -189,37 +241,52 @@ export const daaTools = [
             type: 'object',
             properties: {
                 workflowId: { type: 'string', description: 'Workflow ID' },
-                agentIds: { type: 'array', description: 'Agent IDs to use' },
-                parallelExecution: { type: 'boolean', description: 'Enable parallel execution' },
+                agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to use' },
+                parallelExecution: { type: 'boolean', description: 'Enable parallel execution' }
             },
-            required: ['workflowId'],
-        },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const workflowId = input.workflowId;
-            const workflow = store.workflows[workflowId];
-            if (!workflow) {
-                return { success: false, error: 'Workflow not found' };
-            }
-            workflow.status = 'running';
-            saveDAAStore(store);
-            // Simulate execution
-            for (const step of workflow.steps) {
-                step.status = 'running';
-                await new Promise(resolve => setTimeout(resolve, 10));
-                step.status = 'completed';
-                step.output = `Completed: ${step.name}`;
-            }
-            workflow.status = 'completed';
-            saveDAAStore(store);
-            return {
-                success: true,
-                workflowId,
-                status: workflow.status,
-                steps: workflow.steps,
-                completedAt: new Date().toISOString(),
-            };
+            required: ['workflowId']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, workflowId, workflow, _i, _a, step;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        store = loadDAAStore();
+                        workflowId = input.workflowId;
+                        workflow = store.workflows[workflowId];
+                        if (!workflow) {
+                            return [2 /*return*/, { success: false, error: 'Workflow not found' }];
+                        }
+                        workflow.status = 'running';
+                        saveDAAStore(store);
+                        _i = 0, _a = workflow.steps;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        step = _a[_i];
+                        step.status = 'running';
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
+                    case 2:
+                        _b.sent();
+                        step.status = 'completed';
+                        step.output = "Completed: " + step.name;
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        workflow.status = 'completed';
+                        saveDAAStore(store);
+                        return [2 /*return*/, {
+                                success: true,
+                                workflowId: workflowId,
+                                status: workflow.status,
+                                steps: workflow.steps,
+                                completedAt: new Date().toISOString()
+                            }];
+                }
+            });
+        }); }
     },
     {
         name: 'daa_knowledge_share',
@@ -229,34 +296,37 @@ export const daaTools = [
             type: 'object',
             properties: {
                 sourceAgentId: { type: 'string', description: 'Source agent ID' },
-                targetAgentIds: { type: 'array', description: 'Target agent IDs' },
+                targetAgentIds: { type: 'array', items: { type: 'string' }, description: 'Target agent IDs' },
                 knowledgeDomain: { type: 'string', description: 'Knowledge domain' },
-                knowledgeContent: { type: 'object', description: 'Knowledge to share' },
+                knowledgeContent: { type: 'object', description: 'Knowledge to share' }
             },
-            required: ['sourceAgentId', 'targetAgentIds'],
-        },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const sourceId = input.sourceAgentId;
-            const targetIds = input.targetAgentIds;
-            const domain = input.knowledgeDomain || 'general';
-            const knowledgeId = `knowledge-${Date.now()}`;
-            store.knowledge[knowledgeId] = {
-                domain,
-                content: input.knowledgeContent || {},
-                sharedBy: sourceId,
-                timestamp: new Date().toISOString(),
-            };
-            saveDAAStore(store);
-            return {
-                success: true,
-                knowledgeId,
-                sourceAgent: sourceId,
-                targetAgents: targetIds,
-                domain,
-                sharedAt: new Date().toISOString(),
-            };
+            required: ['sourceAgentId', 'targetAgentIds']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, sourceId, targetIds, domain, knowledgeId;
+            return __generator(this, function (_a) {
+                store = loadDAAStore();
+                sourceId = input.sourceAgentId;
+                targetIds = input.targetAgentIds;
+                domain = input.knowledgeDomain || 'general';
+                knowledgeId = "knowledge-" + Date.now();
+                store.knowledge[knowledgeId] = {
+                    domain: domain,
+                    content: input.knowledgeContent || {},
+                    sharedBy: sourceId,
+                    timestamp: new Date().toISOString()
+                };
+                saveDAAStore(store);
+                return [2 /*return*/, {
+                        success: true,
+                        knowledgeId: knowledgeId,
+                        sourceAgent: sourceId,
+                        targetAgents: targetIds,
+                        domain: domain,
+                        sharedAt: new Date().toISOString()
+                    }];
+            });
+        }); }
     },
     {
         name: 'daa_learning_status',
@@ -266,48 +336,51 @@ export const daaTools = [
             type: 'object',
             properties: {
                 agentId: { type: 'string', description: 'Specific agent ID' },
-                detailed: { type: 'boolean', description: 'Include detailed metrics' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const agentId = input.agentId;
-            if (agentId) {
-                const agent = store.agents[agentId];
-                if (!agent) {
-                    return { success: false, error: 'Agent not found' };
-                }
-                return {
-                    success: true,
-                    agent: {
-                        id: agent.id,
-                        status: agent.status,
-                        cognitivePattern: agent.cognitivePattern,
-                        learningRate: agent.learningRate,
-                        metrics: agent.metrics,
-                    },
-                };
+                detailed: { type: 'boolean', description: 'Include detailed metrics' }
             }
-            const agents = Object.values(store.agents);
-            return {
-                success: true,
-                summary: {
-                    total: agents.length,
-                    active: agents.filter(a => a.status === 'active').length,
-                    learning: agents.filter(a => a.status === 'learning').length,
-                    avgSuccessRate: agents.length > 0
-                        ? agents.reduce((sum, a) => sum + a.metrics.successRate, 0) / agents.length
-                        : 0,
-                    totalAdaptations: agents.reduce((sum, a) => sum + a.metrics.adaptations, 0),
-                },
-                agents: agents.map(a => ({
-                    id: a.id,
-                    status: a.status,
-                    successRate: a.metrics.successRate,
-                    adaptations: a.metrics.adaptations,
-                })),
-            };
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, agentId, agent, agents;
+            return __generator(this, function (_a) {
+                store = loadDAAStore();
+                agentId = input.agentId;
+                if (agentId) {
+                    agent = store.agents[agentId];
+                    if (!agent) {
+                        return [2 /*return*/, { success: false, error: 'Agent not found' }];
+                    }
+                    return [2 /*return*/, {
+                            success: true,
+                            agent: {
+                                id: agent.id,
+                                status: agent.status,
+                                cognitivePattern: agent.cognitivePattern,
+                                learningRate: agent.learningRate,
+                                metrics: agent.metrics
+                            }
+                        }];
+                }
+                agents = Object.values(store.agents);
+                return [2 /*return*/, {
+                        success: true,
+                        summary: {
+                            total: agents.length,
+                            active: agents.filter(function (a) { return a.status === 'active'; }).length,
+                            learning: agents.filter(function (a) { return a.status === 'learning'; }).length,
+                            avgSuccessRate: agents.length > 0
+                                ? agents.reduce(function (sum, a) { return sum + a.metrics.successRate; }, 0) / agents.length
+                                : 0,
+                            totalAdaptations: agents.reduce(function (sum, a) { return sum + a.metrics.adaptations; }, 0)
+                        },
+                        agents: agents.map(function (a) { return ({
+                            id: a.id,
+                            status: a.status,
+                            successRate: a.metrics.successRate,
+                            adaptations: a.metrics.adaptations
+                        }); })
+                    }];
+            });
+        }); }
     },
     {
         name: 'daa_cognitive_pattern',
@@ -317,59 +390,61 @@ export const daaTools = [
             type: 'object',
             properties: {
                 agentId: { type: 'string', description: 'Agent ID' },
-                action: { type: 'string', enum: ['analyze', 'change'], description: 'Action' },
-                pattern: { type: 'string', enum: ['convergent', 'divergent', 'lateral', 'systems', 'critical', 'adaptive'], description: 'New pattern' },
-            },
+                action: { type: 'string', "enum": ['analyze', 'change'], description: 'Action' },
+                pattern: { type: 'string', "enum": ['convergent', 'divergent', 'lateral', 'systems', 'critical', 'adaptive'], description: 'New pattern' }
+            }
         },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const agentId = input.agentId;
-            const action = input.action || 'analyze';
-            if (agentId) {
-                const agent = store.agents[agentId];
-                if (!agent) {
-                    return { success: false, error: 'Agent not found' };
-                }
-                if (action === 'analyze') {
-                    return {
-                        success: true,
-                        agentId,
-                        currentPattern: agent.cognitivePattern,
-                        analysis: {
-                            strengths: ['Pattern recognition', 'Adaptive learning'],
-                            weaknesses: ['May be slow for simple tasks'],
-                            recommendations: ['Consider convergent for focused tasks'],
-                        },
-                    };
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, agentId, action, agent, oldPattern, patternDescriptions;
+            return __generator(this, function (_a) {
+                store = loadDAAStore();
+                agentId = input.agentId;
+                action = input.action || 'analyze';
+                if (agentId) {
+                    agent = store.agents[agentId];
+                    if (!agent) {
+                        return [2 /*return*/, { success: false, error: 'Agent not found' }];
+                    }
+                    if (action === 'analyze') {
+                        return [2 /*return*/, {
+                                success: true,
+                                agentId: agentId,
+                                currentPattern: agent.cognitivePattern,
+                                analysis: {
+                                    strengths: ['Pattern recognition', 'Adaptive learning'],
+                                    weaknesses: ['May be slow for simple tasks'],
+                                    recommendations: ['Consider convergent for focused tasks']
+                                }
+                            }];
+                    }
+                    if (action === 'change' && input.pattern) {
+                        oldPattern = agent.cognitivePattern;
+                        agent.cognitivePattern = input.pattern;
+                        saveDAAStore(store);
+                        return [2 /*return*/, {
+                                success: true,
+                                agentId: agentId,
+                                previousPattern: oldPattern,
+                                newPattern: agent.cognitivePattern,
+                                changedAt: new Date().toISOString()
+                            }];
+                    }
                 }
-                if (action === 'change' && input.pattern) {
-                    const oldPattern = agent.cognitivePattern;
-                    agent.cognitivePattern = input.pattern;
-                    saveDAAStore(store);
-                    return {
+                patternDescriptions = {
+                    convergent: 'Focused, analytical thinking for well-defined problems',
+                    divergent: 'Creative, exploratory thinking for open-ended problems',
+                    lateral: 'Indirect, creative approach to problem solving',
+                    systems: 'Holistic thinking considering interconnections',
+                    critical: 'Analytical evaluation and logical assessment',
+                    adaptive: 'Dynamic switching between patterns as needed'
+                };
+                return [2 /*return*/, {
                         success: true,
-                        agentId,
-                        previousPattern: oldPattern,
-                        newPattern: agent.cognitivePattern,
-                        changedAt: new Date().toISOString(),
-                    };
-                }
-            }
-            // Return general pattern info
-            const patternDescriptions = {
-                convergent: 'Focused, analytical thinking for well-defined problems',
-                divergent: 'Creative, exploratory thinking for open-ended problems',
-                lateral: 'Indirect, creative approach to problem solving',
-                systems: 'Holistic thinking considering interconnections',
-                critical: 'Analytical evaluation and logical assessment',
-                adaptive: 'Dynamic switching between patterns as needed',
-            };
-            return {
-                success: true,
-                patterns: patternDescriptions,
-                recommendation: 'Use "adaptive" for general-purpose agents',
-            };
-        },
+                        patterns: patternDescriptions,
+                        recommendation: 'Use "adaptive" for general-purpose agents'
+                    }];
+            });
+        }); }
     },
     {
         name: 'daa_performance_metrics',
@@ -378,49 +453,52 @@ export const daaTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                category: { type: 'string', enum: ['all', 'agents', 'workflows', 'learning'], description: 'Metrics category' },
-                timeRange: { type: 'string', description: 'Time range' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadDAAStore();
-            const category = input.category || 'all';
-            const agents = Object.values(store.agents);
-            const workflows = Object.values(store.workflows);
-            const metrics = {
-                agents: {
-                    total: agents.length,
-                    active: agents.filter(a => a.status === 'active').length,
-                    avgSuccessRate: agents.length > 0
-                        ? agents.reduce((sum, a) => sum + a.metrics.successRate, 0) / agents.length
-                        : 0,
-                    totalTasks: agents.reduce((sum, a) => sum + a.metrics.tasksCompleted, 0),
-                },
-                workflows: {
-                    total: workflows.length,
-                    completed: workflows.filter(w => w.status === 'completed').length,
-                    running: workflows.filter(w => w.status === 'running').length,
-                    successRate: workflows.length > 0
-                        ? workflows.filter(w => w.status === 'completed').length / workflows.length
-                        : 0,
-                },
-                learning: {
-                    totalAdaptations: agents.reduce((sum, a) => sum + a.metrics.adaptations, 0),
-                    knowledgeItems: Object.keys(store.knowledge).length,
-                    avgLearningRate: agents.length > 0
-                        ? agents.reduce((sum, a) => sum + a.learningRate, 0) / agents.length
-                        : 0,
-                },
-            };
-            if (category === 'all') {
-                return { success: true, metrics };
+                category: { type: 'string', "enum": ['all', 'agents', 'workflows', 'learning'], description: 'Metrics category' },
+                timeRange: { type: 'string', description: 'Time range' }
             }
-            return {
-                success: true,
-                category,
-                metrics: metrics[category],
-            };
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, category, agents, workflows, metrics;
+            return __generator(this, function (_a) {
+                store = loadDAAStore();
+                category = input.category || 'all';
+                agents = Object.values(store.agents);
+                workflows = Object.values(store.workflows);
+                metrics = {
+                    agents: {
+                        total: agents.length,
+                        active: agents.filter(function (a) { return a.status === 'active'; }).length,
+                        avgSuccessRate: agents.length > 0
+                            ? agents.reduce(function (sum, a) { return sum + a.metrics.successRate; }, 0) / agents.length
+                            : 0,
+                        totalTasks: agents.reduce(function (sum, a) { return sum + a.metrics.tasksCompleted; }, 0)
+                    },
+                    workflows: {
+                        total: workflows.length,
+                        completed: workflows.filter(function (w) { return w.status === 'completed'; }).length,
+                        running: workflows.filter(function (w) { return w.status === 'running'; }).length,
+                        successRate: workflows.length > 0
+                            ? workflows.filter(function (w) { return w.status === 'completed'; }).length / workflows.length
+                            : 0
+                    },
+                    learning: {
+                        totalAdaptations: agents.reduce(function (sum, a) { return sum + a.metrics.adaptations; }, 0),
+                        knowledgeItems: Object.keys(store.knowledge).length,
+                        avgLearningRate: agents.length > 0
+                            ? agents.reduce(function (sum, a) { return sum + a.learningRate; }, 0) / agents.length
+                            : 0
+                    }
+                };
+                if (category === 'all') {
+                    return [2 /*return*/, { success: true, metrics: metrics }];
+                }
+                return [2 /*return*/, {
+                        success: true,
+                        category: category,
+                        metrics: metrics[category]
+                    }];
+            });
+        }); }
     },
 ];
 //# sourceMappingURL=daa-tools.js.map