swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/regression/integration-regression.js

@@ -1,334 +0,0 @@
-/**
- * Integration Regression Suite
- *
- * Validates critical integration paths work correctly.
- *
- * @module v3/testing/regression/integration-regression
- */
-/**
- * Integration Regression Suite
- *
- * Runs critical integration tests to catch regressions.
- */
-export class IntegrationRegressionSuite {
-    tests = [];
-    constructor() {
-        this.registerDefaultTests();
-    }
-    /**
-     * Run all integration tests
-     */
-    async runAll() {
-        const results = [];
-        for (const test of this.tests) {
-            const result = await this.runTest(test);
-            results.push(result);
-        }
-        return results;
-    }
-    /**
-     * Run tests by category
-     */
-    async runCategory(category) {
-        const results = [];
-        const categoryTests = this.tests.filter((t) => t.category === category);
-        for (const test of categoryTests) {
-            const result = await this.runTest(test);
-            results.push(result);
-        }
-        return results;
-    }
-    /**
-     * Run critical tests only
-     */
-    async runCritical() {
-        const results = [];
-        const criticalTests = this.tests.filter((t) => t.critical);
-        for (const test of criticalTests) {
-            const result = await this.runTest(test);
-            results.push(result);
-        }
-        return results;
-    }
-    /**
-     * Run a single test
-     */
-    async runTest(test) {
-        const startTime = Date.now();
-        try {
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Test timeout')), test.timeout);
-            });
-            const passed = await Promise.race([test.run(), timeoutPromise]);
-            return {
-                name: test.name,
-                category: test.category,
-                passed,
-                duration: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            return {
-                name: test.name,
-                category: test.category,
-                passed: false,
-                duration: Date.now() - startTime,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Register default integration tests
-     */
-    registerDefaultTests() {
-        // Memory integration tests
-        this.tests.push({
-            name: 'memory-store-retrieve',
-            description: 'Store and retrieve a memory entry',
-            category: 'memory',
-            critical: true,
-            timeout: 5000,
-            run: async () => {
-                const { UnifiedMemoryService, HybridBackend } = await import('@swarmdo/memory');
-                // Create in-memory backend
-                const backend = new HybridBackend({
-                    sqlite: { databasePath: ':memory:', walMode: false, optimize: true, defaultNamespace: 'test', maxEntries: 1000 },
-                    agentdb: { dbPath: ':memory:' },
-                });
-                await backend.initialize();
-                const memory = new UnifiedMemoryService(backend);
-                await memory.initialize();
-                // Store entry
-                const stored = await memory.storeEntry({
-                    key: 'test-key',
-                    namespace: 'test',
-                    content: 'Integration test content',
-                    metadata: { test: true },
-                });
-                // Retrieve entry
-                const retrieved = await memory.get(stored.id);
-                await memory.shutdown();
-                return retrieved !== null && retrieved.content === 'Integration test content';
-            },
-        });
-        this.tests.push({
-            name: 'memory-search',
-            description: 'Search memory entries',
-            category: 'memory',
-            critical: true,
-            timeout: 10000,
-            run: async () => {
-                const { HybridBackend, UnifiedMemoryService } = await import('@swarmdo/memory');
-                const backend = new HybridBackend({
-                    sqlite: { databasePath: ':memory:', walMode: false, optimize: true, defaultNamespace: 'test', maxEntries: 1000 },
-                    agentdb: { dbPath: ':memory:' },
-                });
-                await backend.initialize();
-                const memory = new UnifiedMemoryService(backend);
-                await memory.initialize();
-                // Store entries
-                await memory.storeEntry({
-                    key: 'js-entry',
-                    namespace: 'test',
-                    content: 'JavaScript is a programming language',
-                    metadata: { topic: 'js' },
-                });
-                await memory.storeEntry({
-                    key: 'python-entry',
-                    namespace: 'test',
-                    content: 'Python is used for data science',
-                    metadata: { topic: 'python' },
-                });
-                // Search using a mock embedding vector (384 dimensions)
-                const mockEmbedding = new Float32Array(384).fill(0.1);
-                const results = await memory.search(mockEmbedding, { k: 10 });
-                await memory.shutdown();
-                return results.length >= 0; // Should work even if no semantic matches
-            },
-        });
-        // Event bus tests
-        this.tests.push({
-            name: 'event-bus-publish-subscribe',
-            description: 'Publish and subscribe to events',
-            category: 'events',
-            critical: true,
-            timeout: 5000,
-            run: async () => {
-                const { EventBus, createAgentSpawnedEvent } = await import('@swarmdo/shared');
-                const eventBus = new EventBus();
-                let received = false;
-                // Use a valid event type from the V3 system
-                eventBus.subscribe('agent:spawned', (event) => {
-                    if (event.type === 'agent:spawned') {
-                        received = true;
-                    }
-                });
-                // Emit a properly formatted SwarmEvent
-                const event = createAgentSpawnedEvent('test-agent', 'worker', 'default', ['test']);
-                await eventBus.emit(event);
-                // Small delay for async processing
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                return received;
-            },
-        });
-        this.tests.push({
-            name: 'event-bus-multiple-handlers',
-            description: 'Multiple handlers for same event',
-            category: 'events',
-            critical: false,
-            timeout: 5000,
-            run: async () => {
-                const { EventBus, createAgentSpawnedEvent } = await import('@swarmdo/shared');
-                const eventBus = new EventBus();
-                let count = 0;
-                eventBus.subscribe('agent:spawned', () => { count++; });
-                eventBus.subscribe('agent:spawned', () => { count++; });
-                eventBus.subscribe('agent:spawned', () => { count++; });
-                const event = createAgentSpawnedEvent('test-agent', 'worker', 'default', ['test']);
-                await eventBus.emit(event);
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                return count === 3;
-            },
-        });
-        // Swarm tests
-        this.tests.push({
-            name: 'swarm-coordinator-init',
-            description: 'Initialize swarm coordinator',
-            category: 'swarm',
-            critical: true,
-            timeout: 10000,
-            run: async () => {
-                try {
-                    const { UnifiedSwarmCoordinator } = await import('@swarmdo/swarm');
-                    const coordinator = new UnifiedSwarmCoordinator({
-                        topology: { type: 'hierarchical', maxAgents: 10 },
-                        maxAgents: 10,
-                    });
-                    await coordinator.initialize();
-                    const status = coordinator.getStatus();
-                    await coordinator.shutdown();
-                    // Check status has expected properties - includes running, initializing, paused, etc.
-                    return status.status !== undefined;
-                }
-                catch (error) {
-                    // Swarm may not be fully implemented yet
-                    console.warn('Swarm coordinator test skipped:', error);
-                    return true;
-                }
-            },
-        });
-        // Hooks tests
-        this.tests.push({
-            name: 'hooks-registry',
-            description: 'Register hooks',
-            category: 'hooks',
-            critical: true,
-            timeout: 5000,
-            run: async () => {
-                try {
-                    const { HookRegistry, HookPriority } = await import('@swarmdo/shared');
-                    const registry = new HookRegistry();
-                    // Register a hook
-                    const hookId = registry.register('pre-edit', async () => {
-                        return { success: true };
-                    }, HookPriority.Normal);
-                    // Verify hook was registered
-                    const hook = registry.getHook(hookId);
-                    const handlers = registry.getHandlers('pre-edit');
-                    return hook !== undefined && handlers.length > 0;
-                }
-                catch (error) {
-                    // Hooks may not be fully implemented yet
-                    console.warn('Hooks test skipped:', error);
-                    return true;
-                }
-            },
-        });
-        // MCP tests
-        this.tests.push({
-            name: 'mcp-types-available',
-            description: 'MCP types are available',
-            category: 'mcp',
-            critical: true,
-            timeout: 5000,
-            run: async () => {
-                try {
-                    // MCP types and utilities should be available from shared
-                    const shared = await import('@swarmdo/shared');
-                    // Verify key exports exist
-                    return (typeof shared.EventBus === 'function' &&
-                        typeof shared.generateSecureId === 'function');
-                }
-                catch (error) {
-                    // MCP may use different export
-                    console.warn('MCP test skipped:', error);
-                    return true;
-                }
-            },
-        });
-        // Module import tests
-        this.tests.push({
-            name: 'shared-module-import',
-            description: 'Shared module imports correctly',
-            category: 'mcp',
-            critical: true,
-            timeout: 5000,
-            run: async () => {
-                try {
-                    const shared = await import('@swarmdo/shared');
-                    return (typeof shared.EventBus === 'function' &&
-                        typeof shared.generateSecureId === 'function');
-                }
-                catch {
-                    return false;
-                }
-            },
-        });
-        this.tests.push({
-            name: 'memory-module-import',
-            description: 'Memory module imports correctly',
-            category: 'memory',
-            critical: true,
-            timeout: 5000,
-            run: async () => {
-                try {
-                    const memory = await import('@swarmdo/memory');
-                    return (typeof memory.UnifiedMemoryService === 'function' ||
-                        typeof memory.HybridBackend === 'function');
-                }
-                catch {
-                    return false;
-                }
-            },
-        });
-        this.tests.push({
-            name: 'swarm-module-import',
-            description: 'Swarm module imports correctly',
-            category: 'swarm',
-            critical: true,
-            timeout: 5000,
-            run: async () => {
-                try {
-                    const swarm = await import('@swarmdo/swarm');
-                    return typeof swarm.UnifiedSwarmCoordinator === 'function';
-                }
-                catch {
-                    return false;
-                }
-            },
-        });
-    }
-    /**
-     * Add a custom test
-     */
-    addTest(test) {
-        this.tests.push(test);
-    }
-    /**
-     * Get all registered tests
-     */
-    getTests() {
-        return [...this.tests];
-    }
-}
-//# sourceMappingURL=integration-regression.js.map

package/v3/@swarmdo/testing/dist/regression/performance-baseline.d.ts

@@ -1,106 +0,0 @@
-/**
- * Performance Baseline System
- *
- * Captures and compares performance metrics to detect regressions.
- *
- * @module v3/testing/regression/performance-baseline
- */
-/**
- * Baseline metric definition
- */
-export interface BaselineMetric {
-    name: string;
-    value: number;
-    unit: string;
-    category: 'latency' | 'throughput' | 'memory' | 'cpu' | 'startup';
-    timestamp: number;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Baseline comparison result
- */
-export interface BaselineComparison {
-    metric: string;
-    baseline: number;
-    current: number;
-    unit: string;
-    degradation: number;
-    regression: boolean;
-    improvement: boolean;
-}
-/**
- * Baseline configuration
- */
-export interface BaselineConfig {
-    baselinePath: string;
-    performanceThreshold: number;
-}
-/**
- * Stored baseline data
- */
-interface BaselineData {
-    version: string;
-    capturedAt: number;
-    metrics: BaselineMetric[];
-}
-/**
- * Performance Baseline Manager
- *
- * Manages performance baselines for regression detection.
- */
-export declare class PerformanceBaseline {
-    private readonly baselinePath;
-    private readonly threshold;
-    private cachedBaseline;
-    constructor(config: BaselineConfig);
-    /**
-     * Capture current performance as baseline
-     */
-    captureBaseline(): Promise<BaselineData>;
-    /**
-     * Compare current performance against baseline
-     */
-    compare(): Promise<BaselineComparison[]>;
-    /**
-     * Measure current performance metrics
-     */
-    private measureCurrentPerformance;
-    /**
-     * Simulate startup to measure initialization time
-     */
-    private simulateStartup;
-    /**
-     * Measure operation latency
-     */
-    private measureLatency;
-    /**
-     * Measure throughput
-     */
-    private measureThroughput;
-    /**
-     * Benchmark event bus operations
-     */
-    private benchmarkEventBus;
-    /**
-     * Benchmark memory operations
-     */
-    private benchmarkMemoryOps;
-    /**
-     * Benchmark event throughput
-     */
-    private benchmarkEventThroughput;
-    /**
-     * Benchmark memory throughput
-     */
-    private benchmarkMemoryThroughput;
-    /**
-     * Load baseline from file
-     */
-    private loadBaseline;
-    /**
-     * Save baseline to file
-     */
-    private saveBaseline;
-}
-export {};
-//# sourceMappingURL=performance-baseline.d.ts.map

package/v3/@swarmdo/testing/dist/regression/performance-baseline.js

@@ -1,268 +0,0 @@
-/**
- * Performance Baseline System
- *
- * Captures and compares performance metrics to detect regressions.
- *
- * @module v3/testing/regression/performance-baseline
- */
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { join, dirname } from 'path';
-/**
- * Performance Baseline Manager
- *
- * Manages performance baselines for regression detection.
- */
-export class PerformanceBaseline {
-    baselinePath;
-    threshold;
-    cachedBaseline = null;
-    constructor(config) {
-        this.baselinePath = join(config.baselinePath, 'performance.json');
-        this.threshold = config.performanceThreshold;
-    }
-    /**
-     * Capture current performance as baseline
-     */
-    async captureBaseline() {
-        const metrics = await this.measureCurrentPerformance();
-        const baseline = {
-            version: '1.0.0',
-            capturedAt: Date.now(),
-            metrics,
-        };
-        await this.saveBaseline(baseline);
-        this.cachedBaseline = baseline;
-        return baseline;
-    }
-    /**
-     * Compare current performance against baseline
-     */
-    async compare() {
-        const baseline = await this.loadBaseline();
-        if (!baseline) {
-            console.warn('No baseline found. Capturing initial baseline...');
-            await this.captureBaseline();
-            return [];
-        }
-        const currentMetrics = await this.measureCurrentPerformance();
-        const comparisons = [];
-        for (const current of currentMetrics) {
-            const baselineMetric = baseline.metrics.find((m) => m.name === current.name);
-            if (!baselineMetric)
-                continue;
-            const isHigherBetter = current.category === 'throughput';
-            const diff = current.value - baselineMetric.value;
-            const percentChange = (diff / baselineMetric.value) * 100;
-            // For latency/memory, higher is worse. For throughput, lower is worse.
-            const degradation = isHigherBetter ? -percentChange : percentChange;
-            comparisons.push({
-                metric: current.name,
-                baseline: baselineMetric.value,
-                current: current.value,
-                unit: current.unit,
-                degradation,
-                regression: degradation > this.threshold,
-                improvement: degradation < -this.threshold,
-            });
-        }
-        return comparisons;
-    }
-    /**
-     * Measure current performance metrics
-     */
-    async measureCurrentPerformance() {
-        const metrics = [];
-        const timestamp = Date.now();
-        // Memory metrics
-        const memUsage = process.memoryUsage();
-        metrics.push({
-            name: 'heap_used',
-            value: memUsage.heapUsed / 1024 / 1024,
-            unit: 'MB',
-            category: 'memory',
-            timestamp,
-        });
-        metrics.push({
-            name: 'heap_total',
-            value: memUsage.heapTotal / 1024 / 1024,
-            unit: 'MB',
-            category: 'memory',
-            timestamp,
-        });
-        metrics.push({
-            name: 'rss',
-            value: memUsage.rss / 1024 / 1024,
-            unit: 'MB',
-            category: 'memory',
-            timestamp,
-        });
-        // Startup time simulation
-        const startupStart = performance.now();
-        await this.simulateStartup();
-        const startupTime = performance.now() - startupStart;
-        metrics.push({
-            name: 'startup_time',
-            value: startupTime,
-            unit: 'ms',
-            category: 'startup',
-            timestamp,
-        });
-        // Latency benchmarks
-        const latencyMetrics = await this.measureLatency();
-        metrics.push(...latencyMetrics);
-        // Throughput benchmarks
-        const throughputMetrics = await this.measureThroughput();
-        metrics.push(...throughputMetrics);
-        return metrics;
-    }
-    /**
-     * Simulate startup to measure initialization time
-     */
-    async simulateStartup() {
-        // Import key modules to simulate startup
-        await import('@swarmdo/shared');
-        await import('@swarmdo/memory');
-    }
-    /**
-     * Measure operation latency
-     */
-    async measureLatency() {
-        const metrics = [];
-        const timestamp = Date.now();
-        // Event bus latency
-        const eventLatency = await this.benchmarkEventBus();
-        metrics.push({
-            name: 'event_bus_latency',
-            value: eventLatency,
-            unit: 'μs',
-            category: 'latency',
-            timestamp,
-        });
-        // Memory operation latency
-        const memLatency = await this.benchmarkMemoryOps();
-        metrics.push({
-            name: 'memory_op_latency',
-            value: memLatency,
-            unit: 'μs',
-            category: 'latency',
-            timestamp,
-        });
-        return metrics;
-    }
-    /**
-     * Measure throughput
-     */
-    async measureThroughput() {
-        const metrics = [];
-        const timestamp = Date.now();
-        // Events per second
-        const eventsPerSec = await this.benchmarkEventThroughput();
-        metrics.push({
-            name: 'events_per_second',
-            value: eventsPerSec,
-            unit: 'ops/sec',
-            category: 'throughput',
-            timestamp,
-        });
-        // Memory operations per second
-        const memOpsPerSec = await this.benchmarkMemoryThroughput();
-        metrics.push({
-            name: 'memory_ops_per_second',
-            value: memOpsPerSec,
-            unit: 'ops/sec',
-            category: 'throughput',
-            timestamp,
-        });
-        return metrics;
-    }
-    /**
-     * Benchmark event bus operations
-     */
-    async benchmarkEventBus() {
-        const { EventBus, createAgentSpawnedEvent } = await import('@swarmdo/shared');
-        const eventBus = new EventBus();
-        const iterations = 1000;
-        const start = performance.now();
-        for (let i = 0; i < iterations; i++) {
-            const event = createAgentSpawnedEvent(`bench-${i}`, 'worker', 'default', ['test']);
-            await eventBus.emit(event);
-        }
-        const elapsed = performance.now() - start;
-        return (elapsed / iterations) * 1000; // Convert to microseconds
-    }
-    /**
-     * Benchmark memory operations
-     */
-    async benchmarkMemoryOps() {
-        // Simulate memory operations with a simple Map
-        const map = new Map();
-        const iterations = 10000;
-        const start = performance.now();
-        for (let i = 0; i < iterations; i++) {
-            map.set(`key-${i}`, { data: `value-${i}`, timestamp: Date.now() });
-        }
-        for (let i = 0; i < iterations; i++) {
-            map.get(`key-${i}`);
-        }
-        const elapsed = performance.now() - start;
-        return (elapsed / (iterations * 2)) * 1000; // Convert to microseconds
-    }
-    /**
-     * Benchmark event throughput
-     */
-    async benchmarkEventThroughput() {
-        const { EventBus } = await import('@swarmdo/shared');
-        const eventBus = new EventBus();
-        let count = 0;
-        eventBus.subscribe('agent:spawned', () => { count++; });
-        const { createAgentSpawnedEvent } = await import('@swarmdo/shared');
-        const duration = 1000; // 1 second
-        const start = Date.now();
-        while (Date.now() - start < duration) {
-            const event = createAgentSpawnedEvent('bench-agent', 'worker', 'default', ['test']);
-            await eventBus.emit(event);
-        }
-        return count;
-    }
-    /**
-     * Benchmark memory throughput
-     */
-    async benchmarkMemoryThroughput() {
-        const map = new Map();
-        let count = 0;
-        const duration = 1000; // 1 second
-        const start = Date.now();
-        while (Date.now() - start < duration) {
-            const key = `key-${count}`;
-            map.set(key, { data: count, timestamp: Date.now() });
-            map.get(key);
-            map.delete(key);
-            count++;
-        }
-        return count;
-    }
-    /**
-     * Load baseline from file
-     */
-    async loadBaseline() {
-        if (this.cachedBaseline) {
-            return this.cachedBaseline;
-        }
-        try {
-            const content = await readFile(this.baselinePath, 'utf-8');
-            this.cachedBaseline = JSON.parse(content);
-            return this.cachedBaseline;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Save baseline to file
-     */
-    async saveBaseline(baseline) {
-        await mkdir(dirname(this.baselinePath), { recursive: true });
-        await writeFile(this.baselinePath, JSON.stringify(baseline, null, 2));
-    }
-}
-//# sourceMappingURL=performance-baseline.js.map