swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/helpers/swarm-instance.d.ts

@@ -1,142 +0,0 @@
-import { type MockedInterface } from './create-mock.js';
-/**
- * Agent types for V3 15-agent swarm
- */
-export type V3AgentType = 'queen-coordinator' | 'security-architect' | 'security-auditor' | 'memory-specialist' | 'swarm-specialist' | 'integration-architect' | 'performance-engineer' | 'core-architect' | 'test-architect' | 'project-coordinator' | 'coder' | 'reviewer' | 'tester' | 'planner' | 'researcher';
-/**
- * Swarm topology types
- */
-export type SwarmTopology = 'hierarchical' | 'mesh' | 'adaptive' | 'hierarchical-mesh';
-/**
- * Agent interface for swarm testing
- */
-export interface SwarmAgent {
-    id: string;
-    type: V3AgentType;
-    status: 'idle' | 'busy' | 'terminated';
-    capabilities: string[];
-    execute(task: SwarmTask): Promise<SwarmTaskResult>;
-    communicate(message: SwarmMessage): Promise<void>;
-}
-/**
- * Swarm message interface
- */
-export interface SwarmMessage {
-    from: string;
-    to: string | 'broadcast';
-    type: 'task' | 'result' | 'status' | 'coordination';
-    payload: unknown;
-    timestamp: Date;
-}
-/**
- * Swarm task interface
- */
-export interface SwarmTask {
-    id: string;
-    type: string;
-    payload: unknown;
-    priority: number;
-    assignedTo?: string;
-}
-/**
- * Swarm task result
- */
-export interface SwarmTaskResult {
-    taskId: string;
-    agentId: string;
-    success: boolean;
-    output?: unknown;
-    error?: Error;
-    duration: number;
-}
-/**
- * Swarm coordination result
- */
-export interface SwarmCoordinationResult {
-    success: boolean;
-    completedTasks: number;
-    failedTasks: number;
-    totalDuration: number;
-    agentMetrics: Map<string, AgentMetrics>;
-}
-/**
- * Agent metrics
- */
-export interface AgentMetrics {
-    tasksCompleted: number;
-    tasksFailed: number;
-    averageTaskDuration: number;
-    totalDuration: number;
-}
-/**
- * Create a test swarm instance with mocked agents
- */
-export declare function createSwarmTestInstance(config?: {
-    topology?: SwarmTopology;
-    agentTypes?: V3AgentType[];
-}): SwarmTestInstance;
-/**
- * Swarm test instance class
- */
-export declare class SwarmTestInstance {
-    readonly topology: SwarmTopology;
-    private readonly agentTypes;
-    private agents;
-    private messages;
-    private taskResults;
-    private interactionRecorder;
-    private isInitialized;
-    constructor(topology: SwarmTopology, agentTypes: V3AgentType[]);
-    private initializeAgents;
-    private createMockAgent;
-    private getCapabilitiesForType;
-    /**
-     * Initialize the swarm
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get an agent by type
-     */
-    getAgent(type: V3AgentType): MockedInterface<SwarmAgent> | undefined;
-    /**
-     * Get all agents
-     */
-    getAllAgents(): MockedInterface<SwarmAgent>[];
-    /**
-     * Get agent by ID
-     */
-    getAgentById(id: string): MockedInterface<SwarmAgent> | undefined;
-    /**
-     * Get all messages
-     */
-    getMessages(): SwarmMessage[];
-    /**
-     * Get task results
-     */
-    getTaskResults(): SwarmTaskResult[];
-    /**
-     * Get interaction order for behavior verification
-     */
-    getInteractionOrder(): string[];
-    /**
-     * Get all interactions
-     */
-    getInteractions(): Array<{
-        name: string;
-        method: string;
-        args: unknown[];
-    }>;
-    /**
-     * Coordinate a task across agents
-     */
-    coordinate(task: SwarmTask): Promise<SwarmCoordinationResult>;
-    /**
-     * Shutdown the swarm
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Reset the swarm state
-     */
-    reset(): void;
-}
-//# sourceMappingURL=swarm-instance.d.ts.map

package/v3/@swarmdo/testing/dist/helpers/swarm-instance.js

