claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/swarm/index.js

@@ -0,0 +1,41 @@
+// Main exports for the swarm system
+export * from "./coordinator.js";
+export * from "./executor.js";
+export * from "./types.js";
+export * from "./strategies/base.js";
+export * from "./strategies/auto.js";
+export * from "./strategies/research.js";
+export * from "./memory.js";
+// Prompt copying system exports
+export * from "./prompt-copier.js";
+export * from "./prompt-copier-enhanced.js";
+export * from "./prompt-utils.js";
+export * from "./prompt-manager.js";
+export * from "./prompt-cli.js";
+// Optimizations
+export * from "./optimizations";
+// Utility function to get all exports
+export function getSwarmComponents() {
+    return {
+        // Core components
+        coordinator: ()=>import("./coordinator.js"),
+        executor: ()=>import("./executor.js"),
+        types: ()=>import("./types.js"),
+        // Strategies
+        strategies: {
+            base: ()=>import("./strategies/base.js"),
+            auto: ()=>import("./strategies/auto.js"),
+            research: ()=>import("./strategies/research.js")
+        },
+        // Memory
+        memory: ()=>import("./memory.js"),
+        // Prompt system
+        promptCopier: ()=>import("./prompt-copier.js"),
+        promptCopierEnhanced: ()=>import("./prompt-copier-enhanced.js"),
+        promptUtils: ()=>import("./prompt-utils.js"),
+        promptManager: ()=>import("./prompt-manager.js"),
+        promptCli: ()=>import("./prompt-cli.js"),
+        // Optimizations
+        optimizations: ()=>import("./optimizations")
+    };
+}

package/dist/src/swarm/json-output-aggregator.js

