claude-flow 3.25.6 → 3.26.0

package/v3/@claude-flow/shared/dist/plugins/official/hive-mind-plugin.js

@@ -1,241 +0,0 @@
-/**
- * HiveMind Plugin - Official Plugin (ADR-004)
- *
- * Implements collective intelligence and emergent behavior patterns.
- * Part of the official plugin collection.
- *
- * @module v3/shared/plugins/official/hive-mind
- */
-import { HookEvent, HookPriority } from '../../hooks/index.js';
-/**
- * HiveMind Plugin Implementation
- */
-export class HiveMindPlugin {
-    id = 'hive-mind';
-    name = 'HiveMind Collective Intelligence';
-    version = '1.0.0';
-    description = 'Collective intelligence with consensus mechanisms and emergent behavior';
-    context;
-    config;
-    decisions = new Map();
-    patterns = new Map();
-    collectiveMemory = new Map();
-    constructor(config) {
-        this.config = {
-            enabled: true,
-            consensusThreshold: 0.7,
-            collectiveMemoryEnabled: true,
-            emergentBehaviorEnabled: true,
-            maxVotingRounds: 3,
-            decisionTimeout: 30000,
-            ...config,
-        };
-    }
-    async initialize(context) {
-        this.context = context;
-        // Register hooks for collective behavior
-        context.hooks?.register(HookEvent.PreTaskExecute, async (ctx) => {
-            // Check collective memory for similar tasks
-            const taskKey = this.generateTaskKey(ctx.task);
-            const previous = this.collectiveMemory.get(taskKey);
-            if (previous && ctx.metadata) {
-                ctx.metadata.collectiveInsight = previous;
-            }
-            return { success: true, continueChain: true };
-        }, HookPriority.Normal, { name: 'hive-mind-pre-task' });
-        context.hooks?.register(HookEvent.PostTaskComplete, async (ctx) => {
-            // Store result in collective memory
-            if (this.config.collectiveMemoryEnabled && ctx.task) {
-                const taskInfo = ctx.task;
-                this.collectiveMemory.set(taskInfo.id, {
-                    result: ctx.metadata?.result,
-                    timestamp: new Date(),
-                    agentId: ctx.agent?.id,
-                });
-            }
-            // Detect emergent patterns
-            if (this.config.emergentBehaviorEnabled && ctx.task) {
-                this.detectEmergentPatterns(ctx.task);
-            }
-            return { success: true, continueChain: true };
-        }, HookPriority.Normal, { name: 'hive-mind-post-task' });
-    }
-    async shutdown() {
-        this.decisions.clear();
-        this.patterns.clear();
-        this.collectiveMemory.clear();
-        this.context = undefined;
-    }
-    // ============================================================================
-    // Collective Decision Making
-    // ============================================================================
-    /**
-     * Request a collective decision from the swarm
-     */
-    async requestDecision(question, options) {
-        const decision = {
-            id: `decision-${Date.now()}`,
-            question,
-            votes: new Map(),
-            consensusConfidence: 0,
-            timestamp: new Date(),
-        };
-        this.decisions.set(decision.id, decision);
-        // Generate initial vote distribution from available agents
-        // When integrated with swarm, this receives real agent votes via event system
-        for (let i = 0; i < options.length && i < 3; i++) {
-            decision.votes.set(`agent-${i}`, {
-                agentId: `agent-${i}`,
-                vote: options[i % options.length],
-                confidence: 0.7 + Math.random() * 0.3,
-            });
-        }
-        // Calculate consensus
-        const voteCounts = new Map();
-        for (const vote of decision.votes.values()) {
-            voteCounts.set(vote.vote, (voteCounts.get(vote.vote) ?? 0) + vote.confidence);
-        }
-        let maxVotes = 0;
-        let consensusOption = '';
-        for (const [option, count] of voteCounts) {
-            if (count > maxVotes) {
-                maxVotes = count;
-                consensusOption = option;
-            }
-        }
-        const totalConfidence = Array.from(decision.votes.values()).reduce((sum, v) => sum + v.confidence, 0);
-        const consensusConfidence = maxVotes / totalConfidence;
-        if (consensusConfidence >= this.config.consensusThreshold) {
-            decision.consensus = consensusOption;
-            decision.consensusConfidence = consensusConfidence;
-        }
-        return decision;
-    }
-    /**
-     * Submit a vote for a decision
-     */
-    submitVote(decisionId, agentId, vote, confidence) {
-        const decision = this.decisions.get(decisionId);
-        if (!decision)
-            return false;
-        decision.votes.set(agentId, { agentId, vote, confidence });
-        this.recalculateConsensus(decision);
-        return true;
-    }
-    /**
-     * Get decision result
-     */
-    getDecision(decisionId) {
-        return this.decisions.get(decisionId);
-    }
-    // ============================================================================
-    // Emergent Behavior Detection
-    // ============================================================================
-    /**
-     * Detect emergent patterns from agent behavior
-     */
-    detectEmergentPatterns(taskData) {
-        // Analyze task patterns
-        const type = taskData.description?.split(' ')[0] ?? 'unknown';
-        const patternKey = `pattern-${type}`;
-        const existing = this.patterns.get(patternKey);
-        if (existing) {
-            existing.strength += 0.1;
-            if (!existing.contributors.includes(String(taskData.agentId))) {
-                existing.contributors.push(String(taskData.agentId));
-            }
-        }
-        else if (this.collectiveMemory.size > 5) {
-            // Only create patterns after enough collective memory
-            this.patterns.set(patternKey, {
-                id: patternKey,
-                type: 'task-pattern',
-                description: `Emergent pattern for ${type} tasks`,
-                contributors: [String(taskData.agentId)],
-                strength: 0.5,
-                discoveredAt: new Date(),
-            });
-        }
-    }
-    /**
-     * Get emergent patterns
-     */
-    getEmergentPatterns() {
-        return Array.from(this.patterns.values()).filter((p) => p.strength > 0.5);
-    }
-    // ============================================================================
-    // Collective Memory
-    // ============================================================================
-    /**
-     * Store in collective memory
-     */
-    storeCollective(key, value) {
-        this.collectiveMemory.set(key, {
-            value,
-            timestamp: new Date(),
-            accessCount: 0,
-        });
-    }
-    /**
-     * Retrieve from collective memory
-     */
-    retrieveCollective(key) {
-        const entry = this.collectiveMemory.get(key);
-        if (entry) {
-            entry.accessCount++;
-            return entry.value;
-        }
-        return undefined;
-    }
-    /**
-     * Get collective memory statistics
-     */
-    getCollectiveStats() {
-        return {
-            totalEntries: this.collectiveMemory.size,
-            patterns: this.patterns.size,
-            decisions: this.decisions.size,
-            topPatterns: this.getEmergentPatterns().slice(0, 5),
-        };
-    }
-    // ============================================================================
-    // Private Helpers
-    // ============================================================================
-    generateTaskKey(taskData) {
-        if (!taskData)
-            return 'unknown';
-        return `${taskData.description || 'task'}-${JSON.stringify(taskData.metadata ?? {})}`.slice(0, 100);
-    }
-    recalculateConsensus(decision) {
-        const voteCounts = new Map();
-        let totalConfidence = 0;
-        for (const vote of decision.votes.values()) {
-            voteCounts.set(vote.vote, (voteCounts.get(vote.vote) ?? 0) + vote.confidence);
-            totalConfidence += vote.confidence;
-        }
-        let maxVotes = 0;
-        let consensusOption = '';
-        for (const [option, count] of voteCounts) {
-            if (count > maxVotes) {
-                maxVotes = count;
-                consensusOption = option;
-            }
-        }
-        const consensusConfidence = totalConfidence > 0 ? maxVotes / totalConfidence : 0;
-        if (consensusConfidence >= this.config.consensusThreshold) {
-            decision.consensus = consensusOption;
-            decision.consensusConfidence = consensusConfidence;
-        }
-        else {
-            decision.consensus = undefined;
-            decision.consensusConfidence = consensusConfidence;
-        }
-    }
-}
-/**
- * Factory function
- */
-export function createHiveMindPlugin(config) {
-    return new HiveMindPlugin(config);
-}
-//# sourceMappingURL=hive-mind-plugin.js.map

