kynjal-cli 4.0.0 → 4.0.1

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

@@ -8,48 +8,12 @@
  * - 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
-var STORAGE_DIR = '.claude-flow';
-var DAA_DIR = 'daa';
-var DAA_FILE = 'store.json';
+const STORAGE_DIR = '.claude-flow';
+const DAA_DIR = 'daa';
+const DAA_FILE = 'store.json';
 function getDAADir() {
     return join(process.cwd(), STORAGE_DIR, DAA_DIR);
 }
@@ -57,19 +21,19 @@ function getDAAPath() {
     return join(getDAADir(), DAA_FILE);
 }
 function ensureDAADir() {
-    var dir = getDAADir();
+    const dir = getDAADir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadDAAStore() {
     try {
-        var path = getDAAPath();
+        const path = getDAAPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch (_a) {
+    catch {
         // Return empty store
     }
     return { agents: {}, workflows: {}, knowledge: {}, version: '3.0.0' };
@@ -78,7 +42,7 @@ function saveDAAStore(store) {
     ensureDAADir();
     writeFileSync(getDAAPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export var daaTools = [
+export const daaTools = [
     {
         name: 'daa_agent_create',
         description: 'Create a decentralized autonomous agent',
@@ -89,52 +53,48 @@ export var 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', items: { type: 'string' }, description: 'Agent capabilities' }
+                capabilities: { type: 'array', items: { type: 'string' }, description: 'Agent capabilities' },
             },
-            required: ['id']
+            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,
+            };
         },
-        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',
@@ -146,48 +106,39 @@ export var daaTools = [
                 agentId: { type: 'string', description: 'Agent ID' },
                 feedback: { type: 'string', description: 'Feedback message' },
                 performanceScore: { type: 'number', description: 'Performance score (0-1)' },
-                suggestions: { type: 'array', items: { type: 'string' }, description: 'Improvement suggestions' }
+                suggestions: { type: 'array', items: { type: 'string' }, description: 'Improvement suggestions' },
             },
-            required: ['agentId']
+            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,
+            };
         },
-        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',
@@ -199,39 +150,36 @@ export var daaTools = [
                 id: { type: 'string', description: 'Workflow ID' },
                 name: { type: 'string', description: 'Workflow name' },
                 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' }
+                strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive'], description: 'Execution strategy' },
+                dependencies: { type: 'object', description: 'Step dependencies' },
             },
-            required: ['id', 'name']
+            required: ['id', 'name'],
         },
-        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,
+        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}`,
                     status: 'pending',
-                    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
-                    }];
-            });
-        }); }
+                })),
+                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,
+            };
+        },
     },
     {
         name: 'daa_workflow_execute',
@@ -242,51 +190,36 @@ export var daaTools = [
             properties: {
                 workflowId: { type: 'string', description: 'Workflow ID' },
                 agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to use' },
-                parallelExecution: { type: 'boolean', description: 'Enable parallel execution' }
+                parallelExecution: { type: 'boolean', description: 'Enable parallel execution' },
             },
-            required: ['workflowId']
+            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(),
+            };
         },
-        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',
@@ -298,35 +231,32 @@ export var daaTools = [
                 sourceAgentId: { type: 'string', description: 'Source agent ID' },
                 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']
+            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(),
+            };
         },
-        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',
@@ -336,51 +266,48 @@ export var daaTools = [
             type: 'object',
             properties: {
                 agentId: { type: 'string', description: 'Specific agent ID' },
-                detailed: { type: 'boolean', description: 'Include detailed metrics' }
-            }
+                detailed: { type: 'boolean', description: 'Include detailed metrics' },
+            },
         },
-        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
-                            }
-                        }];
+        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' };
                 }
-                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
-                        }); })
-                    }];
-            });
-        }); }
+                return {
+                    success: true,
+                    agent: {
+                        id: agent.id,
+                        status: agent.status,
+                        cognitivePattern: agent.cognitivePattern,
+                        learningRate: agent.learningRate,
+                        metrics: agent.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,
+                })),
+            };
+        },
     },
     {
         name: 'daa_cognitive_pattern',
@@ -390,61 +317,59 @@ export var 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: 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()
-                            }];
-                    }
+        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' };
                 }
-                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*/, {
+                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'],
+                        },
+                    };
+                }
+                if (action === 'change' && input.pattern) {
+                    const oldPattern = agent.cognitivePattern;
+                    agent.cognitivePattern = input.pattern;
+                    saveDAAStore(store);
+                    return {
                         success: true,
-                        patterns: patternDescriptions,
-                        recommendation: 'Use "adaptive" for general-purpose agents'
-                    }];
-            });
-        }); }
+                        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',
+            };
+        },
     },
     {
         name: 'daa_performance_metrics',
@@ -453,52 +378,49 @@ export var daaTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                category: { type: 'string', "enum": ['all', 'agents', 'workflows', 'learning'], description: 'Metrics category' },
-                timeRange: { type: 'string', description: 'Time range' }
+                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 };
             }
+            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