csvlod-ai-mcp-server/dist/swarm.d.ts

CSVLOD-AI MCP Server v3.0 with Quantum Context Intelligence - Revolutionary Context Intelligence Engine and Multimodal Processor for sovereign AI development

/**
 * CSVLOD-AI Agent Swarm Coordination System
 *
 * This module implements sovereign multi-agent coordination capabilities,
 * enabling developers to orchestrate specialized AI agents while maintaining
 * complete control over their development process.
 *
 * Core Principles:
 * - Sovereignty: All agents operate under developer control
 * - Structure: CSVLOD context provides coordination framework
 * - Emergence: Complex behaviors emerge from simple coordination rules
 */
export interface AgentSpecialization {
    role: string;
    responsibilities: string[];
    context_focus: string[];
    priority: number;
}
export interface SwarmConfig {
    enabled: boolean;
    coordination_mode: 'hierarchical' | 'peer-to-peer' | 'hybrid';
    max_concurrent_agents: number;
    context_sync_mode: 'real-time' | 'batch' | 'manual';
    conflict_resolution: 'coordinator_decides' | 'consensus' | 'escalate';
}
export interface AgentTask {
    id: string;
    agent_type: string;
    description: string;
    context_requirements: string[];
    dependencies: string[];
    priority: number;
    status: 'pending' | 'in_progress' | 'completed' | 'failed';
    assigned_agent?: string;
    result?: any;
    created_at: Date;
    updated_at: Date;
}
export interface AgentManifest {
    version: string;
    name: string;
    description: string;
    swarm_config?: SwarmConfig;
    agent_specializations?: Record<string, AgentSpecialization>;
    capabilities?: any;
}
export declare class SwarmCoordinator {
    private manifest;
    private activeTasks;
    private agentWorkloads;
    private contextCache;
    constructor(manifestPath: string);
    private loadManifest;
    /**
     * Decomposes a high-level task into agent-specific subtasks
     * based on agent specializations and context requirements
     */
    decomposeTask(description: string, projectPath: string, requiredContext?: string[]): Promise<AgentTask[]>;
    /**
     * Analyzes task requirements and maps them to appropriate agent specializations
     */
    private analyzeTaskRequirements;
    /**
     * Prioritizes tasks based on dependencies and agent priority levels
     */
    private prioritizeTasks;
    /**
     * Assigns tasks to available agents based on workload and specialization
     */
    assignTask(taskId: string): Promise<string | null>;
    /**
     * Completes a task and updates swarm state
     */
    completeTask(taskId: string, result: any): Promise<void>;
    /**
     * Updates the shared context cache with task results
     */
    private updateContextCache;
    /**
     * Checks if any pending tasks can now be assigned after a dependency completes
     */
    private checkDependentTasks;
    /**
     * Generates a unique task ID
     */
    private generateTaskId;
    /**
     * Gets current swarm status and active tasks
     */
    getSwarmStatus(): {
        swarm_enabled: boolean;
        coordination_mode: "hierarchical" | "peer-to-peer" | "hybrid";
        active_agents: {
            [k: string]: number;
        };
        task_counts: {
            pending: number;
            in_progress: number;
            completed: number;
            failed: number;
        };
        total_tasks: number;
        context_cache_size: number;
    };
    /**
     * Gets detailed information about a specific task
     */
    getTaskDetails(taskId: string): AgentTask | null;
    /**
     * Gets all tasks for a specific agent type
     */
    getTasksByAgent(agentType: string): AgentTask[];
}
/**
 * Creates a new swarm coordinator instance
 */
export declare function createSwarmCoordinator(projectPath: string): Promise<SwarmCoordinator>;
export default SwarmCoordinator;
//# sourceMappingURL=swarm.d.ts.map