moflo 4.8.30 → 4.8.32

package/src/@claude-flow/shared/dist/plugin-registry.d.ts

@@ -1,183 +0,0 @@
-/**
- * V3 Plugin Registry
- * Domain-Driven Design - Plugin-Based Architecture (ADR-004)
- *
- * Central registry for tracking plugin state, metadata, and registrations
- */
-import type { ClaudeFlowPlugin, PluginInfo, PluginLifecycleState, PluginContext, AgentTypeDefinition, TaskTypeDefinition, MCPToolDefinition, CLICommandDefinition, MemoryBackendFactory } from './plugin-interface.js';
-/**
- * Plugin registry for managing plugin lifecycle and registrations
- */
-export declare class PluginRegistry {
-    private plugins;
-    private agentTypes;
-    private taskTypes;
-    private mcpTools;
-    private cliCommands;
-    private memoryBackends;
-    /**
-     * Register a plugin in the registry
-     */
-    registerPlugin(plugin: ClaudeFlowPlugin, initialState: PluginLifecycleState, context: PluginContext): void;
-    /**
-     * Unregister a plugin from the registry
-     */
-    unregisterPlugin(pluginName: string): boolean;
-    /**
-     * Get a plugin by name
-     */
-    getPlugin(pluginName: string): PluginInfo | undefined;
-    /**
-     * Get all registered plugins
-     */
-    getAllPlugins(): Map<string, PluginInfo>;
-    /**
-     * Get all plugin names
-     */
-    getPluginNames(): string[];
-    /**
-     * Check if a plugin is registered
-     */
-    hasPlugin(pluginName: string): boolean;
-    /**
-     * Get plugins by state
-     */
-    getPluginsByState(state: PluginLifecycleState): PluginInfo[];
-    /**
-     * Get plugin count
-     */
-    getPluginCount(): number;
-    /**
-     * Update plugin state
-     */
-    updatePluginState(pluginName: string, state: PluginLifecycleState, error?: Error): void;
-    /**
-     * Collect and update plugin metrics
-     */
-    collectPluginMetrics(pluginName: string): void;
-    /**
-     * Get plugin status summary
-     */
-    getStatusSummary(): PluginRegistryStatus;
-    /**
-     * Register agent types from a plugin
-     */
-    registerAgentTypes(pluginName: string): void;
-    /**
-     * Unregister agent types from a plugin
-     */
-    unregisterPluginAgentTypes(pluginName: string): void;
-    /**
-     * Get agent type definition
-     */
-    getAgentType(type: string): AgentTypeDefinition | undefined;
-    /**
-     * Get all agent types
-     */
-    getAllAgentTypes(): AgentTypeDefinition[];
-    /**
-     * Get agent types by plugin
-     */
-    getAgentTypesByPlugin(pluginName: string): AgentTypeDefinition[];
-    /**
-     * Register task types from a plugin
-     */
-    registerTaskTypes(pluginName: string): void;
-    /**
-     * Unregister task types from a plugin
-     */
-    unregisterPluginTaskTypes(pluginName: string): void;
-    /**
-     * Get task type definition
-     */
-    getTaskType(type: string): TaskTypeDefinition | undefined;
-    /**
-     * Get all task types
-     */
-    getAllTaskTypes(): TaskTypeDefinition[];
-    /**
-     * Get task types by plugin
-     */
-    getTaskTypesByPlugin(pluginName: string): TaskTypeDefinition[];
-    /**
-     * Register MCP tools from a plugin
-     */
-    registerMCPTools(pluginName: string): void;
-    /**
-     * Unregister MCP tools from a plugin
-     */
-    unregisterPluginMCPTools(pluginName: string): void;
-    /**
-     * Get MCP tool definition
-     */
-    getMCPTool(name: string): MCPToolDefinition | undefined;
-    /**
-     * Get all MCP tools
-     */
-    getAllMCPTools(): MCPToolDefinition[];
-    /**
-     * Get MCP tools by plugin
-     */
-    getMCPToolsByPlugin(pluginName: string): MCPToolDefinition[];
-    /**
-     * Register CLI commands from a plugin
-     */
-    registerCLICommands(pluginName: string): void;
-    /**
-     * Unregister CLI commands from a plugin
-     */
-    unregisterPluginCLICommands(pluginName: string): void;
-    /**
-     * Get CLI command definition
-     */
-    getCLICommand(name: string): CLICommandDefinition | undefined;
-    /**
-     * Get all CLI commands
-     */
-    getAllCLICommands(): CLICommandDefinition[];
-    /**
-     * Get CLI commands by plugin
-     */
-    getCLICommandsByPlugin(pluginName: string): CLICommandDefinition[];
-    /**
-     * Register memory backends from a plugin
-     */
-    registerMemoryBackends(pluginName: string): void;
-    /**
-     * Unregister memory backends from a plugin
-     */
-    unregisterPluginMemoryBackends(pluginName: string): void;
-    /**
-     * Get memory backend factory
-     */
-    getMemoryBackend(name: string): MemoryBackendFactory | undefined;
-    /**
-     * Get all memory backends
-     */
-    getAllMemoryBackends(): MemoryBackendFactory[];
-    /**
-     * Get memory backends by plugin
-     */
-    getMemoryBackendsByPlugin(pluginName: string): MemoryBackendFactory[];
-    /**
-     * Register all extension points from a plugin
-     */
-    registerAllFromPlugin(pluginName: string): void;
-    /**
-     * Clear all registrations (for testing)
-     */
-    clear(): void;
-}
-/**
- * Plugin registry status summary
- */
-export interface PluginRegistryStatus {
-    totalPlugins: number;
-    states: Record<PluginLifecycleState, number>;
-    agentTypesRegistered: number;
-    taskTypesRegistered: number;
-    mcpToolsRegistered: number;
-    cliCommandsRegistered: number;
-    memoryBackendsRegistered: number;
-}
-//# sourceMappingURL=plugin-registry.d.ts.map

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

