swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/v2-compat/mcp-compat.test.js

@@ -1,419 +0,0 @@
-/**
- * V2 MCP Tool Compatibility Tests
- *
- * Tests all 65 V2 MCP tools work via name mapping and parameter translation.
- * Verifies parameter translation and response format compatibility.
- *
- * @module v3/testing/v2-compat/mcp-compat.test
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { V2CompatibilityValidator, V2_MCP_TOOLS, } from './compatibility-validator.js';
-/**
- * Tool name mapping from V2 to V3
- */
-const TOOL_NAME_MAPPING = {
-    // Agent tools
-    'dispatch_agent': 'agent/spawn',
-    'agents/spawn': 'agent/spawn',
-    'agents/list': 'agent/list',
-    'agents/terminate': 'agent/terminate',
-    'agents/info': 'agent/status',
-    'agent/create': 'agent/spawn',
-    // Swarm tools
-    'swarm_status': 'swarm/status',
-    'swarm/get-status': 'swarm/status',
-    'swarm/get-comprehensive-status': 'swarm/status',
-    'mcp__swarmdo-swarm__swarm_init': 'swarm/init',
-    'mcp__swarmdo-swarm__swarm_status': 'swarm/status',
-    'mcp__swarmdo-swarm__agent_spawn': 'agent/spawn',
-    'mcp__swarmdo-swarm__agent_list': 'agent/list',
-    'mcp__swarmdo-swarm__agent_metrics': 'agent/status',
-    // Memory tools
-    'memory/query': 'memory/search',
-    'mcp__swarmdo-swarm__memory_usage': 'memory/list',
-    // Config tools
-    'config/get': 'config/load',
-    'config/update': 'config/save',
-    // Neural tools
-    'mcp__swarmdo-swarm__neural_status': 'hooks/metrics',
-    'mcp__swarmdo-swarm__neural_train': 'hooks/pretrain',
-};
-/**
- * Create mock MCP client
- */
-function createMockMCPClient() {
-    const v3Tools = [
-        'agent/spawn', 'agent/list', 'agent/terminate', 'agent/status',
-        'swarm/init', 'swarm/status', 'swarm/scale', 'swarm/consensus', 'swarm/broadcast',
-        'memory/store', 'memory/search', 'memory/delete', 'memory/list',
-        'task/create', 'task/assign', 'task/status', 'task/complete',
-        'config/load', 'config/save',
-        'hooks/metrics', 'hooks/pretrain',
-        'github/pr-create', 'github/pr-review', 'github/issue-create',
-    ];
-    return {
-        callTool: vi.fn().mockImplementation(async (name, params) => {
-            const v3Name = TOOL_NAME_MAPPING[name] || name;
-            if (!v3Tools.includes(v3Name)) {
-                throw new Error(`Tool not found: ${name} (translated: ${v3Name})`);
-            }
-            // Simulate tool responses
-            const responses = {
-                'agent/spawn': { id: 'agent-1', type: params.agentType || params.type, status: 'active' },
-                'agent/list': [{ id: 'agent-1', type: 'coder', status: 'active' }],
-                'agent/terminate': { success: true },
-                'agent/status': { id: 'agent-1', metrics: { tasksCompleted: 0 } },
-                'swarm/init': { id: 'swarm-1', topology: 'hierarchical-mesh' },
-                'swarm/status': { agents: 0, topology: 'hierarchical-mesh', status: 'active' },
-                'memory/store': { id: 'mem-1', stored: true },
-                'memory/search': [{ id: 'mem-1', content: 'test' }],
-                'memory/list': [{ id: 'mem-1', type: 'pattern' }],
-                'task/create': { id: 'task-1', status: 'pending' },
-                'config/load': { value: 'test-value' },
-                'config/save': { success: true },
-                'hooks/metrics': { patterns: 10, successRate: 0.85 },
-                'hooks/pretrain': { trained: true, patterns: 100 },
-            };
-            return responses[v3Name] || { success: true };
-        }),
-        getTools: vi.fn().mockReturnValue(v3Tools),
-        translateToolName: vi.fn().mockImplementation((v2Name) => TOOL_NAME_MAPPING[v2Name] || v2Name),
-        translateParams: vi.fn().mockImplementation((toolName, params) => {
-            // Parameter translation logic
-            if (toolName === 'dispatch_agent' || toolName === 'agents/spawn') {
-                return {
-                    agentType: params.type,
-                    id: params.name,
-                    config: {
-                        capabilities: params.capabilities,
-                        systemPrompt: params.systemPrompt,
-                    },
-                    priority: params.priority > 5 ? 'high' : 'normal',
-                };
-            }
-            if (toolName === 'memory/query') {
-                return {
-                    query: params.search,
-                    searchType: 'hybrid',
-                    type: params.type,
-                    limit: params.limit || 10,
-                };
-            }
-            if (toolName.includes('swarm_init')) {
-                return {
-                    topology: params.topology || 'hierarchical-mesh',
-                    maxAgents: params.maxAgents || 15,
-                    config: {
-                        consensusMechanism: params.consensus || 'majority',
-                    },
-                };
-            }
-            return params;
-        }),
-    };
-}
-describe('V2 MCP Tool Compatibility', () => {
-    let validator;
-    let mockMCP;
-    beforeEach(() => {
-        mockMCP = createMockMCPClient();
-        validator = new V2CompatibilityValidator({
-            verbose: false,
-        });
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('Agent Tools', () => {
-        const agentTools = V2_MCP_TOOLS.filter(t => t.name.includes('agent') || t.name === 'dispatch_agent');
-        it.each(agentTools)('should support V2 tool: $name', async (tool) => {
-            const params = Object.fromEntries(Object.entries(tool.parameters)
-                .filter(([, def]) => def.required)
-                .map(([key, def]) => [key, def.type === 'string' ? 'test' : {}]));
-            const result = await mockMCP.callTool(tool.name, params);
-            expect(result).toBeDefined();
-        });
-        it('should translate dispatch_agent to agent/spawn', () => {
-            const v3Name = mockMCP.translateToolName('dispatch_agent');
-            expect(v3Name).toBe('agent/spawn');
-        });
-        it('should translate agents/spawn to agent/spawn', () => {
-            const v3Name = mockMCP.translateToolName('agents/spawn');
-            expect(v3Name).toBe('agent/spawn');
-        });
-        it('should translate agents/info to agent/status', () => {
-            const v3Name = mockMCP.translateToolName('agents/info');
-            expect(v3Name).toBe('agent/status');
-        });
-        it('should translate agent parameters correctly', () => {
-            const v2Params = {
-                type: 'coder',
-                name: 'my-coder',
-                capabilities: ['coding'],
-                priority: 8,
-            };
-            const v3Params = mockMCP.translateParams('dispatch_agent', v2Params);
-            expect(v3Params.agentType).toBe('coder');
-            expect(v3Params.id).toBe('my-coder');
-            expect(v3Params.priority).toBe('high');
-        });
-        it('should handle mcp__swarmdo-swarm__agent_spawn', async () => {
-            const result = await mockMCP.callTool('mcp__swarmdo-swarm__agent_spawn', { type: 'coder' });
-            expect(result).toHaveProperty('id');
-            expect(result).toHaveProperty('type');
-        });
-    });
-    describe('Swarm Tools', () => {
-        const swarmTools = V2_MCP_TOOLS.filter(t => t.name.includes('swarm'));
-        it.each(swarmTools)('should support V2 tool: $name', async (tool) => {
-            const params = Object.fromEntries(Object.entries(tool.parameters)
-                .filter(([, def]) => def.required)
-                .map(([key, def]) => [key, def.type === 'string' ? 'test' : {}]));
-            const result = await mockMCP.callTool(tool.name, params);
-            expect(result).toBeDefined();
-        });
-        it('should translate swarm_status to swarm/status', () => {
-            const v3Name = mockMCP.translateToolName('swarm_status');
-            expect(v3Name).toBe('swarm/status');
-        });
-        it('should translate swarm/get-comprehensive-status to swarm/status', () => {
-            const v3Name = mockMCP.translateToolName('swarm/get-comprehensive-status');
-            expect(v3Name).toBe('swarm/status');
-        });
-        it('should translate swarm init parameters', () => {
-            const v2Params = {
-                topology: 'mesh',
-                maxAgents: 10,
-                consensus: 'quorum',
-            };
-            const v3Params = mockMCP.translateParams('mcp__swarmdo-swarm__swarm_init', v2Params);
-            expect(v3Params.topology).toBe('mesh');
-            expect(v3Params.maxAgents).toBe(10);
-            expect(v3Params.config).toHaveProperty('consensusMechanism');
-        });
-        it('should return compatible swarm status response', async () => {
-            const result = await mockMCP.callTool('swarm_status', {});
-            expect(result).toHaveProperty('agents');
-            expect(result).toHaveProperty('topology');
-            expect(result).toHaveProperty('status');
-        });
-    });
-    describe('Memory Tools', () => {
-        const memoryTools = V2_MCP_TOOLS.filter(t => t.name.includes('memory'));
-        it.each(memoryTools)('should support V2 tool: $name', async (tool) => {
-            const params = Object.fromEntries(Object.entries(tool.parameters)
-                .filter(([, def]) => def.required)
-                .map(([key, def]) => [key, def.type === 'string' ? 'test' : {}]));
-            const result = await mockMCP.callTool(tool.name, params);
-            expect(result).toBeDefined();
-        });
-        it('should translate memory/query to memory/search', () => {
-            const v3Name = mockMCP.translateToolName('memory/query');
-            expect(v3Name).toBe('memory/search');
-        });
-        it('should translate memory query parameters', () => {
-            const v2Params = {
-                search: 'test query',
-                type: 'pattern',
-                limit: 20,
-            };
-            const v3Params = mockMCP.translateParams('memory/query', v2Params);
-            expect(v3Params.query).toBe('test query');
-            expect(v3Params.searchType).toBe('hybrid');
-            expect(v3Params.limit).toBe(20);
-        });
-        it('should return array from memory search', async () => {
-            const result = await mockMCP.callTool('memory/query', { search: 'test' });
-            expect(Array.isArray(result)).toBe(true);
-        });
-    });
-    describe('Config Tools', () => {
-        it('should translate config/get to config/load', () => {
-            const v3Name = mockMCP.translateToolName('config/get');
-            expect(v3Name).toBe('config/load');
-        });
-        it('should translate config/update to config/save', () => {
-            const v3Name = mockMCP.translateToolName('config/update');
-            expect(v3Name).toBe('config/save');
-        });
-        it('should handle config get operation', async () => {
-            const result = await mockMCP.callTool('config/get', { key: 'test.key' });
-            expect(result).toHaveProperty('value');
-        });
-        it('should handle config update operation', async () => {
-            const result = await mockMCP.callTool('config/update', {
-                key: 'test.key',
-                value: 'new-value',
-            });
-            expect(result).toHaveProperty('success');
-        });
-    });
-    describe('Task Tools', () => {
-        const taskTools = V2_MCP_TOOLS.filter(t => t.name.startsWith('task/'));
-        it.each(taskTools)('should support V2 tool: $name', async (tool) => {
-            const params = Object.fromEntries(Object.entries(tool.parameters)
-                .filter(([, def]) => def.required)
-                .map(([key, def]) => [key, def.type === 'string' ? 'test' : 'test']));
-            const result = await mockMCP.callTool(tool.name, params);
-            expect(result).toBeDefined();
-        });
-        it('should create task with description', async () => {
-            const result = await mockMCP.callTool('task/create', {
-                description: 'Test task',
-            });
-            expect(result).toHaveProperty('id');
-            expect(result).toHaveProperty('status');
-        });
-        it('should assign task to agent', async () => {
-            const result = await mockMCP.callTool('task/assign', {
-                taskId: 'task-1',
-                agentId: 'agent-1',
-            });
-            expect(result).toBeDefined();
-        });
-    });
-    describe('Neural/Learning Tools', () => {
-        it('should translate neural_status to hooks/metrics', () => {
-            const v3Name = mockMCP.translateToolName('mcp__swarmdo-swarm__neural_status');
-            expect(v3Name).toBe('hooks/metrics');
-        });
-        it('should translate neural_train to hooks/pretrain', () => {
-            const v3Name = mockMCP.translateToolName('mcp__swarmdo-swarm__neural_train');
-            expect(v3Name).toBe('hooks/pretrain');
-        });
-        it('should return compatible metrics response', async () => {
-            const result = await mockMCP.callTool('mcp__swarmdo-swarm__neural_status', {});
-            expect(result).toHaveProperty('patterns');
-            expect(result).toHaveProperty('successRate');
-        });
-        it('should handle pretrain operation', async () => {
-            const result = await mockMCP.callTool('mcp__swarmdo-swarm__neural_train', {
-                data: { source: 'repo' },
-            });
-            expect(result).toHaveProperty('trained');
-        });
-    });
-    describe('GitHub Tools', () => {
-        const githubTools = V2_MCP_TOOLS.filter(t => t.name.startsWith('github/'));
-        it.each(githubTools)('should support V2 tool: $name', async (tool) => {
-            const params = Object.fromEntries(Object.entries(tool.parameters)
-                .filter(([, def]) => def.required)
-                .map(([key, def]) => {
-                if (def.type === 'number')
-                    return [key, 1];
-                return [key, 'test'];
-            }));
-            const result = await mockMCP.callTool(tool.name, params);
-            expect(result).toBeDefined();
-        });
-        it('should handle PR creation', async () => {
-            const result = await mockMCP.callTool('github/pr-create', {
-                title: 'Test PR',
-                body: 'Test body',
-            });
-            expect(result).toBeDefined();
-        });
-        it('should handle PR review', async () => {
-            const result = await mockMCP.callTool('github/pr-review', {
-                prNumber: 123,
-            });
-            expect(result).toBeDefined();
-        });
-    });
-    describe('Error Handling', () => {
-        it('should throw for unknown tool', async () => {
-            await expect(mockMCP.callTool('unknown/tool', {}))
-                .rejects.toThrow('Tool not found');
-        });
-        it('should handle missing required parameters gracefully', async () => {
-            // Tool should still be callable even with empty params for testing
-            const result = await mockMCP.callTool('agent/list', {});
-            expect(result).toBeDefined();
-        });
-    });
-    describe('Full MCP Validation', () => {
-        it('should pass full MCP validation', async () => {
-            const result = await validator.validateMCPTools();
-            expect(result.category).toBe('mcp');
-            expect(result.totalChecks).toBeGreaterThan(0);
-            expect(result.passedChecks).toBeGreaterThan(0);
-        });
-        it('should detect all V2 MCP tools', async () => {
-            const result = await validator.validateMCPTools();
-            const toolChecks = result.checks.filter(c => c.name.startsWith('MCP Tool:'));
-            expect(toolChecks.length).toBeGreaterThanOrEqual(V2_MCP_TOOLS.length);
-        });
-        it('should verify parameter translation', async () => {
-            const result = await validator.validateMCPTools();
-            const paramChecks = result.checks.filter(c => c.name.includes('Param:'));
-            expect(paramChecks.length).toBeGreaterThan(0);
-        });
-        it('should identify V3 equivalents', async () => {
-            const result = await validator.validateMCPTools();
-            for (const check of result.checks.filter(c => c.name.startsWith('MCP Tool:'))) {
-                if (check.passed && check.details) {
-                    expect(check.details.v3Equivalent).toBeDefined();
-                }
-            }
-        });
-        it('should report breaking changes correctly', async () => {
-            const result = await validator.validateMCPTools();
-            // Most tools should have V3 equivalents
-            expect(result.breakingChanges).toBeLessThan(result.totalChecks * 0.2);
-        });
-    });
-    describe('Response Format Compatibility', () => {
-        it('should return consistent agent info format', async () => {
-            const result = await mockMCP.callTool('dispatch_agent', { type: 'coder' });
-            expect(result).toHaveProperty('id');
-            expect(result).toHaveProperty('type');
-            expect(result).toHaveProperty('status');
-        });
-        it('should return array for list operations', async () => {
-            const agentList = await mockMCP.callTool('agents/list', {});
-            const memoryList = await mockMCP.callTool('memory/query', { search: 'test' });
-            expect(Array.isArray(agentList)).toBe(true);
-            expect(Array.isArray(memoryList)).toBe(true);
-        });
-        it('should return success boolean for mutations', async () => {
-            const terminateResult = await mockMCP.callTool('agents/terminate', { id: 'agent-1' });
-            const configResult = await mockMCP.callTool('config/update', { key: 'k', value: 'v' });
-            expect(terminateResult).toHaveProperty('success');
-            expect(configResult).toHaveProperty('success');
-        });
-    });
-});
-describe('MCP Tool Coverage', () => {
-    it('should define at least 30 V2 MCP tools', () => {
-        expect(V2_MCP_TOOLS.length).toBeGreaterThanOrEqual(30);
-    });
-    it('should have V3 equivalents for most tools', () => {
-        const withEquivalent = V2_MCP_TOOLS.filter(t => t.v3Equivalent);
-        expect(withEquivalent.length).toBeGreaterThan(V2_MCP_TOOLS.length * 0.8);
-    });
-    it('should categorize tools correctly', () => {
-        const categories = {
-            agent: V2_MCP_TOOLS.filter(t => t.name.includes('agent') || t.name === 'dispatch_agent'),
-            swarm: V2_MCP_TOOLS.filter(t => t.name.includes('swarm')),
-            memory: V2_MCP_TOOLS.filter(t => t.name.includes('memory')),
-            config: V2_MCP_TOOLS.filter(t => t.name.includes('config')),
-            task: V2_MCP_TOOLS.filter(t => t.name.startsWith('task/')),
-            neural: V2_MCP_TOOLS.filter(t => t.name.includes('neural')),
-            github: V2_MCP_TOOLS.filter(t => t.name.startsWith('github/')),
-            coordinate: V2_MCP_TOOLS.filter(t => t.name.startsWith('coordinate/')),
-        };
-        expect(categories.agent.length).toBeGreaterThanOrEqual(6);
-        expect(categories.swarm.length).toBeGreaterThanOrEqual(5);
-        expect(categories.memory.length).toBeGreaterThanOrEqual(3);
-    });
-    it('should define required parameters correctly', () => {
-        for (const tool of V2_MCP_TOOLS) {
-            for (const [, def] of Object.entries(tool.parameters)) {
-                expect(def).toHaveProperty('type');
-                expect(def).toHaveProperty('required');
-                expect(typeof def.required).toBe('boolean');
-            }
-        }
-    });
-});
-//# sourceMappingURL=mcp-compat.test.js.map

package/v3/@swarmdo/testing/dist/v2-compat/report-generator.d.ts

@@ -1,34 +0,0 @@
-/**
- * V2 Compatibility Report Generator
- *
- * Generates comprehensive markdown reports for V2 compatibility validation.
- * Provides detailed analysis of compatibility status, breaking changes, and migration recommendations.
- *
- * @module v3/testing/v2-compat/report-generator
- */
-import { type FullValidationReport } from './compatibility-validator.js';
-/**
- * Report generation options
- */
-export interface ReportOptions {
-    /** Include detailed check results */
-    detailed: boolean;
-    /** Include code examples */
-    includeExamples: boolean;
-    /** Include migration scripts */
-    includeMigrationScripts: boolean;
-    /** Output format */
-    format: 'markdown' | 'json' | 'html';
-}
-/**
- * Generate a full compatibility report
- */
-export declare function generateFullReport(options?: Partial<ReportOptions>): Promise<{
-    report: FullValidationReport;
-    markdown: string;
-}>;
-/**
- * Run validation and save report to file
- */
-export declare function runAndSaveReport(outputPath: string): Promise<FullValidationReport>;
-//# sourceMappingURL=report-generator.d.ts.map