@@ -1,205 +0,0 @@
-/**
- * V3 Swarmdo Swarm Test Instance
- *
- * Creates isolated swarm instances for testing
- * Supports 15-agent V3 swarm topology testing
- */
-import { vi } from 'vitest';
-import { createMock, InteractionRecorder } from './create-mock.js';
-/**
- * Create a test swarm instance with mocked agents
- */
-export function createSwarmTestInstance(config) {
-    const topology = config?.topology ?? 'hierarchical-mesh';
-    const agentTypes = config?.agentTypes ?? [
-        'queen-coordinator',
-        'security-architect',
-        'security-auditor',
-        'memory-specialist',
-        'swarm-specialist',
-    ];
-    return new SwarmTestInstance(topology, agentTypes);
-}
-/**
- * Swarm test instance class
- */
-export class SwarmTestInstance {
-    topology;
-    agentTypes;
-    agents = new Map();
-    messages = [];
-    taskResults = [];
-    interactionRecorder;
-    isInitialized = false;
-    constructor(topology, agentTypes) {
-        this.topology = topology;
-        this.agentTypes = agentTypes;
-        this.interactionRecorder = new InteractionRecorder();
-        this.initializeAgents();
-    }
-    initializeAgents() {
-        for (const type of this.agentTypes) {
-            const id = `${type}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-            const agent = this.createMockAgent(id, type);
-            this.agents.set(id, agent);
-            this.interactionRecorder.track(id, agent);
-        }
-    }
-    createMockAgent(id, type) {
-        const mock = createMock();
-        // Set default properties
-        Object.defineProperty(mock, 'id', { value: id, writable: false });
-        Object.defineProperty(mock, 'type', { value: type, writable: false });
-        Object.defineProperty(mock, 'status', { value: 'idle', writable: true });
-        Object.defineProperty(mock, 'capabilities', {
-            value: this.getCapabilitiesForType(type),
-            writable: false
-        });
-        // Configure default behavior
-        mock.execute.mockImplementation(async (task) => {
-            const result = {
-                taskId: task.id,
-                agentId: id,
-                success: true,
-                duration: Math.random() * 100 + 10,
-            };
-            this.taskResults.push(result);
-            return result;
-        });
-        mock.communicate.mockImplementation(async (message) => {
-            this.messages.push(message);
-        });
-        return mock;
-    }
-    getCapabilitiesForType(type) {
-        const capabilities = {
-            'queen-coordinator': ['orchestration', 'task-distribution', 'agent-management'],
-            'security-architect': ['security-design', 'threat-modeling', 'security-review'],
-            'security-auditor': ['cve-detection', 'vulnerability-scanning', 'security-testing'],
-            'memory-specialist': ['memory-optimization', 'agentdb-integration', 'caching'],
-            'swarm-specialist': ['coordination', 'consensus', 'communication'],
-            'integration-architect': ['api-design', 'system-integration', 'compatibility'],
-            'performance-engineer': ['optimization', 'benchmarking', 'profiling'],
-            'core-architect': ['ddd-design', 'architecture', 'domain-modeling'],
-            'test-architect': ['tdd', 'test-design', 'quality-assurance'],
-            'project-coordinator': ['project-management', 'scheduling', 'reporting'],
-            'coder': ['coding', 'implementation', 'debugging'],
-            'reviewer': ['code-review', 'quality-check', 'suggestions'],
-            'tester': ['testing', 'test-execution', 'coverage'],
-            'planner': ['planning', 'estimation', 'roadmap'],
-            'researcher': ['research', 'analysis', 'documentation'],
-        };
-        return capabilities[type];
-    }
-    /**
-     * Initialize the swarm
-     */
-    async initialize() {
-        this.isInitialized = true;
-        // Simulate initialization delay
-        await new Promise(resolve => setTimeout(resolve, 1));
-    }
-    /**
-     * Get an agent by type
-     */
-    getAgent(type) {
-        for (const [_, agent] of this.agents) {
-            if (agent.type === type) {
-                return agent;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Get all agents
-     */
-    getAllAgents() {
-        return Array.from(this.agents.values());
-    }
-    /**
-     * Get agent by ID
-     */
-    getAgentById(id) {
-        return this.agents.get(id);
-    }
-    /**
-     * Get all messages
-     */
-    getMessages() {
-        return [...this.messages];
-    }
-    /**
-     * Get task results
-     */
-    getTaskResults() {
-        return [...this.taskResults];
-    }
-    /**
-     * Get interaction order for behavior verification
-     */
-    getInteractionOrder() {
-        return this.interactionRecorder.getInteractionOrder();
-    }
-    /**
-     * Get all interactions
-     */
-    getInteractions() {
-        return this.interactionRecorder.getInteractions();
-    }
-    /**
-     * Coordinate a task across agents
-     */
-    async coordinate(task) {
-        if (!this.isInitialized) {
-            throw new Error('Swarm not initialized');
-        }
-        const startTime = Date.now();
-        const results = [];
-        // Simulate coordination based on topology
-        const queen = this.getAgent('queen-coordinator');
-        if (queen && this.topology.includes('hierarchical')) {
-            await queen.communicate({
-                from: 'coordinator',
-                to: 'broadcast',
-                type: 'task',
-                payload: task,
-                timestamp: new Date(),
-            });
-        }
-        // Execute task on appropriate agent
-        for (const agent of this.agents.values()) {
-            const result = await agent.execute(task);
-            results.push(result);
-        }
-        const completedTasks = results.filter(r => r.success).length;
-        const failedTasks = results.filter(r => !r.success).length;
-        return {
-            success: failedTasks === 0,
-            completedTasks,
-            failedTasks,
-            totalDuration: Date.now() - startTime,
-            agentMetrics: new Map(),
-        };
-    }
-    /**
-     * Shutdown the swarm
-     */
-    async shutdown() {
-        for (const agent of this.agents.values()) {
-            Object.defineProperty(agent, 'status', { value: 'terminated', writable: true });
-        }
-        this.isInitialized = false;
-    }
-    /**
-     * Reset the swarm state
-     */
-    reset() {
-        this.messages = [];
-        this.taskResults = [];
-        this.interactionRecorder.clear();
-        for (const agent of this.agents.values()) {
-            vi.clearAllMocks();
-        }
-    }
-}
-//# sourceMappingURL=swarm-instance.js.map

package/v3/@swarmdo/testing/dist/helpers/test-application.d.ts

@@ -1,190 +0,0 @@
-import { type MockedInterface } from './create-mock.js';
-/**
- * Core domain interfaces for testing
- */
-export interface IEventBus {
-    publish(event: DomainEvent): Promise<void>;
-    subscribe(eventType: string, handler: EventHandler): void;
-    unsubscribe(eventType: string, handler: EventHandler): void;
-}
-export interface ITaskManager {
-    create(task: TaskDefinition): Promise<Task>;
-    execute(taskId: string): Promise<TaskResult>;
-    cancel(taskId: string): Promise<void>;
-    getStatus(taskId: string): Promise<TaskStatus>;
-}
-export interface IAgentLifecycle {
-    spawn(config: AgentConfig): Promise<Agent>;
-    terminate(agentId: string): Promise<void>;
-    getAgent(agentId: string): Promise<Agent | null>;
-    listAgents(): Promise<Agent[]>;
-}
-export interface IMemoryService {
-    store(key: string, value: unknown, metadata?: MemoryMetadata): Promise<void>;
-    retrieve(key: string): Promise<unknown>;
-    search(query: VectorQuery): Promise<SearchResult[]>;
-    delete(key: string): Promise<void>;
-}
-export interface ISecurityService {
-    validatePath(path: string): boolean;
-    hashPassword(password: string): Promise<string>;
-    verifyPassword(password: string, hash: string): Promise<boolean>;
-    executeSecurely(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;
-}
-export interface ISwarmCoordinator {
-    initialize(config: SwarmConfig): Promise<void>;
-    coordinate(agents: Agent[], task: Task): Promise<CoordinationResult>;
-    shutdown(): Promise<void>;
-}
-/**
- * Type definitions for domain objects
- */
-export interface DomainEvent {
-    type: string;
-    payload: unknown;
-    timestamp: Date;
-    correlationId?: string;
-}
-export type EventHandler = (event: DomainEvent) => Promise<void>;
-export interface TaskDefinition {
-    name: string;
-    type: string;
-    payload: unknown;
-    priority?: number;
-}
-export interface Task {
-    id: string;
-    name: string;
-    type: string;
-    status: TaskStatus;
-    payload: unknown;
-    createdAt: Date;
-}
-export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
-export interface TaskResult {
-    taskId: string;
-    success: boolean;
-    output?: unknown;
-    error?: Error;
-    duration: number;
-}
-export interface AgentConfig {
-    type: string;
-    name: string;
-    capabilities: string[];
-}
-export interface Agent {
-    id: string;
-    type: string;
-    name: string;
-    status: 'idle' | 'busy' | 'terminated';
-}
-export interface MemoryMetadata {
-    ttl?: number;
-    tags?: string[];
-    embedding?: number[];
-}
-export interface VectorQuery {
-    embedding: number[];
-    topK: number;
-    threshold?: number;
-}
-export interface SearchResult {
-    key: string;
-    value: unknown;
-    score: number;
-}
-export interface ExecuteOptions {
-    timeout?: number;
-    cwd?: string;
-    shell?: boolean;
-}
-export interface ExecuteResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-export interface SwarmConfig {
-    topology: 'hierarchical' | 'mesh' | 'adaptive';
-    maxAgents: number;
-}
-export interface CoordinationResult {
-    success: boolean;
-    results: TaskResult[];
-    duration: number;
-}
-/**
- * Test application builder with full dependency injection
- *
- * @example
- * const app = createTestApplication()
- *   .withMockEventBus()
- *   .withMockTaskManager()
- *   .build();
- *
- * await app.services.taskManager.create(task);
- * expect(app.mocks.eventBus.publish).toHaveBeenCalled();
- */
-export declare function createTestApplication(): TestApplicationBuilder;
-/**
- * Test application structure with mocked services
- */
-export interface TestApplication {
-    services: {
-        eventBus: IEventBus;
-        taskManager: ITaskManager;
-        agentLifecycle: IAgentLifecycle;
-        memoryService: IMemoryService;
-        securityService: ISecurityService;
-        swarmCoordinator: ISwarmCoordinator;
-    };
-    mocks: {
-        eventBus: MockedInterface<IEventBus>;
-        taskManager: MockedInterface<ITaskManager>;
-        agentLifecycle: MockedInterface<IAgentLifecycle>;
-        memoryService: MockedInterface<IMemoryService>;
-        securityService: MockedInterface<ISecurityService>;
-        swarmCoordinator: MockedInterface<ISwarmCoordinator>;
-    };
-}
-/**
- * Builder class for constructing test applications
- */
-declare class TestApplicationBuilder {
-    private eventBus;
-    private taskManager;
-    private agentLifecycle;
-    private memoryService;
-    private securityService;
-    private swarmCoordinator;
-    /**
-     * Configure mock event bus with default behavior
-     */
-    withMockEventBus(configure?: (mock: MockedInterface<IEventBus>) => void): this;
-    /**
-     * Configure mock task manager with default behavior
-     */
-    withMockTaskManager(configure?: (mock: MockedInterface<ITaskManager>) => void): this;
-    /**
-     * Configure mock agent lifecycle with default behavior
-     */
-    withMockAgentLifecycle(configure?: (mock: MockedInterface<IAgentLifecycle>) => void): this;
-    /**
-     * Configure mock memory service with default behavior
-     */
-    withMockMemoryService(configure?: (mock: MockedInterface<IMemoryService>) => void): this;
-    /**
-     * Configure mock security service with default behavior
-     */
-    withMockSecurityService(configure?: (mock: MockedInterface<ISecurityService>) => void): this;
-    /**
-     * Configure mock swarm coordinator with default behavior
-     */
-    withMockSwarmCoordinator(configure?: (mock: MockedInterface<ISwarmCoordinator>) => void): this;
-    /**
-     * Build the test application with all configured mocks
-     */
-    build(): TestApplication;
-}
-export {};
-//# sourceMappingURL=test-application.d.ts.map

package/v3/@swarmdo/testing/dist/helpers/test-application.js

@@ -1,138 +0,0 @@
-import { createMock } from './create-mock.js';
-/**
- * Test application builder with full dependency injection
- *
- * @example
- * const app = createTestApplication()
- *   .withMockEventBus()
- *   .withMockTaskManager()
- *   .build();
- *
- * await app.services.taskManager.create(task);
- * expect(app.mocks.eventBus.publish).toHaveBeenCalled();
- */
-export function createTestApplication() {
-    return new TestApplicationBuilder();
-}
-/**
- * Builder class for constructing test applications
- */
-class TestApplicationBuilder {
-    eventBus = createMock();
-    taskManager = createMock();
-    agentLifecycle = createMock();
-    memoryService = createMock();
-    securityService = createMock();
-    swarmCoordinator = createMock();
-    /**
-     * Configure mock event bus with default behavior
-     */
-    withMockEventBus(configure) {
-        this.eventBus = createMock();
-        this.eventBus.publish.mockResolvedValue(undefined);
-        configure?.(this.eventBus);
-        return this;
-    }
-    /**
-     * Configure mock task manager with default behavior
-     */
-    withMockTaskManager(configure) {
-        this.taskManager = createMock();
-        this.taskManager.create.mockImplementation(async (def) => ({
-            id: `task-${Date.now()}`,
-            name: def.name,
-            type: def.type,
-            status: 'pending',
-            payload: def.payload,
-            createdAt: new Date(),
-        }));
-        this.taskManager.execute.mockResolvedValue({
-            taskId: 'test-task',
-            success: true,
-            duration: 100,
-        });
-        configure?.(this.taskManager);
-        return this;
-    }
-    /**
-     * Configure mock agent lifecycle with default behavior
-     */
-    withMockAgentLifecycle(configure) {
-        this.agentLifecycle = createMock();
-        this.agentLifecycle.spawn.mockImplementation(async (config) => ({
-            id: `agent-${Date.now()}`,
-            type: config.type,
-            name: config.name,
-            status: 'idle',
-        }));
-        this.agentLifecycle.listAgents.mockResolvedValue([]);
-        configure?.(this.agentLifecycle);
-        return this;
-    }
-    /**
-     * Configure mock memory service with default behavior
-     */
-    withMockMemoryService(configure) {
-        this.memoryService = createMock();
-        this.memoryService.store.mockResolvedValue(undefined);
-        this.memoryService.retrieve.mockResolvedValue(null);
-        this.memoryService.search.mockResolvedValue([]);
-        configure?.(this.memoryService);
-        return this;
-    }
-    /**
-     * Configure mock security service with default behavior
-     */
-    withMockSecurityService(configure) {
-        this.securityService = createMock();
-        this.securityService.validatePath.mockReturnValue(true);
-        this.securityService.hashPassword.mockResolvedValue('hashed');
-        this.securityService.verifyPassword.mockResolvedValue(true);
-        this.securityService.executeSecurely.mockResolvedValue({
-            stdout: '',
-            stderr: '',
-            exitCode: 0,
-        });
-        configure?.(this.securityService);
-        return this;
-    }
-    /**
-     * Configure mock swarm coordinator with default behavior
-     */
-    withMockSwarmCoordinator(configure) {
-        this.swarmCoordinator = createMock();
-        this.swarmCoordinator.initialize.mockResolvedValue(undefined);
-        this.swarmCoordinator.coordinate.mockResolvedValue({
-            success: true,
-            results: [],
-            duration: 0,
-        });
-        this.swarmCoordinator.shutdown.mockResolvedValue(undefined);
-        configure?.(this.swarmCoordinator);
-        return this;
-    }
-    /**
-     * Build the test application with all configured mocks
-     */
-    build() {
-        return {
-            services: {
-                eventBus: this.eventBus,
-                taskManager: this.taskManager,
-                agentLifecycle: this.agentLifecycle,
-                memoryService: this.memoryService,
-                securityService: this.securityService,
-                swarmCoordinator: this.swarmCoordinator,
-            },
-            mocks: {
-                eventBus: this.eventBus,
-                taskManager: this.taskManager,
-                agentLifecycle: this.agentLifecycle,
-                memoryService: this.memoryService,
-                securityService: this.securityService,
-                swarmCoordinator: this.swarmCoordinator,
-            },
-        };
-    }
-}
-//# sourceMappingURL=test-application.js.map