@claude-flow/cli 3.32.3 → 3.32.4

package/dist/src/mcp-tools/daa-tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DAA (Decentralized Autonomous Agents) MCP Tools for CLI
+ *
+ * V2 Compatibility - DAA agent management tools
+ *
+ * ⚠️ IMPORTANT: These tools provide LOCAL STATE MANAGEMENT.
+ * - Agent coordination is tracked locally
+ * - No distributed network communication
+ * - Useful for workflow orchestration and state tracking
+ */
+import { type MCPTool } from './types.js';
+export declare const daaTools: MCPTool[];
+//# sourceMappingURL=daa-tools.d.ts.map

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

@@ -0,0 +1,534 @@
+/**
+ * DAA (Decentralized Autonomous Agents) MCP Tools for CLI
+ *
+ * V2 Compatibility - DAA agent management tools
+ *
+ * ⚠️ IMPORTANT: These tools provide LOCAL STATE MANAGEMENT.
+ * - Agent coordination is tracked locally
+ * - No distributed network communication
+ * - Useful for workflow orchestration and state tracking
+ */
+import { getProjectCwd } from './types.js';
+import { validateIdentifier, validateText } from './validate-input.js';
+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';
+function getDAADir() {
+    return join(getProjectCwd(), STORAGE_DIR, DAA_DIR);
+}
+function getDAAPath() {
+    return join(getDAADir(), DAA_FILE);
+}
+function ensureDAADir() {
+    const dir = getDAADir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+function loadDAAStore() {
+    try {
+        const path = getDAAPath();
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+    }
+    catch {
+        // Return empty store
+    }
+    return { agents: {}, workflows: {}, knowledge: {}, version: '3.0.0' };
+}
+function saveDAAStore(store) {
+    ensureDAADir();
+    writeFileSync(getDAAPath(), JSON.stringify(store, null, 2), 'utf-8');
+}
+export const daaTools = [
+    {
+        name: 'daa_agent_create',
+        description: 'Create a decentralized autonomous agent Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                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' },
+                learningRate: { type: 'number', description: 'Learning rate (0-1)' },
+                enableMemory: { type: 'boolean', description: 'Enable persistent memory' },
+                capabilities: { type: 'array', items: { type: 'string' }, description: 'Agent capabilities' },
+            },
+            required: ['id'],
+        },
+        handler: async (input) => {
+            const vId = validateIdentifier(input.id, 'id');
+            if (!vId.valid)
+                return { success: false, error: vId.error };
+            if (input.name) {
+                const vName = validateText(input.name, 'name');
+                if (!vName.valid)
+                    return { success: false, error: vName.error };
+            }
+            if (input.type) {
+                const vType = validateIdentifier(input.type, 'type');
+                if (!vType.valid)
+                    return { success: false, error: vType.error };
+            }
+            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);
+            // Store agent in AgentDB for searchable agent registry
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeStoreEntry({
+                    key: `daa-agent-${id}`,
+                    value: JSON.stringify({ id: agent.id, name: agent.name, type: agent.type, cognitivePattern: agent.cognitivePattern }),
+                    namespace: 'daa-agents',
+                    tags: [agent.type, agent.cognitivePattern],
+                });
+            }
+            catch { /* AgentDB not available */ }
+            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',
+        description: 'Trigger agent adaptation based on feedback Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                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' },
+            },
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const vAgentId = validateIdentifier(input.agentId, 'agentId');
+            if (!vAgentId.valid)
+                return { success: false, error: vAgentId.error };
+            if (input.feedback) {
+                const vFeedback = validateText(input.feedback, 'feedback');
+                if (!vFeedback.valid)
+                    return { success: false, error: vFeedback.error };
+            }
+            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 = 'active';
+            saveDAAStore(store);
+            // Store adaptation feedback in AgentDB for pattern learning (backward compat: JSON store above)
+            let _storedIn = 'json-store';
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeRecordFeedback({
+                    taskId: `adapt-${agentId}-${agent.metrics.adaptations}`,
+                    success: performanceScore >= 0.5,
+                    quality: performanceScore,
+                    agent: agentId,
+                });
+                _storedIn = 'agentdb';
+            }
+            catch { /* AgentDB not available */ }
+            return {
+                success: true,
+                agentId,
+                adaptation: {
+                    feedback: input.feedback,
+                    performanceScore,
+                    adaptations: agent.metrics.adaptations,
+                    newSuccessRate: agent.metrics.successRate,
+                },
+                status: agent.status,
+                _storedIn,
+            };
+        },
+    },
+    {
+        name: 'daa_workflow_create',
+        description: 'Create an autonomous workflow Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                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' },
+            },
+            required: ['id', 'name'],
+        },
+        handler: async (input) => {
+            const vId = validateIdentifier(input.id, 'id');
+            if (!vId.valid)
+                return { success: false, error: vId.error };
+            const vName = validateText(input.name, 'name');
+            if (!vName.valid)
+                return { success: false, error: vName.error };
+            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',
+                })),
+                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',
+        description: 'Execute a DAA workflow Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        inputSchema: {
+            type: 'object',
+            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' },
+            },
+            required: ['workflowId'],
+        },
+        handler: async (input) => {
+            const vWorkflowId = validateIdentifier(input.workflowId, 'workflowId');
+            if (!vWorkflowId.valid)
+                return { success: false, error: vWorkflowId.error };
+            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);
+            // Store workflow state in AgentDB for tracking
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeStoreEntry({
+                    key: `workflow-${workflowId}`,
+                    value: JSON.stringify({
+                        id: workflowId, status: 'running',
+                        steps: workflow.steps.length, strategy: workflow.strategy,
+                        startedAt: new Date().toISOString(),
+                    }),
+                    namespace: 'daa-workflows',
+                });
+            }
+            catch { /* AgentDB not available */ }
+            return {
+                success: true,
+                workflowId,
+                status: workflow.status,
+                steps: workflow.steps,
+                startedAt: new Date().toISOString(),
+                _note: 'Steps are tracked but not auto-executed. Use agent tools to execute each step.',
+            };
+        },
+    },
+    {
+        name: 'daa_knowledge_share',
+        description: 'Share knowledge between agents Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                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' },
+            },
+            required: ['sourceAgentId', 'targetAgentIds'],
+        },
+        handler: async (input) => {
+            const vSourceId = validateIdentifier(input.sourceAgentId, 'sourceAgentId');
+            if (!vSourceId.valid)
+                return { success: false, error: vSourceId.error };
+            if (input.targetAgentIds && Array.isArray(input.targetAgentIds)) {
+                for (const t of input.targetAgentIds) {
+                    const vT = validateIdentifier(t, 'targetAgentIds[]');
+                    if (!vT.valid)
+                        return { success: false, error: vT.error };
+                }
+            }
+            if (input.knowledgeDomain) {
+                const vDomain = validateIdentifier(input.knowledgeDomain, 'knowledgeDomain');
+                if (!vDomain.valid)
+                    return { success: false, error: vDomain.error };
+            }
+            const store = loadDAAStore();
+            const sourceId = input.sourceAgentId;
+            const targetIds = input.targetAgentIds;
+            const domain = input.knowledgeDomain || 'general';
+            const knowledgeId = `knowledge-${Date.now()}`;
+            const knowledgeEntry = {
+                domain,
+                content: input.knowledgeContent || {},
+                sharedBy: sourceId,
+                targetAgents: targetIds,
+                timestamp: new Date().toISOString(),
+            };
+            // Primary: store in AgentDB for vector-searchable knowledge
+            let _storedIn = 'json-store';
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                await bridge.bridgeStoreEntry({
+                    key: knowledgeId,
+                    value: JSON.stringify(knowledgeEntry),
+                    namespace: 'daa-knowledge',
+                    tags: [domain, sourceId, ...targetIds],
+                });
+                _storedIn = 'agentdb';
+            }
+            catch { /* AgentDB not available */ }
+            // Backward compat: always persist in JSON store
+            store.knowledge[knowledgeId] = knowledgeEntry;
+            saveDAAStore(store);
+            return {
+                success: true,
+                knowledgeId,
+                sourceAgent: sourceId,
+                targetAgents: targetIds,
+                domain,
+                sharedAt: knowledgeEntry.timestamp,
+                _storedIn,
+                _note: _storedIn === 'agentdb'
+                    ? 'Knowledge stored in AgentDB (vector-searchable) and JSON store. Target agents can retrieve via daa_learning_status or memory search.'
+                    : 'Knowledge stored in shared JSON registry. Target agents can retrieve via daa_learning_status. No cross-agent memory transfer occurs.',
+            };
+        },
+    },
+    {
+        name: 'daa_learning_status',
+        description: 'Get learning status for DAA agents Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Specific agent ID' },
+                detailed: { type: 'boolean', description: 'Include detailed metrics' },
+            },
+        },
+        handler: async (input) => {
+            if (input.agentId) {
+                const vAgentId = validateIdentifier(input.agentId, 'agentId');
+                if (!vAgentId.valid)
+                    return { success: false, error: vAgentId.error };
+            }
+            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,
+                    },
+                };
+            }
+            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',
+        description: 'Analyze or change cognitive patterns Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        inputSchema: {
+            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' },
+            },
+        },
+        handler: async (input) => {
+            if (input.agentId) {
+                const vAgentId = validateIdentifier(input.agentId, 'agentId');
+                if (!vAgentId.valid)
+                    return { success: false, error: vAgentId.error };
+            }
+            if (input.pattern) {
+                const vPattern = validateIdentifier(input.pattern, 'pattern');
+                if (!vPattern.valid)
+                    return { success: false, error: vPattern.error };
+            }
+            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,
+                        learningRate: agent.learningRate,
+                        metrics: agent.metrics,
+                        _note: 'Pattern analysis requires real cognitive modeling. Current pattern and metrics shown.',
+                    };
+                }
+                if (action === 'change' && input.pattern) {
+                    const oldPattern = agent.cognitivePattern;
+                    agent.cognitivePattern = input.pattern;
+                    saveDAAStore(store);
+                    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',
+            };
+        },
+    },
+    {
+        name: 'daa_performance_metrics',
+        description: 'Get DAA performance metrics Use when native Task is wrong because you need agents that adapt their cognitive pattern (convergent / divergent / lateral / systems / critical) per-task and share knowledge across the swarm. For static one-shot agents, native Task is fine.',
+        category: 'daa',
+        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 };
+            }
+            return {
+                success: true,
+                category,
+                metrics: metrics[category],
+            };
+        },
+    },
+];
+//# sourceMappingURL=daa-tools.js.map

package/dist/src/mcp-tools/embeddings-tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Embeddings MCP Tools for CLI
+ *
+ * Tool definitions for ONNX embeddings with hyperbolic support and neural substrate.
+ * Implements ADR-024: Embeddings MCP Tools
+ */
+import type { MCPTool } from './types.js';
+export declare const embeddingsTools: MCPTool[];
+//# sourceMappingURL=embeddings-tools.d.ts.map