@@ -1,10 +0,0 @@
-/**
- * Plugins System - ADR-004 Implementation
- *
- * Plugin architecture for extending Claude Flow functionality.
- *
- * @module v3/shared/plugins
- */
-export type { PluginConfig, PluginContext, PluginEvent, PluginEventHandler, ClaudeFlowPlugin, PluginMetadata, IPluginRegistry, IPluginLoader, } from './types.js';
-export { HiveMindPlugin, createHiveMindPlugin, type HiveMindConfig, type CollectiveDecision, type EmergentPattern, MaestroPlugin, createMaestroPlugin, type MaestroConfig, type WorkflowStep, type Workflow, type OrchestrationResult, } from './official/index.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/shared/dist/plugins/official/hive-mind-plugin.d.ts

@@ -1,106 +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 type { ClaudeFlowPlugin, PluginContext, PluginConfig } from '../types.js';
-/**
- * HiveMind configuration
- */
-export interface HiveMindConfig extends PluginConfig {
-    consensusThreshold: number;
-    collectiveMemoryEnabled: boolean;
-    emergentBehaviorEnabled: boolean;
-    maxVotingRounds: number;
-    decisionTimeout: number;
-}
-/**
- * Collective decision
- */
-export interface CollectiveDecision {
-    id: string;
-    question: string;
-    votes: Map<string, {
-        agentId: string;
-        vote: string;
-        confidence: number;
-    }>;
-    consensus?: string;
-    consensusConfidence: number;
-    timestamp: Date;
-}
-/**
- * Emergent pattern
- */
-export interface EmergentPattern {
-    id: string;
-    type: string;
-    description: string;
-    contributors: string[];
-    strength: number;
-    discoveredAt: Date;
-}
-/**
- * HiveMind Plugin Implementation
- */
-export declare class HiveMindPlugin implements ClaudeFlowPlugin {
-    readonly id = "hive-mind";
-    readonly name = "HiveMind Collective Intelligence";
-    readonly version = "1.0.0";
-    readonly description = "Collective intelligence with consensus mechanisms and emergent behavior";
-    private context?;
-    private config;
-    private decisions;
-    private patterns;
-    private collectiveMemory;
-    constructor(config?: Partial<HiveMindConfig>);
-    initialize(context: PluginContext): Promise<void>;
-    shutdown(): Promise<void>;
-    /**
-     * Request a collective decision from the swarm
-     */
-    requestDecision(question: string, options: string[]): Promise<CollectiveDecision>;
-    /**
-     * Submit a vote for a decision
-     */
-    submitVote(decisionId: string, agentId: string, vote: string, confidence: number): boolean;
-    /**
-     * Get decision result
-     */
-    getDecision(decisionId: string): CollectiveDecision | undefined;
-    /**
-     * Detect emergent patterns from agent behavior
-     */
-    private detectEmergentPatterns;
-    /**
-     * Get emergent patterns
-     */
-    getEmergentPatterns(): EmergentPattern[];
-    /**
-     * Store in collective memory
-     */
-    storeCollective(key: string, value: unknown): void;
-    /**
-     * Retrieve from collective memory
-     */
-    retrieveCollective(key: string): unknown;
-    /**
-     * Get collective memory statistics
-     */
-    getCollectiveStats(): {
-        totalEntries: number;
-        patterns: number;
-        decisions: number;
-        topPatterns: EmergentPattern[];
-    };
-    private generateTaskKey;
-    private recalculateConsensus;
-}
-/**
- * Factory function
- */
-export declare function createHiveMindPlugin(config?: Partial<HiveMindConfig>): HiveMindPlugin;
-//# sourceMappingURL=hive-mind-plugin.d.ts.map

package/src/@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/src/@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

package/src/@claude-flow/shared/dist/plugins/types.d.ts

