swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/setup.d.ts

@@ -1,43 +0,0 @@
-/**
- * V3 Swarmdo Test Setup
- *
- * London School TDD Global Configuration
- * - Initializes mock infrastructure
- * - Sets up global test utilities
- * - Configures behavior verification helpers
- */
-import { vi } from 'vitest';
-export { vi, expect } from 'vitest';
-export { createMock, createDeepMock, createSpyMock } from './helpers/create-mock.js';
-export { createTestApplication } from './helpers/test-application.js';
-export { createSwarmTestInstance } from './helpers/swarm-instance.js';
-interface CustomMatchers<R = unknown> {
-    toHaveBeenCalledWithInteraction(expected: unknown[]): R;
-    toHaveBeenCalledBefore(other: ReturnType<typeof vi.fn>): R;
-    toHaveInteractionCount(expected: number): R;
-    toHaveBeenCalledWithPattern(pattern: Record<string, unknown>): R;
-    toHaveEventType(eventType: string): R;
-    toMeetV3PerformanceTargets(): R;
-    toBeValidTransition(from: string, allowedTransitions: Record<string, string[]>): R;
-}
-declare module 'vitest' {
-    interface Assertion<T> extends CustomMatchers<T> {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
-    }
-}
-/**
- * Test configuration constants
- */
-export declare const TEST_CONFIG: {
-    readonly SECURITY_COVERAGE_TARGET: 0.95;
-    readonly FLASH_ATTENTION_SPEEDUP_MIN: 2.49;
-    readonly FLASH_ATTENTION_SPEEDUP_MAX: 7.47;
-    readonly AGENTDB_SEARCH_IMPROVEMENT_MIN: 150;
-    readonly AGENTDB_SEARCH_IMPROVEMENT_MAX: 12500;
-    readonly MEMORY_REDUCTION_TARGET: 0.5;
-    readonly ASYNC_TIMEOUT: 5000;
-    readonly INTEGRATION_TIMEOUT: 10000;
-    readonly ACCEPTANCE_TIMEOUT: 30000;
-};
-//# sourceMappingURL=setup.d.ts.map

package/v3/@swarmdo/testing/dist/setup.js

@@ -1,91 +0,0 @@
-/**
- * V3 Swarmdo Test Setup
- *
- * London School TDD Global Configuration
- * - Initializes mock infrastructure
- * - Sets up global test utilities
- * - Configures behavior verification helpers
- */
-import { vi, beforeEach, afterEach, expect } from 'vitest';
-// Re-export commonly used testing utilities
-export { vi, expect } from 'vitest';
-export { createMock, createDeepMock, createSpyMock } from './helpers/create-mock.js';
-export { createTestApplication } from './helpers/test-application.js';
-export { createSwarmTestInstance } from './helpers/swarm-instance.js';
-// Custom matchers for London School testing
-expect.extend({
-    /**
-     * Verify a mock was called with specific interaction pattern
-     */
-    toHaveBeenCalledWithInteraction(received, expected) {
-        const pass = received.mock.calls.some((call) => JSON.stringify(call) === JSON.stringify(expected));
-        return {
-            pass,
-            message: () => pass
-                ? `Expected mock not to have been called with ${JSON.stringify(expected)}`
-                : `Expected mock to have been called with ${JSON.stringify(expected)}, but was called with ${JSON.stringify(received.mock.calls)}`,
-        };
-    },
-    /**
-     * Verify mock call order for behavior testing
-     */
-    toHaveBeenCalledBefore(received, other) {
-        const receivedCalls = received.mock.invocationCallOrder;
-        const otherCalls = other.mock.invocationCallOrder;
-        if (receivedCalls.length === 0 || otherCalls.length === 0) {
-            return {
-                pass: false,
-                message: () => 'Expected both mocks to have been called',
-            };
-        }
-        const pass = Math.min(...receivedCalls) < Math.min(...otherCalls);
-        return {
-            pass,
-            message: () => pass
-                ? `Expected first mock not to have been called before second mock`
-                : `Expected first mock to have been called before second mock`,
-        };
-    },
-    /**
-     * Verify interaction count for behavior verification
-     */
-    toHaveInteractionCount(received, expected) {
-        const actual = received.mock.calls.length;
-        const pass = actual === expected;
-        return {
-            pass,
-            message: () => pass
-                ? `Expected mock not to have ${expected} interactions`
-                : `Expected mock to have ${expected} interactions, but had ${actual}`,
-        };
-    },
-});
-// Global setup - runs once before all tests
-beforeEach(() => {
-    // Reset all mocks before each test (London School principle)
-    vi.clearAllMocks();
-    // Reset any timers
-    vi.useRealTimers();
-});
-afterEach(() => {
-    // Verify no unhandled mock calls (strict verification)
-    vi.restoreAllMocks();
-});
-/**
- * Test configuration constants
- */
-export const TEST_CONFIG = {
-    // Security test thresholds
-    SECURITY_COVERAGE_TARGET: 0.95,
-    // Performance test thresholds
-    FLASH_ATTENTION_SPEEDUP_MIN: 2.49,
-    FLASH_ATTENTION_SPEEDUP_MAX: 7.47,
-    AGENTDB_SEARCH_IMPROVEMENT_MIN: 150,
-    AGENTDB_SEARCH_IMPROVEMENT_MAX: 12500,
-    MEMORY_REDUCTION_TARGET: 0.50,
-    // Timeouts
-    ASYNC_TIMEOUT: 5000,
-    INTEGRATION_TIMEOUT: 10000,
-    ACCEPTANCE_TIMEOUT: 30000,
-};
-//# sourceMappingURL=setup.js.map