package/v3/@claude-flow/shared/dist/plugins/official/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Official Plugins - ADR-004 Implementation
- *
- * Exports all official @claude-flow plugins.
- *
- * @module v3/shared/plugins/official
- */
-export { HiveMindPlugin, createHiveMindPlugin, type HiveMindConfig, type CollectiveDecision, type EmergentPattern, } from './hive-mind-plugin.js';
-export { MaestroPlugin, createMaestroPlugin, type MaestroConfig, type WorkflowStep, type Workflow, type OrchestrationResult, } from './maestro-plugin.js';
-//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/shared/dist/plugins/official/index.js

@@ -1,10 +0,0 @@
-/**
- * Official Plugins - ADR-004 Implementation
- *
- * Exports all official @claude-flow plugins.
- *
- * @module v3/shared/plugins/official
- */
-export { HiveMindPlugin, createHiveMindPlugin, } from './hive-mind-plugin.js';
-export { MaestroPlugin, createMaestroPlugin, } from './maestro-plugin.js';
-//# sourceMappingURL=index.js.map

package/v3/@claude-flow/shared/dist/plugins/official/maestro-plugin.d.ts

@@ -1,121 +0,0 @@
-/**
- * Maestro Plugin - Official Plugin (ADR-004)
- *
- * Implements orchestration patterns for complex multi-agent workflows.
- * Part of the official plugin collection.
- *
- * @module v3/shared/plugins/official/maestro
- */
-import type { ClaudeFlowPlugin, PluginContext, PluginConfig } from '../types.js';
-/**
- * Maestro configuration
- */
-export interface MaestroConfig extends PluginConfig {
-    orchestrationMode: 'sequential' | 'parallel' | 'adaptive';
-    maxConcurrentWorkflows: number;
-    workflowTimeout: number;
-    autoRecovery: boolean;
-    checkpointInterval: number;
-}
-/**
- * Workflow step
- */
-export interface WorkflowStep {
-    id: string;
-    name: string;
-    type: string;
-    input: Record<string, unknown>;
-    dependencies: string[];
-    assignedAgent?: string;
-    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
-    output?: unknown;
-    error?: string;
-    startedAt?: Date;
-    completedAt?: Date;
-}
-/**
- * Workflow definition
- */
-export interface Workflow {
-    id: string;
-    name: string;
-    description: string;
-    steps: WorkflowStep[];
-    status: 'created' | 'running' | 'paused' | 'completed' | 'failed';
-    currentStep?: string;
-    progress: number;
-    createdAt: Date;
-    startedAt?: Date;
-    completedAt?: Date;
-    checkpoints: Map<string, unknown>;
-}
-/**
- * Orchestration result
- */
-export interface OrchestrationResult {
-    workflowId: string;
-    success: boolean;
-    stepsCompleted: number;
-    stepsTotal: number;
-    outputs: Record<string, unknown>;
-    errors: Array<{
-        stepId: string;
-        error: string;
-    }>;
-    duration: number;
-}
-/**
- * Maestro Plugin Implementation
- */
-export declare class MaestroPlugin implements ClaudeFlowPlugin {
-    readonly id = "maestro";
-    readonly name = "Maestro Workflow Orchestrator";
-    readonly version = "1.0.0";
-    readonly description = "Complex multi-agent workflow orchestration with adaptive strategies";
-    private context?;
-    private config;
-    private workflows;
-    private activeWorkflows;
-    constructor(config?: Partial<MaestroConfig>);
-    initialize(context: PluginContext): Promise<void>;
-    shutdown(): Promise<void>;
-    /**
-     * Create a new workflow
-     */
-    createWorkflow(name: string, description: string, steps: Array<Omit<WorkflowStep, 'id' | 'status'>>): Workflow;
-    /**
-     * Execute a workflow
-     */
-    executeWorkflow(workflowId: string): Promise<OrchestrationResult>;
-    /**
-     * Pause a workflow
-     */
-    pauseWorkflow(workflowId: string): boolean;
-    /**
-     * Resume a paused workflow
-     */
-    resumeWorkflow(workflowId: string): Promise<OrchestrationResult>;
-    /**
-     * Get workflow status
-     */
-    getWorkflow(workflowId: string): Workflow | undefined;
-    /**
-     * List all workflows
-     */
-    listWorkflows(): Workflow[];
-    private executeSequential;
-    private executeParallel;
-    private executeAdaptive;
-    private executeStep;
-    private buildExecutionLayers;
-    private resolveInputReferences;
-    private updateProgress;
-    private updateWorkflowProgress;
-    private handleWorkflowError;
-    private checkpointWorkflow;
-}
-/**
- * Factory function
- */
-export declare function createMaestroPlugin(config?: Partial<MaestroConfig>): MaestroPlugin;
-//# sourceMappingURL=maestro-plugin.d.ts.map