agentic-qe 1.9.4 → 2.1.0

package/dist/cli/init/skills.js

@@ -66,7 +66,7 @@ async function copySkillTemplates(force = false) {
     const targetPath = path.join(process.cwd(), '.claude/skills');
     await fs.ensureDir(targetPath);
     // QE-specific skill patterns (NOT claude-flow, github, flow-nexus, agentdb-*, hive-mind, hooks, performance-analysis, reasoningbank-*, sparc-methodology)
-    // Total: 40 QE skills (updated from 38 - added accessibility-testing, shift-left-testing, shift-right-testing, verification-quality, visual-testing-advanced, xp-practices, technical-writing)
+    // Total: 41 QE skills (updated from 40 - added testability-scoring contributed by @fndlalit)
     const QE_SKILL_PATTERNS = [
         /^accessibility-testing$/,
         /^agentic-quality-engineering$/,
@@ -101,6 +101,7 @@ async function copySkillTemplates(force = false) {
         /^tdd-london-chicago$/,
         /^technical-writing$/,
         /^test-automation-strategy$/,
+        /^testability-scoring$/, // Contributed by @fndlalit - https://github.com/fndlalit
         /^test-data-management$/,
         /^test-design-techniques$/,
         /^test-environment-management$/,

package/dist/cli/init/skills.js.map

@@ -1 +1 @@
-{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../../src/cli/init/skills.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../../src/cli/init/skills.ts"],"names":[],"mappings":"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"}

package/dist/core/SwarmCoordinator.d.ts

@@ -0,0 +1,180 @@
+/**
+ * SwarmCoordinator - Master Orchestration Layer
+ *
+ * Coordinates SwarmOptimizer, WorkflowOrchestrator, and UnifiedMemoryCoordinator
+ * to provide unified swarm management with feedback loops and adaptive optimization.
+ */
+import { EventEmitter } from 'events';
+import { SwarmMemoryManager } from './memory/SwarmMemoryManager.js';
+import { QEEventBus } from './events/QEEventBus.js';
+import { Task, Agent } from './optimization/SwarmOptimizer.js';
+/**
+ * Swarm topology types
+ */
+export type SwarmTopology = 'hierarchical' | 'mesh' | 'ring' | 'star' | 'adaptive';
+/**
+ * Swarm status
+ */
+export type SwarmStatus = 'initializing' | 'running' | 'paused' | 'degraded' | 'stopped' | 'error';
+/**
+ * Coordinator configuration
+ */
+export interface SwarmCoordinatorConfig {
+    /** Default topology to use */
+    defaultTopology: SwarmTopology;
+    /** Maximum agents in swarm */
+    maxAgents: number;
+    /** Enable automatic optimization */
+    autoOptimize: boolean;
+    /** Optimization interval in milliseconds */
+    optimizationInterval: number;
+    /** Enable health monitoring */
+    healthMonitoring: boolean;
+    /** Health check interval in milliseconds */
+    healthCheckInterval: number;
+    /** Enable performance feedback loop */
+    enableFeedbackLoop: boolean;
+    /** Feedback loop interval in milliseconds */
+    feedbackInterval: number;
+    /** Enable automatic recovery */
+    autoRecovery: boolean;
+}
+/**
+ * Swarm metrics
+ */
+export interface SwarmMetrics {
+    activeAgents: number;
+    totalTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    averageTaskDuration: number;
+    throughput: number;
+    queueDepth: number;
+    memoryUsage: number;
+    cpuUtilization: number;
+    errorRate: number;
+    topology: SwarmTopology;
+    uptime: number;
+}
+/**
+ * Feedback loop data
+ */
+export interface FeedbackData {
+    timestamp: Date;
+    metrics: SwarmMetrics;
+    optimizerRecommendations: any;
+    orchestratorStatus: any;
+    memoryHealth: any;
+}
+/**
+ * Swarm Coordinator - Master orchestration layer
+ */
+export declare class SwarmCoordinator extends EventEmitter {
+    private readonly logger;
+    private readonly config;
+    private memoryManager;
+    private eventBus;
+    private optimizer;
+    private orchestrator;
+    private memoryCoordinator;
+    private recoveryOrchestrator;
+    private status;
+    private currentTopology;
+    private agents;
+    private startTime;
+    private metricsHistory;
+    private optimizationTimer?;
+    private healthCheckTimer?;
+    private feedbackTimer?;
+    private taskStats;
+    constructor(memoryManager: SwarmMemoryManager, eventBus: QEEventBus, config?: Partial<SwarmCoordinatorConfig>);
+    /**
+     * Initialize the coordinator and all sub-components
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get current swarm status
+     */
+    getStatus(): SwarmStatus;
+    /**
+     * Get current topology
+     */
+    getTopology(): SwarmTopology;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): SwarmMetrics;
+    /**
+     * Register an agent with the swarm
+     */
+    registerAgent(agent: Agent): Promise<void>;
+    /**
+     * Unregister an agent from the swarm
+     */
+    unregisterAgent(agentId: string): Promise<void>;
+    /**
+     * Submit a task for execution
+     */
+    submitTask(task: Task): Promise<string>;
+    /**
+     * Change swarm topology
+     */
+    changeTopology(newTopology: SwarmTopology): Promise<void>;
+    /**
+     * Pause the swarm
+     */
+    pause(): Promise<void>;
+    /**
+     * Resume the swarm
+     */
+    resume(): Promise<void>;
+    /**
+     * Shutdown the coordinator
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Force optimization cycle
+     */
+    optimize(): Promise<void>;
+    /**
+     * Get feedback loop data
+     */
+    getFeedbackData(): Promise<FeedbackData>;
+    /**
+     * Set up event handlers for sub-components
+     */
+    private setupEventHandlers;
+    /**
+     * Start optimization loop
+     */
+    private startOptimizationLoop;
+    /**
+     * Start health monitoring
+     */
+    private startHealthMonitoring;
+    /**
+     * Start feedback loop
+     */
+    private startFeedbackLoop;
+    /**
+     * Stop all timers
+     */
+    private stopTimers;
+    /**
+     * Build workload profile from metrics
+     */
+    private buildWorkloadProfile;
+    /**
+     * Persist current metrics
+     */
+    private persistMetrics;
+}
+/**
+ * Get or create default coordinator
+ */
+export declare function getSwarmCoordinator(memoryManager?: SwarmMemoryManager, eventBus?: QEEventBus, config?: Partial<SwarmCoordinatorConfig>): Promise<SwarmCoordinator>;
+/**
+ * Reset default coordinator (for testing)
+ */
+export declare function resetSwarmCoordinator(): Promise<void>;
+//# sourceMappingURL=SwarmCoordinator.d.ts.map

package/dist/core/SwarmCoordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwarmCoordinator.d.ts","sourceRoot":"","sources":["../../src/core/SwarmCoordinator.ts"],"names":[],"mappings":"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"}

package/dist/core/SwarmCoordinator.js

@@ -0,0 +1,473 @@
+"use strict";
+/**
+ * SwarmCoordinator - Master Orchestration Layer
+ *
+ * Coordinates SwarmOptimizer, WorkflowOrchestrator, and UnifiedMemoryCoordinator
+ * to provide unified swarm management with feedback loops and adaptive optimization.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwarmCoordinator = void 0;
+exports.getSwarmCoordinator = getSwarmCoordinator;
+exports.resetSwarmCoordinator = resetSwarmCoordinator;
+const events_1 = require("events");
+const Logger_js_1 = require("../utils/Logger.js");
+const SwarmOptimizer_js_1 = require("./optimization/SwarmOptimizer.js");
+const WorkflowOrchestrator_js_1 = require("./orchestration/WorkflowOrchestrator.js");
+const UnifiedMemoryCoordinator_js_1 = require("./memory/UnifiedMemoryCoordinator.js");
+const index_js_1 = require("./recovery/index.js");
+// CPU tracking state for utilization calculation
+let lastCpuUsage = process.cpuUsage();
+let lastCpuTime = Date.now();
+/**
+ * Calculate current CPU usage percentage
+ * Uses process.cpuUsage() delta to compute actual CPU utilization
+ */
+function calculateCpuUsage() {
+    const currentCpuUsage = process.cpuUsage(lastCpuUsage);
+    const currentTime = Date.now();
+    const elapsedMs = currentTime - lastCpuTime;
+    if (elapsedMs === 0)
+        return 0;
+    // Total CPU time used in microseconds (user + system)
+    const totalCpuTime = currentCpuUsage.user + currentCpuUsage.system;
+    // Convert to percentage: (microseconds / 1000 = ms) / elapsed ms * 100
+    const cpuPercent = (totalCpuTime / 1000 / elapsedMs) * 100;
+    // Update tracking state for next calculation
+    lastCpuUsage = process.cpuUsage();
+    lastCpuTime = currentTime;
+    // Clamp to 0-1 range (normalized utilization)
+    return Math.min(cpuPercent / 100, 1);
+}
+/**
+ * Swarm Coordinator - Master orchestration layer
+ */
+class SwarmCoordinator extends events_1.EventEmitter {
+    constructor(memoryManager, eventBus, config) {
+        super();
+        // State
+        this.status = 'initializing';
+        this.currentTopology = 'hierarchical';
+        this.agents = new Map();
+        this.startTime = new Date();
+        this.metricsHistory = [];
+        // Metrics tracking
+        this.taskStats = {
+            total: 0,
+            completed: 0,
+            failed: 0,
+            durations: [],
+        };
+        this.logger = Logger_js_1.Logger.getInstance();
+        this.memoryManager = memoryManager;
+        this.eventBus = eventBus;
+        this.config = {
+            defaultTopology: 'hierarchical',
+            maxAgents: 10,
+            autoOptimize: true,
+            optimizationInterval: 60000, // 1 minute
+            healthMonitoring: true,
+            healthCheckInterval: 30000, // 30 seconds
+            enableFeedbackLoop: true,
+            feedbackInterval: 120000, // 2 minutes
+            autoRecovery: true,
+            ...config,
+        };
+        // Initialize core components
+        this.optimizer = new SwarmOptimizer_js_1.SwarmOptimizer(memoryManager, eventBus);
+        this.orchestrator = new WorkflowOrchestrator_js_1.WorkflowOrchestrator(memoryManager, eventBus, this.optimizer);
+        this.memoryCoordinator = new UnifiedMemoryCoordinator_js_1.UnifiedMemoryCoordinator();
+        this.recoveryOrchestrator = (0, index_js_1.getRecoveryOrchestrator)();
+        this.currentTopology = this.config.defaultTopology;
+    }
+    /**
+     * Initialize the coordinator and all sub-components
+     */
+    async initialize() {
+        this.logger.info('Initializing SwarmCoordinator');
+        this.status = 'initializing';
+        try {
+            // Initialize components in order
+            await this.optimizer.initialize();
+            await this.orchestrator.initialize();
+            await this.memoryCoordinator.initialize();
+            // Set up event handlers
+            this.setupEventHandlers();
+            // Start monitoring if enabled
+            if (this.config.autoOptimize) {
+                this.startOptimizationLoop();
+            }
+            if (this.config.healthMonitoring) {
+                this.startHealthMonitoring();
+            }
+            if (this.config.enableFeedbackLoop) {
+                this.startFeedbackLoop();
+            }
+            this.status = 'running';
+            this.startTime = new Date();
+            this.emit('initialized', { topology: this.currentTopology });
+            this.logger.info('SwarmCoordinator initialized successfully');
+        }
+        catch (error) {
+            this.status = 'error';
+            this.logger.error('Failed to initialize SwarmCoordinator:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get current swarm status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Get current topology
+     */
+    getTopology() {
+        return this.currentTopology;
+    }
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        const avgDuration = this.taskStats.durations.length > 0
+            ? this.taskStats.durations.reduce((a, b) => a + b, 0) / this.taskStats.durations.length
+            : 0;
+        const uptime = Date.now() - this.startTime.getTime();
+        const throughput = uptime > 0
+            ? (this.taskStats.completed / (uptime / 1000))
+            : 0;
+        const errorRate = this.taskStats.total > 0
+            ? this.taskStats.failed / this.taskStats.total
+            : 0;
+        // Get queue depth from orchestrator
+        const queueDepth = this.orchestrator?.getQueueDepth() ?? 0;
+        // Calculate real CPU utilization using process.cpuUsage()
+        const cpuUtilization = calculateCpuUsage();
+        return {
+            activeAgents: this.agents.size,
+            totalTasks: this.taskStats.total,
+            completedTasks: this.taskStats.completed,
+            failedTasks: this.taskStats.failed,
+            averageTaskDuration: avgDuration,
+            throughput,
+            queueDepth,
+            memoryUsage: process.memoryUsage().heapUsed,
+            cpuUtilization,
+            errorRate,
+            topology: this.currentTopology,
+            uptime,
+        };
+    }
+    /**
+     * Register an agent with the swarm
+     */
+    async registerAgent(agent) {
+        if (this.agents.size >= this.config.maxAgents) {
+            throw new Error(`Maximum agent limit (${this.config.maxAgents}) reached`);
+        }
+        this.agents.set(agent.id, agent);
+        this.emit('agent:registered', { agentId: agent.id, type: agent.type });
+        this.logger.info(`Agent registered: ${agent.id} (${agent.type})`);
+    }
+    /**
+     * Unregister an agent from the swarm
+     */
+    async unregisterAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            this.agents.delete(agentId);
+            this.emit('agent:unregistered', { agentId, type: agent.type });
+            this.logger.info(`Agent unregistered: ${agentId}`);
+        }
+    }
+    /**
+     * Submit a task for execution
+     */
+    async submitTask(task) {
+        this.taskStats.total++;
+        try {
+            // Use recovery orchestrator for resilient execution
+            const result = await this.recoveryOrchestrator.executeWithRecovery('orchestration', `task:${task.id}`, async () => {
+                // Get optimal allocation from optimizer
+                const allocation = await this.optimizer.allocateAgents([task], Array.from(this.agents.values()));
+                // Execute through orchestrator
+                // Note: WorkflowOrchestrator handles actual execution
+                return task.id;
+            });
+            this.emit('task:submitted', { taskId: task.id, priority: task.priority });
+            return result;
+        }
+        catch (error) {
+            this.taskStats.failed++;
+            throw error;
+        }
+    }
+    /**
+     * Change swarm topology
+     */
+    async changeTopology(newTopology) {
+        if (newTopology === this.currentTopology) {
+            return;
+        }
+        this.logger.info(`Changing topology: ${this.currentTopology} -> ${newTopology}`);
+        const oldTopology = this.currentTopology;
+        this.currentTopology = newTopology;
+        // Notify all agents of topology change
+        this.emit('topology:changed', { from: oldTopology, to: newTopology });
+        // Store in memory for persistence
+        await this.memoryCoordinator.store('swarm:topology', { topology: newTopology, changedAt: new Date().toISOString() });
+    }
+    /**
+     * Pause the swarm
+     */
+    async pause() {
+        this.status = 'paused';
+        this.stopTimers();
+        this.emit('paused');
+        this.logger.info('Swarm paused');
+    }
+    /**
+     * Resume the swarm
+     */
+    async resume() {
+        this.status = 'running';
+        if (this.config.autoOptimize) {
+            this.startOptimizationLoop();
+        }
+        if (this.config.healthMonitoring) {
+            this.startHealthMonitoring();
+        }
+        if (this.config.enableFeedbackLoop) {
+            this.startFeedbackLoop();
+        }
+        this.emit('resumed');
+        this.logger.info('Swarm resumed');
+    }
+    /**
+     * Shutdown the coordinator
+     */
+    async shutdown() {
+        this.logger.info('Shutting down SwarmCoordinator');
+        this.status = 'stopped';
+        this.stopTimers();
+        // Persist final metrics
+        await this.persistMetrics();
+        this.emit('shutdown');
+        this.removeAllListeners();
+        this.logger.info('SwarmCoordinator shutdown complete');
+    }
+    /**
+     * Force optimization cycle
+     */
+    async optimize() {
+        this.logger.debug('Running optimization cycle');
+        try {
+            // Get current workload profile
+            const metrics = this.getMetrics();
+            const workloadProfile = this.buildWorkloadProfile(metrics);
+            // Get topology recommendation
+            const recommendation = await this.optimizer.recommendTopology(workloadProfile);
+            // Apply recommendation if different from current
+            if (recommendation && recommendation.topology !== this.currentTopology) {
+                if (recommendation.confidence > 0.7) {
+                    await this.changeTopology(recommendation.topology);
+                }
+            }
+            this.emit('optimization:complete', { recommendation, metrics });
+        }
+        catch (error) {
+            this.logger.error('Optimization cycle failed:', error);
+            this.emit('optimization:failed', { error });
+        }
+    }
+    /**
+     * Get feedback loop data
+     */
+    async getFeedbackData() {
+        const metrics = this.getMetrics();
+        const memoryHealth = await this.memoryCoordinator.checkHealth();
+        // Get latest optimization recommendations from optimizer
+        const optimizerRecommendations = this.optimizer?.getLatestRecommendation() ?? null;
+        // Get orchestrator status with queue depth and execution info
+        const orchestratorStatus = this.orchestrator?.getStatus() ?? { status: 'unknown' };
+        return {
+            timestamp: new Date(),
+            metrics,
+            optimizerRecommendations,
+            orchestratorStatus,
+            memoryHealth: { healthy: memoryHealth },
+        };
+    }
+    /**
+     * Set up event handlers for sub-components
+     */
+    setupEventHandlers() {
+        // Forward events from sub-components
+        this.eventBus.subscribe('agent:completed', (data) => {
+            this.taskStats.completed++;
+            if (data.duration) {
+                this.taskStats.durations.push(data.duration);
+                // Keep only last 1000 durations
+                if (this.taskStats.durations.length > 1000) {
+                    this.taskStats.durations = this.taskStats.durations.slice(-1000);
+                }
+            }
+        });
+        this.eventBus.subscribe('agent:failed', () => {
+            this.taskStats.failed++;
+        });
+        // Listen for recovery events
+        this.recoveryOrchestrator.on('recovery-success', (data) => {
+            this.logger.info(`Recovery succeeded for ${data.component}:`, data);
+        });
+        this.recoveryOrchestrator.on('recovery-failed', (data) => {
+            this.logger.warn(`Recovery failed for ${data.component}:`, data);
+            if (this.status !== 'degraded') {
+                this.status = 'degraded';
+                this.emit('status:degraded', { reason: data.error });
+            }
+        });
+    }
+    /**
+     * Start optimization loop
+     */
+    startOptimizationLoop() {
+        this.optimizationTimer = setInterval(() => {
+            this.optimize().catch(err => {
+                this.logger.error('Optimization loop error:', err);
+            });
+        }, this.config.optimizationInterval);
+    }
+    /**
+     * Start health monitoring
+     */
+    startHealthMonitoring() {
+        this.healthCheckTimer = setInterval(async () => {
+            try {
+                const memoryHealthy = await this.memoryCoordinator.checkHealth();
+                if (!memoryHealthy && this.config.autoRecovery) {
+                    await this.recoveryOrchestrator.attemptRecovery('memory', new Error('Memory health check failed'));
+                }
+                this.emit('health:checked', {
+                    memoryHealthy,
+                    status: this.status,
+                });
+            }
+            catch (error) {
+                this.logger.error('Health check failed:', error);
+            }
+        }, this.config.healthCheckInterval);
+    }
+    /**
+     * Start feedback loop
+     */
+    startFeedbackLoop() {
+        this.feedbackTimer = setInterval(async () => {
+            try {
+                const feedbackData = await this.getFeedbackData();
+                // Store metrics history
+                this.metricsHistory.push(feedbackData.metrics);
+                if (this.metricsHistory.length > 100) {
+                    this.metricsHistory = this.metricsHistory.slice(-100);
+                }
+                // Persist to memory (24 hours TTL)
+                await this.memoryCoordinator.store(`swarm:feedback:${Date.now()}`, feedbackData, 86400000 // 24 hours in ms
+                );
+                this.emit('feedback:collected', feedbackData);
+            }
+            catch (error) {
+                this.logger.error('Feedback loop error:', error);
+            }
+        }, this.config.feedbackInterval);
+    }
+    /**
+     * Stop all timers
+     */
+    stopTimers() {
+        if (this.optimizationTimer) {
+            clearInterval(this.optimizationTimer);
+            this.optimizationTimer = undefined;
+        }
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = undefined;
+        }
+        if (this.feedbackTimer) {
+            clearInterval(this.feedbackTimer);
+            this.feedbackTimer = undefined;
+        }
+    }
+    /**
+     * Build workload profile from metrics
+     */
+    buildWorkloadProfile(metrics) {
+        // Calculate average complexity from multiple factors:
+        // 1. Duration factor: normalized task duration (0-1 scale, baseline 5000ms)
+        const durationFactor = Math.min(metrics.averageTaskDuration / 5000, 1);
+        // 2. Error factor: higher error rates indicate complex/problematic tasks
+        const errorFactor = metrics.errorRate;
+        // 3. Throughput factor: low throughput relative to agents indicates coordination complexity
+        const expectedThroughput = metrics.activeAgents * 0.5; // 0.5 tasks/sec per agent baseline
+        const throughputFactor = metrics.activeAgents > 0 && expectedThroughput > 0
+            ? Math.max(0, 1 - (metrics.throughput / expectedThroughput))
+            : 0;
+        // 4. Memory factor: high memory usage indicates data-intensive complexity
+        const memoryFactor = Math.min(metrics.memoryUsage / 1073741824, 1); // 1GB baseline
+        // Weighted average complexity (0-1 scale)
+        const averageComplexity = Math.min(1, Math.max(0, durationFactor * 0.4 + // Duration is primary indicator
+            errorFactor * 0.2 + // Errors suggest complexity
+            throughputFactor * 0.2 + // Low throughput means coordination overhead
+            memoryFactor * 0.2 // Memory usage indicates data complexity
+        ));
+        return {
+            taskCount: metrics.totalTasks,
+            averageComplexity,
+            parallelizationPotential: metrics.activeAgents > 1 ? 0.8 : 0.3,
+            coordinationNeeds: metrics.activeAgents > 5 ? 0.8 : 0.4,
+            memoryIntensity: metrics.memoryUsage > 500000000 ? 0.8 : 0.4, // 500MB threshold
+        };
+    }
+    /**
+     * Persist current metrics
+     */
+    async persistMetrics() {
+        try {
+            await this.memoryCoordinator.store('swarm:metrics:final', {
+                metrics: this.getMetrics(),
+                history: this.metricsHistory.slice(-20),
+                shutdownTime: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to persist metrics:', error);
+        }
+    }
+}
+exports.SwarmCoordinator = SwarmCoordinator;
+/**
+ * Default coordinator instance
+ */
+let defaultCoordinator = null;
+/**
+ * Get or create default coordinator
+ */
+async function getSwarmCoordinator(memoryManager, eventBus, config) {
+    if (!defaultCoordinator && memoryManager && eventBus) {
+        defaultCoordinator = new SwarmCoordinator(memoryManager, eventBus, config);
+        await defaultCoordinator.initialize();
+    }
+    if (!defaultCoordinator) {
+        throw new Error('SwarmCoordinator not initialized. Provide memoryManager and eventBus.');
+    }
+    return defaultCoordinator;
+}
+/**
+ * Reset default coordinator (for testing)
+ */
+async function resetSwarmCoordinator() {
+    if (defaultCoordinator) {
+        await defaultCoordinator.shutdown();
+        defaultCoordinator = null;
+    }
+}
+//# sourceMappingURL=SwarmCoordinator.js.map