swarmdo 1.45.0 → 1.54.1

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

@@ -0,0 +1,352 @@
+/**
+ * V2 CLI Compatibility Tests
+ *
+ * Tests all 25 V2 CLI commands work via compatibility layer or native V3 equivalents.
+ * Verifies flag compatibility and output format compatibility.
+ *
+ * @module v3/testing/v2-compat/cli-compat.test
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { V2CompatibilityValidator, V2_CLI_COMMANDS, } from './compatibility-validator.js';
+/**
+ * Create mock CLI executor
+ */
+function createMockCLIExecutor() {
+    const v3Commands = [
+        'init', 'start', 'stop', 'status', 'config',
+        'agent spawn', 'agent list', 'agent terminate', 'agent status',
+        'swarm init', 'swarm status', 'swarm scale',
+        'memory list', 'memory search', 'memory clear',
+        'hooks pre-edit', 'hooks post-edit', 'hooks pre-command', 'hooks post-command',
+        'hooks route', 'hooks pretrain', 'hooks metrics',
+    ];
+    return {
+        execute: vi.fn().mockImplementation(async (command, args) => {
+            // Simulate V3 CLI behavior with V2 command translation
+            const commandTranslation = {
+                'hive-mind init': 'swarm init',
+                'hive-mind status': 'swarm status',
+                'hive-mind spawn': 'agent spawn',
+                'neural init': 'hooks pretrain',
+                'goal init': 'hooks pretrain',
+                'memory query': 'memory search',
+                'agent info': 'agent status',
+            };
+            const translatedCommand = commandTranslation[command] || command;
+            const isSupported = v3Commands.some(c => c === translatedCommand || translatedCommand.startsWith(c.split(' ')[0]));
+            if (!isSupported) {
+                return {
+                    success: false,
+                    output: `Error: Command "${command}" not found`,
+                    exitCode: 1,
+                };
+            }
+            // Simulate successful output
+            const outputMap = {
+                'status': JSON.stringify({ status: 'running', agents: 0, memory: 'healthy' }),
+                'agent list': JSON.stringify([]),
+                'swarm status': JSON.stringify({ topology: 'hierarchical-mesh', agents: 0 }),
+                'memory list': JSON.stringify([]),
+                'hooks metrics': JSON.stringify({ patterns: 0, successRate: 0 }),
+            };
+            return {
+                success: true,
+                output: outputMap[translatedCommand] || 'OK',
+                exitCode: 0,
+            };
+        }),
+        getCommands: vi.fn().mockReturnValue(v3Commands),
+        parseOutput: vi.fn().mockImplementation((output) => {
+            try {
+                return JSON.parse(output);
+            }
+            catch {
+                return { raw: output };
+            }
+        }),
+    };
+}
+describe('V2 CLI Compatibility', () => {
+    let validator;
+    let mockCLI;
+    beforeEach(() => {
+        mockCLI = createMockCLIExecutor();
+        validator = new V2CompatibilityValidator({
+            verbose: false,
+        });
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('Core Commands', () => {
+        const coreCommands = V2_CLI_COMMANDS.filter(c => ['init', 'start', 'stop', 'status', 'config'].includes(c.name));
+        it.each(coreCommands)('should support V2 command: $name', async (cmd) => {
+            const result = await mockCLI.execute(cmd.name, []);
+            expect(result.success).toBe(true);
+            expect(result.exitCode).toBe(0);
+        });
+        it('should support init command with --force flag', async () => {
+            const result = await mockCLI.execute('init', ['--force']);
+            expect(result.success).toBe(true);
+            expect(mockCLI.execute).toHaveBeenCalledWith('init', ['--force']);
+        });
+        it('should support init command with --template flag', async () => {
+            const result = await mockCLI.execute('init', ['--template', 'minimal']);
+            expect(result.success).toBe(true);
+        });
+        it('should support status command with --json flag', async () => {
+            const result = await mockCLI.execute('status', ['--json']);
+            expect(result.success).toBe(true);
+            const parsed = mockCLI.parseOutput(result.output);
+            expect(parsed).toHaveProperty('status');
+        });
+        it('should support config command with --list flag', async () => {
+            const result = await mockCLI.execute('config', ['--list']);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Agent Commands', () => {
+        const agentCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('agent'));
+        it.each(agentCommands)('should support V2 command: $name', async (cmd) => {
+            const result = await mockCLI.execute(cmd.name, []);
+            expect(result.success).toBe(true);
+        });
+        it('should support agent spawn with --type flag', async () => {
+            const result = await mockCLI.execute('agent spawn', ['--type', 'coder']);
+            expect(result.success).toBe(true);
+        });
+        it('should support agent spawn with --id flag', async () => {
+            const result = await mockCLI.execute('agent spawn', ['--id', 'my-agent']);
+            expect(result.success).toBe(true);
+        });
+        it('should support agent list with --status filter', async () => {
+            const result = await mockCLI.execute('agent list', ['--status', 'active']);
+            expect(result.success).toBe(true);
+        });
+        it('should support agent terminate with --force flag', async () => {
+            const result = await mockCLI.execute('agent terminate', ['--force', 'agent-1']);
+            expect(result.success).toBe(true);
+        });
+        it('should translate agent info to agent status', async () => {
+            const result = await mockCLI.execute('agent info', ['agent-1']);
+            expect(result.success).toBe(true);
+        });
+        it('should support alias "a spawn" for "agent spawn"', async () => {
+            // Aliases should be handled by CLI framework
+            const result = await mockCLI.execute('agent spawn', ['--type', 'coder']);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Swarm Commands', () => {
+        const swarmCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('swarm'));
+        it.each(swarmCommands)('should support V2 command: $name', async (cmd) => {
+            const result = await mockCLI.execute(cmd.name, []);
+            expect(result.success).toBe(true);
+        });
+        it('should support swarm init with --topology flag', async () => {
+            const result = await mockCLI.execute('swarm init', ['--topology', 'hierarchical-mesh']);
+            expect(result.success).toBe(true);
+        });
+        it('should support swarm init with --max-agents flag', async () => {
+            const result = await mockCLI.execute('swarm init', ['--max-agents', '15']);
+            expect(result.success).toBe(true);
+        });
+        it('should support swarm status with --detailed flag', async () => {
+            const result = await mockCLI.execute('swarm status', ['--detailed']);
+            expect(result.success).toBe(true);
+            const parsed = mockCLI.parseOutput(result.output);
+            expect(parsed).toHaveProperty('topology');
+        });
+        it('should support swarm scale with --up flag', async () => {
+            const result = await mockCLI.execute('swarm scale', ['--up', '3']);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Memory Commands', () => {
+        const memoryCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('memory'));
+        it.each(memoryCommands)('should support V2 command: $name', async (cmd) => {
+            const result = await mockCLI.execute(cmd.name, []);
+            expect(result.success).toBe(true);
+        });
+        it('should support memory list with --type filter', async () => {
+            const result = await mockCLI.execute('memory list', ['--type', 'pattern']);
+            expect(result.success).toBe(true);
+        });
+        it('should translate memory query to memory search', async () => {
+            const result = await mockCLI.execute('memory query', ['--search', 'test']);
+            expect(result.success).toBe(true);
+        });
+        it('should support memory clear with --force flag', async () => {
+            const result = await mockCLI.execute('memory clear', ['--force']);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Hooks Commands', () => {
+        const hooksCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('hooks'));
+        it.each(hooksCommands)('should support V2 command: $name', async (cmd) => {
+            const result = await mockCLI.execute(cmd.name, []);
+            expect(result.success).toBe(true);
+        });
+        it('should support hooks pre-edit with file path', async () => {
+            const result = await mockCLI.execute('hooks pre-edit', ['--file', '/path/to/file.ts']);
+            expect(result.success).toBe(true);
+        });
+        it('should support hooks post-edit with success flag', async () => {
+            const result = await mockCLI.execute('hooks post-edit', ['--file', '/path/to/file.ts', '--success', 'true']);
+            expect(result.success).toBe(true);
+        });
+        it('should support hooks route with task description', async () => {
+            const result = await mockCLI.execute('hooks route', ['--task', 'implement feature']);
+            expect(result.success).toBe(true);
+        });
+        it('should support hooks metrics with --dashboard flag', async () => {
+            const result = await mockCLI.execute('hooks metrics', ['--dashboard']);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Deprecated Commands', () => {
+        const deprecatedCommands = V2_CLI_COMMANDS.filter(c => c.deprecated);
+        it.each(deprecatedCommands)('should support deprecated command: $name (with warning)', async (cmd) => {
+            const result = await mockCLI.execute(cmd.name, []);
+            // Deprecated commands should still work
+            expect(result.success).toBe(true);
+        });
+        it('should translate hive-mind init to swarm init', async () => {
+            const result = await mockCLI.execute('hive-mind init', []);
+            expect(result.success).toBe(true);
+        });
+        it('should translate neural init to hooks pretrain', async () => {
+            const result = await mockCLI.execute('neural init', []);
+            expect(result.success).toBe(true);
+        });
+        it('should translate goal init to hooks pretrain', async () => {
+            const result = await mockCLI.execute('goal init', []);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Output Format Compatibility', () => {
+        it('should return JSON output for status command', async () => {
+            const result = await mockCLI.execute('status', ['--json']);
+            expect(result.success).toBe(true);
+            const parsed = mockCLI.parseOutput(result.output);
+            expect(typeof parsed).toBe('object');
+        });
+        it('should return agent list as array', async () => {
+            const result = await mockCLI.execute('agent list', []);
+            expect(result.success).toBe(true);
+            const parsed = mockCLI.parseOutput(result.output);
+            expect(Array.isArray(parsed)).toBe(true);
+        });
+        it('should return swarm status as object', async () => {
+            const result = await mockCLI.execute('swarm status', []);
+            expect(result.success).toBe(true);
+            const parsed = mockCLI.parseOutput(result.output);
+            expect(parsed).toHaveProperty('topology');
+        });
+        it('should return memory list as array', async () => {
+            const result = await mockCLI.execute('memory list', []);
+            expect(result.success).toBe(true);
+            const parsed = mockCLI.parseOutput(result.output);
+            expect(Array.isArray(parsed)).toBe(true);
+        });
+        it('should return hooks metrics as object', async () => {
+            const result = await mockCLI.execute('hooks metrics', []);
+            expect(result.success).toBe(true);
+            const parsed = mockCLI.parseOutput(result.output);
+            expect(parsed).toHaveProperty('patterns');
+        });
+    });
+    describe('Error Handling', () => {
+        it('should return error for unknown command', async () => {
+            const result = await mockCLI.execute('unknown-command', []);
+            expect(result.success).toBe(false);
+            expect(result.exitCode).toBe(1);
+            expect(result.output).toContain('not found');
+        });
+        it('should handle missing required arguments gracefully', async () => {
+            // Most commands should work without arguments for listing operations
+            const result = await mockCLI.execute('agent list', []);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('Full CLI Validation', () => {
+        it('should pass full CLI validation', async () => {
+            const result = await validator.validateCLI();
+            expect(result.category).toBe('cli');
+            expect(result.totalChecks).toBeGreaterThan(0);
+            expect(result.passedChecks).toBeGreaterThan(0);
+        });
+        it('should detect all 25 V2 CLI commands', async () => {
+            const result = await validator.validateCLI();
+            const commandChecks = result.checks.filter(c => c.name.startsWith('CLI:'));
+            // Should have checks for all 25 commands
+            expect(commandChecks.length).toBeGreaterThanOrEqual(25);
+        });
+        it('should identify deprecated commands', async () => {
+            const result = await validator.validateCLI();
+            const deprecatedChecks = result.checks.filter(c => c.name.includes('hive-mind') || c.name.includes('neural') || c.name.includes('goal'));
+            expect(deprecatedChecks.length).toBeGreaterThan(0);
+        });
+        it('should verify flag compatibility', async () => {
+            const result = await validator.validateCLI();
+            const flagChecks = result.checks.filter(c => c.name.includes('Flag:'));
+            expect(flagChecks.length).toBeGreaterThan(0);
+        });
+        it('should report breaking changes for unsupported commands', async () => {
+            const result = await validator.validateCLI();
+            // All non-deprecated commands should be supported
+            const breakingNonDeprecated = result.checks.filter(c => c.breaking && !c.name.includes('deprecated'));
+            // Expect minimal breaking changes in supported commands
+            expect(breakingNonDeprecated.length).toBeLessThan(5);
+        });
+        it('should provide migration paths', async () => {
+            const result = await validator.validateCLI();
+            const withMigration = result.checks.filter(c => c.migrationPath);
+            expect(withMigration.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Alias Compatibility', () => {
+        it('should check all command aliases', async () => {
+            const result = await validator.validateCLI();
+            const aliasChecks = result.checks.filter(c => c.name.includes('Alias:'));
+            expect(aliasChecks.length).toBeGreaterThan(0);
+        });
+        it('should verify common aliases work', async () => {
+            const commonAliases = ['i', 's', 'st', 'c', 'a spawn', 'a ls'];
+            for (const alias of commonAliases) {
+                // Aliases should map to valid commands
+                const aliasCmd = V2_CLI_COMMANDS.find(c => c.aliases.includes(alias));
+                expect(aliasCmd).toBeDefined();
+            }
+        });
+    });
+});
+describe('CLI Command Coverage', () => {
+    it('should test all 25 V2 CLI commands', () => {
+        expect(V2_CLI_COMMANDS.length).toBe(25);
+    });
+    it('should have V3 equivalents for all non-deprecated commands', () => {
+        const nonDeprecated = V2_CLI_COMMANDS.filter(c => !c.deprecated);
+        for (const cmd of nonDeprecated) {
+            expect(cmd.v3Equivalent).toBeDefined();
+            expect(cmd.v3Equivalent).not.toBe('');
+        }
+    });
+    it('should categorize commands correctly', () => {
+        const categories = {
+            core: ['init', 'start', 'stop', 'status', 'config'],
+            agent: V2_CLI_COMMANDS.filter(c => c.name.startsWith('agent')).map(c => c.name),
+            swarm: V2_CLI_COMMANDS.filter(c => c.name.startsWith('swarm')).map(c => c.name),
+            memory: V2_CLI_COMMANDS.filter(c => c.name.startsWith('memory')).map(c => c.name),
+            hooks: V2_CLI_COMMANDS.filter(c => c.name.startsWith('hooks')).map(c => c.name),
+            deprecated: V2_CLI_COMMANDS.filter(c => c.deprecated).map(c => c.name),
+        };
+        expect(categories.core.length).toBe(5);
+        expect(categories.agent.length).toBe(4);
+        expect(categories.swarm.length).toBe(3);
+        expect(categories.memory.length).toBe(3);
+        expect(categories.hooks.length).toBe(7);
+        expect(categories.deprecated.length).toBe(3);
+    });
+});
+//# sourceMappingURL=cli-compat.test.js.map

package/v3/@swarmdo/testing/dist/v2-compat/compatibility-validator.d.ts

@@ -0,0 +1,206 @@
+/**
+ * V2 Compatibility Validator
+ *
+ * Validates that V3 implementation maintains backward compatibility with V2 capabilities.
+ * Tests CLI commands, MCP tools, hooks, and API interfaces.
+ *
+ * @module v3/testing/v2-compat/compatibility-validator
+ */
+/**
+ * Validation result for a single check
+ */
+export interface ValidationCheck {
+    name: string;
+    category: 'cli' | 'mcp' | 'hooks' | 'api';
+    passed: boolean;
+    message: string;
+    v2Behavior: string;
+    v3Behavior: string;
+    breaking: boolean;
+    migrationPath?: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Validation result for a category
+ */
+export interface ValidationResult {
+    category: 'cli' | 'mcp' | 'hooks' | 'api';
+    totalChecks: number;
+    passedChecks: number;
+    failedChecks: number;
+    breakingChanges: number;
+    checks: ValidationCheck[];
+    duration: number;
+}
+/**
+ * Full validation report
+ */
+export interface FullValidationReport {
+    timestamp: Date;
+    v2Version: string;
+    v3Version: string;
+    overallPassed: boolean;
+    totalChecks: number;
+    passedChecks: number;
+    failedChecks: number;
+    breakingChanges: number;
+    cli: ValidationResult;
+    mcp: ValidationResult;
+    hooks: ValidationResult;
+    api: ValidationResult;
+    summary: string;
+    recommendations: string[];
+    duration: number;
+}
+/**
+ * V2 CLI command definition
+ */
+export interface V2CLICommand {
+    name: string;
+    aliases: string[];
+    flags: string[];
+    description: string;
+    v3Equivalent?: string;
+    deprecated?: boolean;
+}
+/**
+ * V2 MCP tool definition
+ */
+export interface V2MCPTool {
+    name: string;
+    parameters: Record<string, {
+        type: string;
+        required: boolean;
+    }>;
+    returnType: string;
+    v3Equivalent?: string;
+    deprecated?: boolean;
+}
+/**
+ * V2 hook definition
+ */
+export interface V2Hook {
+    name: string;
+    trigger: string;
+    parameters: string[];
+    returnType: string;
+    v3Equivalent?: string;
+    deprecated?: boolean;
+}
+/**
+ * V2 API interface definition
+ */
+export interface V2APIInterface {
+    name: string;
+    methods: {
+        name: string;
+        signature: string;
+    }[];
+    v3Equivalent?: string;
+    deprecated?: boolean;
+}
+/**
+ * V2 CLI Commands (25 total)
+ */
+export declare const V2_CLI_COMMANDS: V2CLICommand[];
+/**
+ * V2 MCP Tools (65 total - showing key ones)
+ */
+export declare const V2_MCP_TOOLS: V2MCPTool[];
+/**
+ * V2 Hooks (42 total)
+ */
+export declare const V2_HOOKS: V2Hook[];
+/**
+ * V2 API Interfaces
+ */
+export declare const V2_API_INTERFACES: V2APIInterface[];
+/**
+ * Mock V3 service for testing
+ */
+interface MockV3Service {
+    cli: {
+        execute: (command: string, args: string[]) => Promise<{
+            success: boolean;
+            output: string;
+        }>;
+        getCommands: () => string[];
+    };
+    mcp: {
+        callTool: (name: string, params: Record<string, unknown>) => Promise<unknown>;
+        getTools: () => string[];
+        translateToolName: (v2Name: string) => string;
+    };
+    hooks: {
+        trigger: (name: string, params: Record<string, unknown>) => Promise<{
+            handled: boolean;
+            result: unknown;
+        }>;
+        getHooks: () => string[];
+    };
+    api: {
+        getClass: (name: string) => {
+            methods: string[];
+        } | null;
+        getClasses: () => string[];
+    };
+}
+/**
+ * V2 Compatibility Validator
+ *
+ * Tests V3 implementation against V2 capabilities to ensure backward compatibility.
+ */
+export declare class V2CompatibilityValidator {
+    private readonly v3Service;
+    private readonly v2Version;
+    private readonly v3Version;
+    private readonly verbose;
+    constructor(options?: {
+        v3Service?: MockV3Service;
+        v2Version?: string;
+        v3Version?: string;
+        verbose?: boolean;
+    });
+    /**
+     * Create default mock V3 service for testing
+     */
+    private createDefaultMockService;
+    /**
+     * Validate CLI command compatibility
+     */
+    validateCLI(): Promise<ValidationResult>;
+    /**
+     * Validate MCP tool compatibility
+     */
+    validateMCPTools(): Promise<ValidationResult>;
+    /**
+     * Validate hook compatibility
+     */
+    validateHooks(): Promise<ValidationResult>;
+    /**
+     * Validate API compatibility
+     */
+    validateAPI(): Promise<ValidationResult>;
+    /**
+     * Run full validation suite
+     */
+    runFullValidation(): Promise<FullValidationReport>;
+    /**
+     * Generate recommendations based on results
+     */
+    private generateRecommendations;
+    /**
+     * Generate human-readable summary
+     */
+    private generateSummary;
+    /**
+     * Log message if verbose mode is enabled
+     */
+    private log;
+}
+/**
+ * Generate markdown compatibility report
+ */
+export declare function generateCompatibilityReport(report: FullValidationReport): string;
+export {};
+//# sourceMappingURL=compatibility-validator.d.ts.map