swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/fixtures/agents.js

@@ -1,158 +0,0 @@
-/**
- * Pre-defined agent configurations for testing
- */
-export const agentConfigs = {
-    queenCoordinator: {
-        type: 'queen-coordinator',
-        name: 'Queen Alpha',
-        capabilities: ['orchestration', 'task-distribution', 'agent-management'],
-        priority: 100,
-        metadata: { isLeader: true },
-    },
-    securityArchitect: {
-        type: 'security-architect',
-        name: 'Security Architect',
-        capabilities: ['security-design', 'threat-modeling', 'security-review'],
-        priority: 90,
-        metadata: { specialization: 'cve-prevention' },
-    },
-    securityAuditor: {
-        type: 'security-auditor',
-        name: 'Security Auditor',
-        capabilities: ['cve-detection', 'vulnerability-scanning', 'security-testing'],
-        priority: 90,
-        metadata: { specialization: 'penetration-testing' },
-    },
-    memorySpecialist: {
-        type: 'memory-specialist',
-        name: 'Memory Specialist',
-        capabilities: ['memory-optimization', 'agentdb-integration', 'caching'],
-        priority: 80,
-        metadata: { backend: 'agentdb' },
-    },
-    swarmSpecialist: {
-        type: 'swarm-specialist',
-        name: 'Swarm Specialist',
-        capabilities: ['coordination', 'consensus', 'communication'],
-        priority: 85,
-        metadata: { topology: 'hierarchical-mesh' },
-    },
-    coder: {
-        type: 'coder',
-        name: 'Coder Agent',
-        capabilities: ['coding', 'implementation', 'debugging'],
-        priority: 70,
-    },
-    tester: {
-        type: 'tester',
-        name: 'Tester Agent',
-        capabilities: ['testing', 'test-execution', 'coverage'],
-        priority: 70,
-    },
-    reviewer: {
-        type: 'reviewer',
-        name: 'Reviewer Agent',
-        capabilities: ['code-review', 'quality-check', 'suggestions'],
-        priority: 75,
-    },
-};
-/**
- * Pre-defined agent instances for testing
- */
-export const agentInstances = {
-    idleQueen: {
-        id: 'agent-queen-001',
-        type: 'queen-coordinator',
-        name: 'Queen Alpha',
-        status: 'idle',
-        capabilities: ['orchestration', 'task-distribution', 'agent-management'],
-        createdAt: new Date('2024-01-01T00:00:00Z'),
-    },
-    busySecurityArchitect: {
-        id: 'agent-security-001',
-        type: 'security-architect',
-        name: 'Security Architect',
-        status: 'busy',
-        capabilities: ['security-design', 'threat-modeling', 'security-review'],
-        createdAt: new Date('2024-01-01T00:00:00Z'),
-        lastActiveAt: new Date('2024-01-15T12:00:00Z'),
-    },
-    terminatedCoder: {
-        id: 'agent-coder-001',
-        type: 'coder',
-        name: 'Coder Agent',
-        status: 'terminated',
-        capabilities: ['coding', 'implementation', 'debugging'],
-        createdAt: new Date('2024-01-01T00:00:00Z'),
-        lastActiveAt: new Date('2024-01-10T08:00:00Z'),
-    },
-};
-/**
- * Factory function to create agent config with overrides
- */
-export function createAgentConfig(base, overrides) {
-    return {
-        ...agentConfigs[base],
-        ...overrides,
-    };
-}
-/**
- * Factory function to create agent instance with overrides
- */
-export function createAgentInstance(base, overrides) {
-    return {
-        ...agentInstances[base],
-        ...overrides,
-        id: overrides?.id ?? `agent-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-        createdAt: overrides?.createdAt ?? new Date(),
-    };
-}
-/**
- * Create a full 15-agent swarm configuration
- */
-export function create15AgentSwarmConfig() {
-    return [
-        agentConfigs.queenCoordinator,
-        agentConfigs.securityArchitect,
-        agentConfigs.securityAuditor,
-        agentConfigs.memorySpecialist,
-        agentConfigs.swarmSpecialist,
-        createAgentConfig('coder', { name: 'Integration Architect', type: 'integration-architect' }),
-        createAgentConfig('coder', { name: 'Performance Engineer', type: 'performance-engineer' }),
-        createAgentConfig('coder', { name: 'Core Architect', type: 'core-architect' }),
-        createAgentConfig('tester', { name: 'Test Architect', type: 'test-architect' }),
-        createAgentConfig('coder', { name: 'Project Coordinator', type: 'project-coordinator' }),
-        agentConfigs.coder,
-        agentConfigs.reviewer,
-        agentConfigs.tester,
-        createAgentConfig('coder', { name: 'Planner Agent', type: 'planner' }),
-        createAgentConfig('coder', { name: 'Researcher Agent', type: 'researcher' }),
-    ];
-}
-/**
- * Invalid agent configurations for error testing
- */
-export const invalidAgentConfigs = {
-    emptyName: {
-        type: 'coder',
-        name: '',
-        capabilities: ['coding'],
-    },
-    noCapabilities: {
-        type: 'coder',
-        name: 'Invalid Agent',
-        capabilities: [],
-    },
-    invalidType: {
-        type: 'invalid-type',
-        name: 'Invalid Agent',
-        capabilities: ['something'],
-    },
-    negativePriority: {
-        type: 'coder',
-        name: 'Invalid Agent',
-        capabilities: ['coding'],
-        priority: -1,
-    },
-};
-//# sourceMappingURL=agents.js.map

package/v3/@swarmdo/testing/dist/fixtures/configurations.d.ts

@@ -1,157 +0,0 @@
-/**
- * V3 Swarmdo Configuration Fixtures
- *
- * Test data for configuration testing
- * Following London School principle of explicit test data
- */
-/**
- * Security configuration interface
- */
-export interface SecurityConfig {
-    validation: {
-        maxInputSize: number;
-        allowedChars: RegExp;
-        sanitizeHtml: boolean;
-    };
-    paths: {
-        allowedDirectories: string[];
-        blockedPatterns: string[];
-        maxPathLength: number;
-    };
-    execution: {
-        shell: boolean;
-        timeout: number;
-        allowedCommands: string[];
-        blockedCommands: string[];
-    };
-    hashing: {
-        algorithm: 'argon2' | 'bcrypt' | 'scrypt';
-        memoryCost?: number;
-        timeCost?: number;
-        parallelism?: number;
-    };
-}
-/**
- * Memory configuration interface
- */
-export interface MemoryConfig {
-    backend: 'agentdb' | 'sqlite' | 'memory' | 'hybrid';
-    vectorDimensions: number;
-    hnswConfig: {
-        M: number;
-        efConstruction: number;
-        efSearch: number;
-    };
-    caching: {
-        enabled: boolean;
-        maxSize: number;
-        ttl: number;
-    };
-    quantization: {
-        enabled: boolean;
-        bits: 4 | 8;
-    };
-}
-/**
- * Swarm configuration interface
- */
-export interface SwarmConfig {
-    topology: 'hierarchical' | 'mesh' | 'adaptive' | 'hierarchical-mesh';
-    maxAgents: number;
-    coordination: {
-        consensusProtocol: 'raft' | 'pbft' | 'gossip';
-        heartbeatInterval: number;
-        electionTimeout: number;
-    };
-    communication: {
-        protocol: 'quic' | 'tcp' | 'websocket';
-        maxMessageSize: number;
-        retryAttempts: number;
-    };
-}
-/**
- * MCP configuration interface
- */
-export interface MCPConfig {
-    server: {
-        port: number;
-        host: string;
-        protocol: 'http' | 'https' | 'stdio';
-    };
-    connection: {
-        poolSize: number;
-        timeout: number;
-        keepAlive: boolean;
-    };
-    tools: {
-        enabled: string[];
-        disabled: string[];
-    };
-}
-/**
- * Performance configuration interface
- */
-export interface PerformanceConfig {
-    targets: {
-        flashAttentionSpeedup: [number, number];
-        agentDBSearchImprovement: [number, number];
-        memoryReduction: number;
-        startupTime: number;
-    };
-    monitoring: {
-        enabled: boolean;
-        samplingRate: number;
-        metricsEndpoint?: string;
-    };
-    optimization: {
-        batchSize: number;
-        parallelism: number;
-        cacheStrategy: 'lru' | 'lfu' | 'arc';
-    };
-}
-/**
- * Pre-defined security configurations for testing
- */
-export declare const securityConfigs: Record<string, SecurityConfig>;
-/**
- * Pre-defined memory configurations for testing
- */
-export declare const memoryConfigs: Record<string, MemoryConfig>;
-/**
- * Pre-defined swarm configurations for testing
- */
-export declare const swarmConfigs: Record<string, SwarmConfig>;
-/**
- * Pre-defined MCP configurations for testing
- */
-export declare const mcpConfigs: Record<string, MCPConfig>;
-/**
- * Pre-defined performance configurations for testing
- */
-export declare const performanceConfigs: Record<string, PerformanceConfig>;
-/**
- * Factory functions to create configurations with overrides
- */
-export declare function createSecurityConfig(base: keyof typeof securityConfigs, overrides?: Partial<SecurityConfig>): SecurityConfig;
-export declare function createMemoryConfig(base: keyof typeof memoryConfigs, overrides?: Partial<MemoryConfig>): MemoryConfig;
-export declare function createSwarmConfigFromBase(base: keyof typeof swarmConfigs, overrides?: Partial<SwarmConfig>): SwarmConfig;
-export declare function createMCPConfig(base: keyof typeof mcpConfigs, overrides?: Partial<MCPConfig>): MCPConfig;
-export declare function createPerformanceConfig(base: keyof typeof performanceConfigs, overrides?: Partial<PerformanceConfig>): PerformanceConfig;
-/**
- * Invalid configurations for error testing
- */
-export declare const invalidConfigs: {
-    security: {
-        negativeMaxInputSize: SecurityConfig;
-        emptyAllowedCommands: SecurityConfig;
-    };
-    memory: {
-        zeroDimensions: MemoryConfig;
-        invalidQuantization: MemoryConfig;
-    };
-    swarm: {
-        zeroAgents: SwarmConfig;
-        negativeHeartbeat: SwarmConfig;
-    };
-};
-//# sourceMappingURL=configurations.d.ts.map

package/v3/@swarmdo/testing/dist/fixtures/configurations.js

@@ -1,337 +0,0 @@
-/**
- * V3 Swarmdo Configuration Fixtures
- *
- * Test data for configuration testing
- * Following London School principle of explicit test data
- */
-/**
- * Pre-defined security configurations for testing
- */
-export const securityConfigs = {
-    strict: {
-        validation: {
-            maxInputSize: 10000,
-            allowedChars: /^[a-zA-Z0-9._\-\s]+$/,
-            sanitizeHtml: true,
-        },
-        paths: {
-            allowedDirectories: ['./v3/', './src/', './tests/'],
-            blockedPatterns: ['../', '~/', '/etc/', '/tmp/', '/var/'],
-            maxPathLength: 255,
-        },
-        execution: {
-            shell: false,
-            timeout: 30000,
-            allowedCommands: ['npm', 'npx', 'node', 'git'],
-            blockedCommands: ['rm', 'del', 'format', 'dd', 'chmod', 'chown'],
-        },
-        hashing: {
-            algorithm: 'argon2',
-            memoryCost: 65536,
-            timeCost: 3,
-            parallelism: 4,
-        },
-    },
-    development: {
-        validation: {
-            maxInputSize: 50000,
-            allowedChars: /^[\x20-\x7E\n\r\t]+$/,
-            sanitizeHtml: false,
-        },
-        paths: {
-            allowedDirectories: ['./', './node_modules/'],
-            blockedPatterns: ['../', '~/'],
-            maxPathLength: 512,
-        },
-        execution: {
-            shell: false, // Security: Always disable shell to prevent injection
-            timeout: 60000,
-            allowedCommands: ['npm', 'npx', 'node', 'git', 'yarn', 'pnpm'],
-            blockedCommands: ['rm', 'rmdir', 'del', 'format', 'dd', 'chmod', 'chown', 'sudo', 'su'],
-        },
-        hashing: {
-            algorithm: 'bcrypt',
-        },
-    },
-    production: {
-        validation: {
-            maxInputSize: 5000,
-            allowedChars: /^[a-zA-Z0-9._\-]+$/,
-            sanitizeHtml: true,
-        },
-        paths: {
-            allowedDirectories: ['/app/'],
-            blockedPatterns: ['../', '~/', '/etc/', '/tmp/', '/var/', '/root/'],
-            maxPathLength: 200,
-        },
-        execution: {
-            shell: false,
-            timeout: 15000,
-            allowedCommands: ['node'],
-            blockedCommands: ['rm', 'del', 'format', 'dd', 'chmod', 'chown', 'sudo'],
-        },
-        hashing: {
-            algorithm: 'argon2',
-            memoryCost: 131072,
-            timeCost: 4,
-            parallelism: 4,
-        },
-    },
-};
-/**
- * Pre-defined memory configurations for testing
- */
-export const memoryConfigs = {
-    agentDB: {
-        backend: 'agentdb',
-        vectorDimensions: 384,
-        hnswConfig: {
-            M: 16,
-            efConstruction: 200,
-            efSearch: 50,
-        },
-        caching: {
-            enabled: true,
-            maxSize: 1000,
-            ttl: 3600000,
-        },
-        quantization: {
-            enabled: true,
-            bits: 8,
-        },
-    },
-    hybrid: {
-        backend: 'hybrid',
-        vectorDimensions: 384,
-        hnswConfig: {
-            M: 32,
-            efConstruction: 400,
-            efSearch: 100,
-        },
-        caching: {
-            enabled: true,
-            maxSize: 5000,
-            ttl: 7200000,
-        },
-        quantization: {
-            enabled: true,
-            bits: 4,
-        },
-    },
-    inMemory: {
-        backend: 'memory',
-        vectorDimensions: 384,
-        hnswConfig: {
-            M: 8,
-            efConstruction: 100,
-            efSearch: 25,
-        },
-        caching: {
-            enabled: false,
-            maxSize: 0,
-            ttl: 0,
-        },
-        quantization: {
-            enabled: false,
-            bits: 8,
-        },
-    },
-};
-/**
- * Pre-defined swarm configurations for testing
- */
-export const swarmConfigs = {
-    v3Default: {
-        topology: 'hierarchical-mesh',
-        maxAgents: 15,
-        coordination: {
-            consensusProtocol: 'raft',
-            heartbeatInterval: 1000,
-            electionTimeout: 5000,
-        },
-        communication: {
-            protocol: 'quic',
-            maxMessageSize: 1048576, // 1MB
-            retryAttempts: 3,
-        },
-    },
-    minimal: {
-        topology: 'mesh',
-        maxAgents: 5,
-        coordination: {
-            consensusProtocol: 'gossip',
-            heartbeatInterval: 2000,
-            electionTimeout: 10000,
-        },
-        communication: {
-            protocol: 'tcp',
-            maxMessageSize: 65536, // 64KB
-            retryAttempts: 5,
-        },
-    },
-    highPerformance: {
-        topology: 'adaptive',
-        maxAgents: 50,
-        coordination: {
-            consensusProtocol: 'pbft',
-            heartbeatInterval: 500,
-            electionTimeout: 3000,
-        },
-        communication: {
-            protocol: 'quic',
-            maxMessageSize: 4194304, // 4MB
-            retryAttempts: 2,
-        },
-    },
-};
-/**
- * Pre-defined MCP configurations for testing
- */
-export const mcpConfigs = {
-    development: {
-        server: {
-            port: 3000,
-            host: 'localhost',
-            protocol: 'http',
-        },
-        connection: {
-            poolSize: 10,
-            timeout: 30000,
-            keepAlive: true,
-        },
-        tools: {
-            enabled: ['*'],
-            disabled: [],
-        },
-    },
-    production: {
-        server: {
-            port: 443,
-            host: '0.0.0.0',
-            protocol: 'https',
-        },
-        connection: {
-            poolSize: 100,
-            timeout: 15000,
-            keepAlive: true,
-        },
-        tools: {
-            enabled: ['swarm_init', 'agent_spawn', 'task_orchestrate', 'memory_usage'],
-            disabled: ['debug_*', 'test_*'],
-        },
-    },
-    stdio: {
-        server: {
-            port: 0,
-            host: '',
-            protocol: 'stdio',
-        },
-        connection: {
-            poolSize: 1,
-            timeout: 60000,
-            keepAlive: false,
-        },
-        tools: {
-            enabled: ['*'],
-            disabled: [],
-        },
-    },
-};
-/**
- * Pre-defined performance configurations for testing
- */
-export const performanceConfigs = {
-    v3Targets: {
-        targets: {
-            flashAttentionSpeedup: [2.49, 7.47],
-            agentDBSearchImprovement: [150, 12500],
-            memoryReduction: 0.50,
-            startupTime: 500,
-        },
-        monitoring: {
-            enabled: true,
-            samplingRate: 0.1,
-            metricsEndpoint: '/metrics',
-        },
-        optimization: {
-            batchSize: 100,
-            parallelism: 4,
-            cacheStrategy: 'arc',
-        },
-    },
-    minimal: {
-        targets: {
-            flashAttentionSpeedup: [1.0, 2.0],
-            agentDBSearchImprovement: [10, 100],
-            memoryReduction: 0.25,
-            startupTime: 2000,
-        },
-        monitoring: {
-            enabled: false,
-            samplingRate: 0,
-        },
-        optimization: {
-            batchSize: 10,
-            parallelism: 1,
-            cacheStrategy: 'lru',
-        },
-    },
-};
-/**
- * Factory functions to create configurations with overrides
- */
-export function createSecurityConfig(base, overrides) {
-    return mergeDeep(securityConfigs[base], (overrides ?? {}));
-}
-export function createMemoryConfig(base, overrides) {
-    return mergeDeep(memoryConfigs[base], (overrides ?? {}));
-}
-export function createSwarmConfigFromBase(base, overrides) {
-    return mergeDeep(swarmConfigs[base], (overrides ?? {}));
-}
-export function createMCPConfig(base, overrides) {
-    return mergeDeep(mcpConfigs[base], (overrides ?? {}));
-}
-export function createPerformanceConfig(base, overrides) {
-    return mergeDeep(performanceConfigs[base], (overrides ?? {}));
-}
-/**
- * Deep merge utility
- */
-function mergeDeep(target, source) {
-    const output = { ...target };
-    for (const key of Object.keys(source)) {
-        const sourceValue = source[key];
-        if (sourceValue && typeof sourceValue === 'object' && !Array.isArray(sourceValue)) {
-            output[key] = mergeDeep(target[key] ?? {}, sourceValue);
-        }
-        else {
-            output[key] = sourceValue;
-        }
-    }
-    return output;
-}
-/**
- * Invalid configurations for error testing
- */
-export const invalidConfigs = {
-    security: {
-        negativeMaxInputSize: createSecurityConfig('strict', {
-            validation: { maxInputSize: -1, allowedChars: /.*/, sanitizeHtml: true },
-        }),
-        emptyAllowedCommands: createSecurityConfig('strict', {
-            execution: { shell: false, timeout: 1000, allowedCommands: [], blockedCommands: [] },
-        }),
-    },
-    memory: {
-        zeroDimensions: createMemoryConfig('agentDB', { vectorDimensions: 0 }),
-        invalidQuantization: createMemoryConfig('agentDB', { quantization: { enabled: true, bits: 16 } }),
-    },
-    swarm: {
-        zeroAgents: createSwarmConfigFromBase('v3Default', { maxAgents: 0 }),
-        negativeHeartbeat: createSwarmConfigFromBase('v3Default', {
-            coordination: { consensusProtocol: 'raft', heartbeatInterval: -100, electionTimeout: 5000 },
-        }),
-    },
-};
-//# sourceMappingURL=configurations.js.map

package/v3/@swarmdo/testing/dist/fixtures/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * V3 Swarmdo Test Fixtures Index
- *
- * Central export for all test fixtures
- */
-export * from './agent-fixtures.js';
-export * from './memory-fixtures.js';
-export * from './swarm-fixtures.js';
-export * from './mcp-fixtures.js';
-//# sourceMappingURL=index.d.ts.map

package/v3/@swarmdo/testing/dist/fixtures/index.js

@@ -1,17 +0,0 @@
-/**
- * V3 Swarmdo Test Fixtures Index
- *
- * Central export for all test fixtures
- */
-// Agent fixtures (comprehensive)
-export * from './agent-fixtures.js';
-// Memory fixtures (AgentDB, HNSW, ReasoningBank)
-export * from './memory-fixtures.js';
-// Swarm fixtures (topologies, coordination, consensus)
-export * from './swarm-fixtures.js';
-// MCP fixtures (tools, resources, prompts)
-export * from './mcp-fixtures.js';
-// Note: Legacy files (agents.js, tasks.js, memory-entries.js, configurations.js)
-// are deprecated. Their contents have been merged into the comprehensive fixtures above.
-// Import directly from the specific fixture files if needed.
-//# sourceMappingURL=index.js.map