@@ -1,93 +0,0 @@
-/**
- * Plugin Types - ADR-004 Implementation
- *
- * Type definitions for the plugin system.
- *
- * @module v3/shared/plugins/types
- */
-import type { HookRegistry } from '../hooks/index.js';
-/**
- * Plugin configuration base
- */
-export interface PluginConfig {
-    enabled: boolean;
-    [key: string]: unknown;
-}
-/**
- * Plugin context provided during initialization
- */
-export interface PluginContext {
-    hooks?: HookRegistry;
-    services?: Record<string, unknown>;
-    config?: Record<string, unknown>;
-}
-/**
- * Plugin lifecycle events
- */
-export type PluginEvent = 'initialized' | 'shutdown' | 'error';
-/**
- * Plugin event handler
- */
-export type PluginEventHandler = (event: PluginEvent, data?: unknown) => void;
-/**
- * Claude Flow Plugin Interface
- *
- * All plugins must implement this interface.
- */
-export interface ClaudeFlowPlugin {
-    /** Unique plugin identifier */
-    readonly id: string;
-    /** Human-readable name */
-    readonly name: string;
-    /** Plugin version */
-    readonly version: string;
-    /** Plugin description */
-    readonly description: string;
-    /** Dependencies on other plugins */
-    readonly dependencies?: string[];
-    /**
-     * Initialize the plugin
-     * @param context Plugin context with hooks and services
-     */
-    initialize(context: PluginContext): Promise<void>;
-    /**
-     * Shutdown the plugin
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Optional event handler
-     */
-    onEvent?: PluginEventHandler;
-}
-/**
- * Plugin metadata
- */
-export interface PluginMetadata {
-    id: string;
-    name: string;
-    version: string;
-    description: string;
-    author?: string;
-    license?: string;
-    homepage?: string;
-    dependencies?: string[];
-}
-/**
- * Plugin registry
- */
-export interface IPluginRegistry {
-    register(plugin: ClaudeFlowPlugin): void;
-    unregister(pluginId: string): void;
-    get(pluginId: string): ClaudeFlowPlugin | undefined;
-    getAll(): ClaudeFlowPlugin[];
-    isRegistered(pluginId: string): boolean;
-}
-/**
- * Plugin loader interface
- */
-export interface IPluginLoader {
-    loadFromPath(path: string): Promise<ClaudeFlowPlugin>;
-    loadFromPackage(packageName: string): Promise<ClaudeFlowPlugin>;
-    loadBuiltin(pluginId: string): Promise<ClaudeFlowPlugin>;
-}
-//# sourceMappingURL=types.d.ts.map

package/src/@claude-flow/shared/dist/resilience/bulkhead.d.ts

@@ -1,105 +0,0 @@
-/**
- * Bulkhead Pattern
- *
- * Isolates failures by limiting concurrent executions.
- *
- * @module v3/shared/resilience/bulkhead
- */
-import { EventEmitter } from 'events';
-/**
- * Bulkhead options
- */
-export interface BulkheadOptions {
-    /** Name for identification */
-    name: string;
-    /** Maximum concurrent executions */
-    maxConcurrent: number;
-    /** Maximum queue size */
-    maxQueue: number;
-    /** Timeout for queued items in ms */
-    queueTimeout: number;
-    /** Callback when rejected */
-    onRejected?: (reason: 'full' | 'timeout') => void;
-}
-/**
- * Bulkhead statistics
- */
-export interface BulkheadStats {
-    active: number;
-    queued: number;
-    maxConcurrent: number;
-    maxQueue: number;
-    completed: number;
-    rejected: number;
-    timedOut: number;
-}
-/**
- * Bulkhead
- *
- * Limits concurrent executions to prevent resource exhaustion.
- *
- * @example
- * const bulkhead = new Bulkhead({
- *   name: 'database',
- *   maxConcurrent: 10,
- *   maxQueue: 50,
- * });
- *
- * try {
- *   const result = await bulkhead.execute(() => dbQuery());
- * } catch (error) {
- *   if (error.message.includes('Bulkhead full')) {
- *     // Handle capacity exceeded
- *   }
- * }
- */
-export declare class Bulkhead extends EventEmitter {
-    private readonly options;
-    private active;
-    private readonly queue;
-    private completed;
-    private rejected;
-    private timedOut;
-    constructor(options: BulkheadOptions);
-    /**
-     * Execute a function within the bulkhead
-     */
-    execute<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Get current statistics
-     */
-    getStats(): BulkheadStats;
-    /**
-     * Check if there's capacity available
-     */
-    hasCapacity(): boolean;
-    /**
-     * Get available capacity (concurrent + queue)
-     */
-    availableCapacity(): number;
-    /**
-     * Reset statistics
-     */
-    resetStats(): void;
-    /**
-     * Run function immediately
-     */
-    private runNow;
-    /**
-     * Add function to queue
-     */
-    private addToQueue;
-    /**
-     * Process next item in queue
-     */
-    private processQueue;
-}
-/**
- * Create a semaphore for limiting concurrent access
- */
-export declare function createSemaphore(maxConcurrent: number): {
-    acquire: () => Promise<void>;
-    release: () => void;
-    available: () => number;
-};
-//# sourceMappingURL=bulkhead.d.ts.map