@@ -0,0 +1,267 @@
+/**
+ * JSON Output Aggregator for Non-Interactive Swarm Execution
+ * Collects and formats swarm results into a comprehensive JSON structure
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "events";
+import { promises as fs } from "node:fs";
+import { Logger } from "../core/logger.js";
+export class SwarmJsonOutputAggregator extends EventEmitter {
+    // Agent tracking methods
+    addAgent(agent) {
+        // Handle null/undefined agent IDs gracefully
+        if (!agent || !agent.id) {
+            this.logger.warn('Attempted to add agent with null/undefined ID, skipping');
+            return;
+        }
+        const agentIdStr = typeof agent.id === 'string' ? agent.id : agent.id.id;
+        const agentData = {
+            agentId: agentIdStr,
+            name: agent.name || agentIdStr,
+            type: agent.type,
+            status: agent.status,
+            startTime: new Date().toISOString(),
+            tasksCompleted: 0,
+            outputs: [],
+            errors: [],
+            metrics: {
+                memoryAccess: 0,
+                operationsPerformed: 0
+            }
+        };
+        this.agents.set(agentIdStr, agentData);
+        this.logger.debug('Agent added to output tracking', {
+            agentId: agentIdStr
+        });
+    }
+    updateAgent(agentId, updates) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            Object.assign(agent, updates);
+            this.logger.debug('Agent updated in output tracking', {
+                agentId,
+                updates
+            });
+        }
+    }
+    addAgentOutput(agentId, output) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.outputs.push(output);
+            agent.metrics.operationsPerformed++;
+        }
+        this.outputs.push(`[${agentId}] ${output}`);
+    }
+    addAgentError(agentId, error) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.errors.push(error);
+        }
+        this.errors.push(`[${agentId}] ${error}`);
+    }
+    // Task tracking methods
+    addTask(task) {
+        // Handle null/undefined task IDs gracefully
+        if (!task || !task.id) {
+            this.logger.warn('Attempted to add task with null/undefined ID, skipping');
+            return;
+        }
+        const taskIdStr = typeof task.id === 'string' ? task.id : task.id.id;
+        const taskData = {
+            taskId: taskIdStr,
+            name: task.name || taskIdStr,
+            type: task.type,
+            status: task.status,
+            assignedAgent: task.assignedAt ? typeof task.assignedAt === 'string' ? task.assignedAt : task.assignedAt.toString() : undefined,
+            startTime: new Date().toISOString(),
+            priority: task.priority || 'normal'
+        };
+        this.tasks.set(taskIdStr, taskData);
+        this.logger.debug('Task added to output tracking', {
+            taskId: taskIdStr
+        });
+    }
+    updateTask(taskId, updates) {
+        const task = this.tasks.get(taskId);
+        if (task) {
+            Object.assign(task, updates);
+            this.logger.debug('Task updated in output tracking', {
+                taskId,
+                updates
+            });
+        }
+    }
+    completeTask(taskId, result) {
+        const task = this.tasks.get(taskId);
+        if (task) {
+            task.status = 'completed';
+            task.endTime = new Date().toISOString();
+            task.duration = task.startTime ? Date.now() - new Date(task.startTime).getTime() : 0;
+            task.result = result;
+            task.output = result.output;
+            task.artifacts = result.artifacts;
+            // Update agent completion count
+            if (task.assignedAgent) {
+                const agent = this.agents.get(task.assignedAgent);
+                if (agent) {
+                    agent.tasksCompleted++;
+                }
+            }
+        }
+    }
+    // Global tracking methods
+    addInsight(insight) {
+        this.insights.push(insight);
+        this.logger.debug('Insight added', {
+            insight
+        });
+    }
+    addArtifact(key, artifact) {
+        this.artifacts[key] = artifact;
+        this.logger.debug('Artifact added', {
+            key
+        });
+    }
+    updateMetrics(updates) {
+        Object.assign(this.metrics, updates);
+    }
+    // Finalization and output
+    finalize(status = 'completed') {
+        this.endTime = new Date();
+        const duration = this.endTime.getTime() - this.startTime.getTime();
+        // Calculate summary statistics
+        const totalTasks = this.tasks.size;
+        const completedTasks = Array.from(this.tasks.values()).filter((task)=>task.status === 'completed').length;
+        const failedTasks = Array.from(this.tasks.values()).filter((task)=>task.status === 'failed').length;
+        const successRate = totalTasks > 0 ? completedTasks / totalTasks : 0;
+        // Finalize agent data
+        this.agents.forEach((agent)=>{
+            if (!agent.endTime) {
+                agent.endTime = this.endTime.toISOString();
+                agent.duration = Date.now() - new Date(agent.startTime).getTime();
+            }
+        });
+        const aggregate = {
+            swarmId: this.swarmId,
+            objective: this.objective,
+            startTime: this.startTime.toISOString(),
+            endTime: this.endTime.toISOString(),
+            duration,
+            status,
+            summary: {
+                totalAgents: this.agents.size,
+                totalTasks,
+                completedTasks,
+                failedTasks,
+                successRate
+            },
+            agents: Array.from(this.agents.values()),
+            tasks: Array.from(this.tasks.values()),
+            results: {
+                artifacts: this.artifacts,
+                outputs: this.outputs,
+                errors: this.errors,
+                insights: this.insights
+            },
+            metrics: this.metrics,
+            metadata: {
+                strategy: this.configuration.strategy || 'auto',
+                mode: this.configuration.mode || 'centralized',
+                configuration: this.configuration,
+                version: '2.0.0-alpha'
+            }
+        };
+        this.logger.info('Swarm output aggregation finalized', {
+            swarmId: this.swarmId,
+            status,
+            duration,
+            summary: aggregate.summary
+        });
+        return aggregate;
+    }
+    async saveToFile(filePath, status = 'completed') {
+        const aggregate = this.finalize(status);
+        const json = JSON.stringify(aggregate, this.circularReplacer(), 2);
+        await fs.writeFile(filePath, json, 'utf8');
+        this.logger.info('Swarm output saved to file', {
+            filePath,
+            size: json.length
+        });
+    }
+    getJsonOutput(status = 'completed') {
+        const aggregate = this.finalize(status);
+        return JSON.stringify(aggregate, this.circularReplacer(), 2);
+    }
+    // Handle circular references in JSON serialization
+    circularReplacer() {
+        const seen = new WeakSet();
+        return (key, value)=>{
+            if (typeof value === 'object' && value !== null) {
+                if (seen.has(value)) {
+                    return '[Circular]';
+                }
+                seen.add(value);
+            }
+            return value;
+        };
+    }
+    initializeMetrics() {
+        return {
+            // Performance metrics
+            throughput: 0,
+            latency: 0,
+            efficiency: 0,
+            reliability: 0,
+            // Quality metrics
+            averageQuality: 0,
+            defectRate: 0,
+            reworkRate: 0,
+            // Resource metrics
+            resourceUtilization: {
+                cpu: 0,
+                memory: 0,
+                disk: 0,
+                network: 0
+            },
+            costEfficiency: 0,
+            // Agent metrics
+            agentUtilization: 0,
+            agentSatisfaction: 0,
+            collaborationEffectiveness: 0,
+            // Timeline metrics
+            scheduleVariance: 0,
+            deadlineAdherence: 0
+        };
+    }
+    constructor(swarmId, objective, configuration = {}){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "swarmId", void 0), _define_property(this, "objective", void 0), _define_property(this, "startTime", void 0), _define_property(this, "endTime", void 0), _define_property(this, "configuration", void 0), // Data collection
+        _define_property(this, "agents", new Map()), _define_property(this, "tasks", new Map()), _define_property(this, "outputs", []), _define_property(this, "errors", []), _define_property(this, "insights", []), _define_property(this, "artifacts", {}), _define_property(this, "metrics", this.initializeMetrics());
+        this.swarmId = swarmId;
+        this.objective = objective;
+        this.configuration = configuration;
+        this.startTime = new Date();
+        this.logger = new Logger({
+            level: 'info',
+            format: 'json',
+            destination: 'console'
+        }, {
+            component: 'SwarmJsonAggregator'
+        });
+        this.logger.info('JSON output aggregator initialized', {
+            swarmId,
+            objective,
+            timestamp: this.startTime.toISOString()
+        });
+    }
+}