@claude-flow/cli 3.32.1 → 3.32.3

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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,534 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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