package/v3/@swarmdo/testing/dist/v2-compat/api-compat.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * V2 API Compatibility Tests
- *
- * Tests that V2 import paths work via aliases and class interfaces match.
- * Verifies method signatures and type compatibility.
- *
- * @module v3/testing/v2-compat/api-compat.test
- */
-export {};
-//# sourceMappingURL=api-compat.test.d.ts.map

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

@@ -1,433 +0,0 @@
-/**
- * V2 API Compatibility Tests
- *
- * Tests that V2 import paths work via aliases and class interfaces match.
- * Verifies method signatures and type compatibility.
- *
- * @module v3/testing/v2-compat/api-compat.test
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { V2CompatibilityValidator, V2_API_INTERFACES, } from './compatibility-validator.js';
-/**
- * V3 class implementations mapping
- */
-const V3_CLASSES = {
-    'UnifiedSwarmCoordinator': {
-        name: 'UnifiedSwarmCoordinator',
-        v3Name: 'UnifiedSwarmCoordinator',
-        methods: [
-            { name: 'initialize', signature: '(config?: SwarmConfig): Promise<void>', compatible: true },
-            { name: 'spawn', signature: '(agentType: string, config?: AgentConfig): Promise<Agent>', v2Signature: '(type: string, config?: AgentConfig): Promise<Agent>', compatible: true },
-            { name: 'addAgent', signature: '(agent: Agent): Promise<void>', compatible: true },
-            { name: 'removeAgent', signature: '(agentId: string): Promise<void>', compatible: true },
-            { name: 'broadcast', signature: '(message: Message): Promise<void>', compatible: true },
-            { name: 'consensus', signature: '(proposal: Proposal): Promise<ConsensusResult>', compatible: true },
-            { name: 'getStatus', signature: '(): Promise<SwarmStatus>', compatible: true },
-            { name: 'shutdown', signature: '(): Promise<void>', compatible: true },
-            { name: 'init', signature: '(topology: string): Promise<void>', compatible: true },
-        ],
-        staticMethods: [],
-        properties: [
-            { name: 'topology', type: 'string', readonly: true },
-            { name: 'agentCount', type: 'number', readonly: true },
-            { name: 'status', type: 'SwarmStatus', readonly: true },
-        ],
-    },
-    'UnifiedMemoryService': {
-        name: 'UnifiedMemoryService',
-        v3Name: 'UnifiedMemoryService',
-        methods: [
-            { name: 'store', signature: '(entry: MemoryEntry): Promise<string>', compatible: true },
-            { name: 'search', signature: '(query: string, options?: SearchOptions): Promise<MemoryEntry[]>', v2Signature: '(search: string): Promise<MemoryEntry[]>', compatible: true },
-            { name: 'query', signature: '(search: string): Promise<MemoryEntry[]>', compatible: true },
-            { name: 'delete', signature: '(id: string): Promise<boolean>', compatible: true },
-            { name: 'clear', signature: '(): Promise<void>', compatible: true },
-            { name: 'getStats', signature: '(): Promise<MemoryStats>', compatible: true },
-        ],
-        staticMethods: [],
-        properties: [
-            { name: 'backend', type: 'string', readonly: true },
-            { name: 'stats', type: 'MemoryStats', readonly: true },
-        ],
-    },
-    'AgentLifecycleService': {
-        name: 'AgentLifecycleService',
-        v3Name: 'AgentLifecycleService',
-        methods: [
-            { name: 'spawn', signature: '(config: AgentConfig): Promise<Agent>', compatible: true },
-            { name: 'terminate', signature: '(id: string): Promise<void>', compatible: true },
-            { name: 'list', signature: '(): Promise<Agent[]>', compatible: true },
-            { name: 'getInfo', signature: '(id: string): Promise<AgentInfo>', compatible: true },
-            { name: 'getStatus', signature: '(id: string): Promise<AgentStatus>', compatible: true },
-        ],
-        staticMethods: [],
-        properties: [
-            { name: 'agents', type: 'Map<string, Agent>', readonly: true },
-        ],
-    },
-    'TaskExecutionService': {
-        name: 'TaskExecutionService',
-        v3Name: 'TaskExecutionService',
-        methods: [
-            { name: 'create', signature: '(definition: TaskDefinition): Promise<Task>', compatible: true },
-            { name: 'assign', signature: '(taskId: string, agentId: string): Promise<void>', compatible: true },
-            { name: 'complete', signature: '(taskId: string, result?: TaskResult): Promise<void>', v2Signature: '(taskId: string, result?: any): Promise<void>', compatible: true },
-            { name: 'getStatus', signature: '(taskId: string): Promise<TaskStatus>', compatible: true },
-        ],
-        staticMethods: [],
-        properties: [
-            { name: 'tasks', type: 'Map<string, Task>', readonly: true },
-        ],
-    },
-};
-/**
- * V2 to V3 import alias mapping
- */
-const IMPORT_ALIASES = {
-    'swarmdo/hive-mind': '@swarmdo/swarm',
-    'swarmdo/swarm': '@swarmdo/swarm',
-    'swarmdo/memory': '@swarmdo/memory',
-    'swarmdo/agents': '@swarmdo/agent-lifecycle',
-    'swarmdo/tasks': '@swarmdo/task-execution',
-    'swarmdo/hooks': '@swarmdo/hooks',
-    'swarmdo/config': '@swarmdo/config',
-    'swarmdo': '@swarmdo/core',
-};
-/**
- * V2 to V3 class name mapping
- */
-const CLASS_ALIASES = {
-    'HiveMind': 'UnifiedSwarmCoordinator',
-    'SwarmCoordinator': 'UnifiedSwarmCoordinator',
-    'MemoryManager': 'UnifiedMemoryService',
-    'AgentManager': 'AgentLifecycleService',
-    'TaskOrchestrator': 'TaskExecutionService',
-};
-/**
- * Create mock module registry
- */
-function createMockModuleRegistry() {
-    return {
-        getClass: vi.fn().mockImplementation((name) => {
-            const v3Name = CLASS_ALIASES[name] || name;
-            return V3_CLASSES[v3Name] || null;
-        }),
-        getClasses: vi.fn().mockReturnValue(Object.keys(V3_CLASSES)),
-        resolveImport: vi.fn().mockImplementation((path) => {
-            return IMPORT_ALIASES[path] || null;
-        }),
-        getMethodSignature: vi.fn().mockImplementation((className, methodName) => {
-            const v3Name = CLASS_ALIASES[className] || className;
-            const classInfo = V3_CLASSES[v3Name];
-            if (!classInfo)
-                return null;
-            const method = classInfo.methods.find(m => m.name === methodName);
-            return method?.signature || null;
-        }),
-        checkTypeCompatibility: vi.fn().mockImplementation((v2Type, v3Type) => {
-            // Simplified type compatibility check
-            if (v2Type === v3Type)
-                return true;
-            if (v2Type === 'any')
-                return true;
-            if (v3Type.includes(v2Type))
-                return true;
-            return false;
-        }),
-    };
-}
-describe('V2 API Compatibility', () => {
-    let validator;
-    let mockRegistry;
-    beforeEach(() => {
-        mockRegistry = createMockModuleRegistry();
-        validator = new V2CompatibilityValidator({
-            verbose: false,
-        });
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('Import Path Aliases', () => {
-        it.each(Object.entries(IMPORT_ALIASES))('should resolve V2 import "%s" to V3 "%s"', (v2Path, v3Path) => {
-            const resolved = mockRegistry.resolveImport(v2Path);
-            expect(resolved).toBe(v3Path);
-        });
-        it('should resolve swarmdo/hive-mind to @swarmdo/swarm', () => {
-            const resolved = mockRegistry.resolveImport('swarmdo/hive-mind');
-            expect(resolved).toBe('@swarmdo/swarm');
-        });
-        it('should resolve swarmdo/memory to @swarmdo/memory', () => {
-            const resolved = mockRegistry.resolveImport('swarmdo/memory');
-            expect(resolved).toBe('@swarmdo/memory');
-        });
-        it('should return null for unknown import paths', () => {
-            const resolved = mockRegistry.resolveImport('unknown-package');
-            expect(resolved).toBeNull();
-        });
-    });
-    describe('Class Name Aliases', () => {
-        it.each(Object.entries(CLASS_ALIASES))('should map V2 class "%s" to V3 "%s"', (v2Name, v3Name) => {
-            const classInfo = mockRegistry.getClass(v2Name);
-            expect(classInfo).not.toBeNull();
-            expect(classInfo?.v3Name).toBe(v3Name);
-        });
-        it('should get HiveMind as UnifiedSwarmCoordinator', () => {
-            const classInfo = mockRegistry.getClass('HiveMind');
-            expect(classInfo).not.toBeNull();
-            expect(classInfo?.name).toBe('UnifiedSwarmCoordinator');
-        });
-        it('should get MemoryManager as UnifiedMemoryService', () => {
-            const classInfo = mockRegistry.getClass('MemoryManager');
-            expect(classInfo).not.toBeNull();
-            expect(classInfo?.name).toBe('UnifiedMemoryService');
-        });
-    });
-    describe('HiveMind Interface', () => {
-        const hiveMindInterface = V2_API_INTERFACES.find(i => i.name === 'HiveMind');
-        it('should have all HiveMind methods available', () => {
-            const classInfo = mockRegistry.getClass('HiveMind');
-            expect(classInfo).not.toBeNull();
-            for (const method of hiveMindInterface.methods) {
-                const hasMethod = classInfo.methods.some(m => m.name === method.name);
-                expect(hasMethod).toBe(true);
-            }
-        });
-        it('should have compatible initialize signature', () => {
-            const signature = mockRegistry.getMethodSignature('HiveMind', 'initialize');
-            expect(signature).toContain('Promise<void>');
-        });
-        it('should have compatible spawn signature', () => {
-            const signature = mockRegistry.getMethodSignature('HiveMind', 'spawn');
-            expect(signature).toContain('Promise<Agent>');
-        });
-        it('should have compatible getStatus signature', () => {
-            const signature = mockRegistry.getMethodSignature('HiveMind', 'getStatus');
-            expect(signature).toContain('Promise');
-        });
-        it('should have compatible shutdown signature', () => {
-            const signature = mockRegistry.getMethodSignature('HiveMind', 'shutdown');
-            expect(signature).toContain('Promise<void>');
-        });
-    });
-    describe('SwarmCoordinator Interface', () => {
-        const swarmInterface = V2_API_INTERFACES.find(i => i.name === 'SwarmCoordinator');
-        it('should have all SwarmCoordinator methods available', () => {
-            const classInfo = mockRegistry.getClass('SwarmCoordinator');
-            expect(classInfo).not.toBeNull();
-            for (const method of swarmInterface.methods) {
-                const hasMethod = classInfo.methods.some(m => m.name === method.name);
-                expect(hasMethod).toBe(true);
-            }
-        });
-        it('should have compatible init signature', () => {
-            const signature = mockRegistry.getMethodSignature('SwarmCoordinator', 'init');
-            expect(signature).toContain('topology');
-            expect(signature).toContain('Promise<void>');
-        });
-        it('should have compatible addAgent signature', () => {
-            const signature = mockRegistry.getMethodSignature('SwarmCoordinator', 'addAgent');
-            expect(signature).toContain('Agent');
-            expect(signature).toContain('Promise<void>');
-        });
-        it('should have compatible broadcast signature', () => {
-            const signature = mockRegistry.getMethodSignature('SwarmCoordinator', 'broadcast');
-            expect(signature).toContain('Message');
-        });
-        it('should have compatible consensus signature', () => {
-            const signature = mockRegistry.getMethodSignature('SwarmCoordinator', 'consensus');
-            expect(signature).toContain('Proposal');
-            expect(signature).toContain('ConsensusResult');
-        });
-    });
-    describe('MemoryManager Interface', () => {
-        const memoryInterface = V2_API_INTERFACES.find(i => i.name === 'MemoryManager');
-        it('should have all MemoryManager methods available', () => {
-            const classInfo = mockRegistry.getClass('MemoryManager');
-            expect(classInfo).not.toBeNull();
-            for (const method of memoryInterface.methods) {
-                const hasMethod = classInfo.methods.some(m => m.name === method.name || (method.name === 'query' && m.name === 'search'));
-                expect(hasMethod).toBe(true);
-            }
-        });
-        it('should have compatible store signature', () => {
-            const signature = mockRegistry.getMethodSignature('MemoryManager', 'store');
-            expect(signature).toContain('MemoryEntry');
-            expect(signature).toContain('Promise<string>');
-        });
-        it('should have query aliased to search', () => {
-            const classInfo = mockRegistry.getClass('MemoryManager');
-            const hasQuery = classInfo.methods.some(m => m.name === 'query');
-            const hasSearch = classInfo.methods.some(m => m.name === 'search');
-            expect(hasQuery || hasSearch).toBe(true);
-        });
-        it('should have compatible delete signature', () => {
-            const signature = mockRegistry.getMethodSignature('MemoryManager', 'delete');
-            expect(signature).toContain('Promise<boolean>');
-        });
-        it('should have compatible getStats signature', () => {
-            const signature = mockRegistry.getMethodSignature('MemoryManager', 'getStats');
-            expect(signature).toContain('MemoryStats');
-        });
-    });
-    describe('AgentManager Interface', () => {
-        const agentInterface = V2_API_INTERFACES.find(i => i.name === 'AgentManager');
-        it('should have all AgentManager methods available', () => {
-            const classInfo = mockRegistry.getClass('AgentManager');
-            expect(classInfo).not.toBeNull();
-            for (const method of agentInterface.methods) {
-                const hasMethod = classInfo.methods.some(m => m.name === method.name);
-                expect(hasMethod).toBe(true);
-            }
-        });
-        it('should have compatible spawn signature', () => {
-            const signature = mockRegistry.getMethodSignature('AgentManager', 'spawn');
-            expect(signature).toContain('AgentConfig');
-            expect(signature).toContain('Promise<Agent>');
-        });
-        it('should have compatible terminate signature', () => {
-            const signature = mockRegistry.getMethodSignature('AgentManager', 'terminate');
-            expect(signature).toContain('Promise<void>');
-        });
-        it('should have compatible list signature', () => {
-            const signature = mockRegistry.getMethodSignature('AgentManager', 'list');
-            expect(signature).toContain('Promise<Agent[]>');
-        });
-        it('should have compatible getInfo signature', () => {
-            const signature = mockRegistry.getMethodSignature('AgentManager', 'getInfo');
-            expect(signature).toContain('AgentInfo');
-        });
-    });
-    describe('TaskOrchestrator Interface', () => {
-        const taskInterface = V2_API_INTERFACES.find(i => i.name === 'TaskOrchestrator');
-        it('should have all TaskOrchestrator methods available', () => {
-            const classInfo = mockRegistry.getClass('TaskOrchestrator');
-            expect(classInfo).not.toBeNull();
-            for (const method of taskInterface.methods) {
-                const hasMethod = classInfo.methods.some(m => m.name === method.name);
-                expect(hasMethod).toBe(true);
-            }
-        });
-        it('should have compatible create signature', () => {
-            const signature = mockRegistry.getMethodSignature('TaskOrchestrator', 'create');
-            expect(signature).toContain('TaskDefinition');
-            expect(signature).toContain('Promise<Task>');
-        });
-        it('should have compatible assign signature', () => {
-            const signature = mockRegistry.getMethodSignature('TaskOrchestrator', 'assign');
-            expect(signature).toContain('taskId');
-            expect(signature).toContain('agentId');
-        });
-        it('should have compatible complete signature', () => {
-            const signature = mockRegistry.getMethodSignature('TaskOrchestrator', 'complete');
-            expect(signature).toContain('taskId');
-            expect(signature).toContain('Promise<void>');
-        });
-        it('should have compatible getStatus signature', () => {
-            const signature = mockRegistry.getMethodSignature('TaskOrchestrator', 'getStatus');
-            expect(signature).toContain('TaskStatus');
-        });
-    });
-    describe('Type Compatibility', () => {
-        it('should accept any type as compatible', () => {
-            const compatible = mockRegistry.checkTypeCompatibility('any', 'string');
-            expect(compatible).toBe(true);
-        });
-        it('should accept same types as compatible', () => {
-            const compatible = mockRegistry.checkTypeCompatibility('string', 'string');
-            expect(compatible).toBe(true);
-        });
-        it('should accept subtype compatibility', () => {
-            const compatible = mockRegistry.checkTypeCompatibility('Agent', 'Agent | null');
-            expect(compatible).toBe(true);
-        });
-    });
-    describe('Full API Validation', () => {
-        it('should pass full API validation', async () => {
-            const result = await validator.validateAPI();
-            expect(result.category).toBe('api');
-            expect(result.totalChecks).toBeGreaterThan(0);
-            expect(result.passedChecks).toBeGreaterThan(0);
-        });
-        it('should detect all V2 API interfaces', async () => {
-            const result = await validator.validateAPI();
-            const classChecks = result.checks.filter(c => c.name.startsWith('API Class:'));
-            expect(classChecks.length).toBeGreaterThanOrEqual(V2_API_INTERFACES.length);
-        });
-        it('should verify method signatures', async () => {
-            const result = await validator.validateAPI();
-            const methodChecks = result.checks.filter(c => c.name.includes('Method:'));
-            expect(methodChecks.length).toBeGreaterThan(0);
-        });
-        it('should provide migration paths', async () => {
-            const result = await validator.validateAPI();
-            const withMigration = result.checks.filter(c => c.migrationPath);
-            expect(withMigration.length).toBeGreaterThan(0);
-        });
-        it('should report minimal breaking changes', async () => {
-            const result = await validator.validateAPI();
-            // Most interfaces should be compatible
-            expect(result.breakingChanges).toBeLessThan(result.totalChecks * 0.2);
-        });
-    });
-    describe('Backward Compatible Usage Patterns', () => {
-        it('should support V2 HiveMind instantiation pattern', () => {
-            // V2 pattern: const hive = new HiveMind(config);
-            // V3 equivalent: const hive = new UnifiedSwarmCoordinator(config);
-            const classInfo = mockRegistry.getClass('HiveMind');
-            expect(classInfo).not.toBeNull();
-            expect(classInfo?.methods.some(m => m.name === 'initialize')).toBe(true);
-        });
-        it('should support V2 MemoryManager query pattern', () => {
-            // V2 pattern: const results = await memory.query('search term');
-            // V3 equivalent: const results = await memory.search('search term');
-            const classInfo = mockRegistry.getClass('MemoryManager');
-            const hasQueryOrSearch = classInfo?.methods.some(m => m.name === 'query' || m.name === 'search');
-            expect(hasQueryOrSearch).toBe(true);
-        });
-        it('should support V2 agent spawn pattern', () => {
-            // V2 pattern: const agent = await manager.spawn({ type: 'coder' });
-            // V3 equivalent: const agent = await lifecycle.spawn({ agentType: 'coder' });
-            const classInfo = mockRegistry.getClass('AgentManager');
-            expect(classInfo?.methods.some(m => m.name === 'spawn')).toBe(true);
-        });
-    });
-});
-describe('API Coverage', () => {
-    it('should define all core V2 API interfaces', () => {
-        const coreInterfaces = ['HiveMind', 'SwarmCoordinator', 'MemoryManager', 'AgentManager', 'TaskOrchestrator'];
-        for (const name of coreInterfaces) {
-            const iface = V2_API_INTERFACES.find(i => i.name === name);
-            expect(iface).toBeDefined();
-        }
-    });
-    it('should have V3 equivalents for all interfaces', () => {
-        for (const iface of V2_API_INTERFACES) {
-            expect(iface.v3Equivalent).toBeDefined();
-            expect(iface.v3Equivalent).not.toBe('');
-        }
-    });
-    it('should define methods for all interfaces', () => {
-        for (const iface of V2_API_INTERFACES) {
-            expect(iface.methods.length).toBeGreaterThan(0);
-        }
-    });
-    it('should define method signatures correctly', () => {
-        for (const iface of V2_API_INTERFACES) {
-            for (const method of iface.methods) {
-                expect(method.name).toBeDefined();
-                expect(method.signature).toBeDefined();
-                expect(method.signature).toContain(':');
-            }
-        }
-    });
-    it('should cover common method patterns', () => {
-        const allMethods = V2_API_INTERFACES.flatMap(i => i.methods.map(m => m.name));
-        expect(allMethods).toContain('initialize');
-        expect(allMethods).toContain('spawn');
-        expect(allMethods).toContain('store');
-        expect(allMethods).toContain('create');
-        expect(allMethods).toContain('getStatus');
-    });
-});
-//# sourceMappingURL=api-compat.test.js.map

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

@@ -1,10 +0,0 @@
-/**
- * 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
- */
-export {};
-//# sourceMappingURL=cli-compat.test.d.ts.map