claude-code-subagents-orchestrator/dist/core/enhanced-agent-spec-manager.d.ts

Claude Code Sub-agents Orchestrator - A powerful MCP server for orchestrating multiple AI sub-agents for complex task execution in Claude Code

import { EventEmitter } from 'events';
import { EnhancedAgentSpec } from '../types/filesystem.js';
import { EnhancedFileSystemUtilities } from './enhanced-filesystem-utilities.js';
export declare class EnhancedAgentSpecManager extends EventEmitter {
    private agentsDir;
    private fileUtils;
    private agentSpecs;
    private capabilityMatrix;
    private domainExperts;
    private complexityMappings;
    private lastScanTime;
    private scanInProgress;
    constructor(agentsDir: string, fileUtils: EnhancedFileSystemUtilities);
    initialize(): Promise<void>;
    cleanup(): Promise<void>;
    getAllAgentSpecs(): EnhancedAgentSpec[];
    getAgentSpec(agentName: string): EnhancedAgentSpec | undefined;
    getCapabilityMatrix(): Record<string, string[]>;
    findAgentsByCapabilities(requiredCapabilities: string[]): AgentMatchResult[];
    findAgentsByDomain(domain: string): AgentMatchResult[];
    findAgentsByComplexity(complexity: 'low' | 'medium' | 'high'): EnhancedAgentSpec[];
    getBestAgentForTask(taskDescription: string, constraints?: TaskConstraints): AgentRecommendation | null;
    generateUtilizationReport(): AgentUtilizationReport;
    validateAgentSpecs(): ValidationReport;
    rescanAgentSpecs(): Promise<void>;
    getScanStats(): {
        lastScanTime: Date | null;
        scanInProgress: boolean;
        agentCount: number;
        capabilityCount: number;
        domainCount: number;
        averageCapabilitiesPerAgent: number;
    };
    private scanAgentSpecs;
    private parseAgentSpecFile;
    private parseMarkdownContent;
    private extractMarkdownSections;
    private buildCapabilities;
    private buildCapabilityMatrix;
    private setupFileWatching;
    private debounceRescan;
    private extractValue;
    private extractList;
    private extractListItems;
    private extractTriggers;
    private mapComplexity;
    private calculateCapabilityMatch;
    private calculateDomainRelevance;
    private calculateConfidence;
    private generateMatchReasoning;
    private analyzeTaskRequirements;
    private inferTaskComplexity;
    private estimateTaskEffort;
    private inferTaskPriority;
    private applyConstraints;
    private removeDuplicateMatches;
    private calculateAverageResponseTime;
    private calculateAverageSuccessRate;
    private calculateAverageErrorRate;
    private calculateCapabilityDistribution;
    private calculateDomainCoverage;
    private generateOptimizationRecommendations;
    private validateSingleAgentSpec;
    private calculateSpecCompleteness;
    private calculateOverallHealth;
    private identifySystemWideIssues;
    private generateValidationRecommendations;
}
interface AgentMatchResult {
    agent: EnhancedAgentSpec;
    matchScore: number;
    matchedCapabilities: string[];
    missingCapabilities: string[];
    confidence: number;
    reasoning: string[];
}
interface TaskAnalysis {
    capabilities: string[];
    domains: string[];
    complexity: 'low' | 'medium' | 'high';
    estimatedEffort: number;
    priority: 'low' | 'medium' | 'high' | 'critical';
}
interface TaskConstraints {
    maxComplexity?: 'low' | 'medium' | 'high';
    requiredHealth?: 'healthy' | 'degraded' | 'unavailable' | 'any';
    minConfidence?: number;
}
interface AgentRecommendation {
    agent: EnhancedAgentSpec;
    confidence: number;
    matchScore: number;
    reasoning: string[];
    taskAnalysis: TaskAnalysis;
    alternatives: AgentMatchResult[];
}
interface AgentUtilizationReport {
    totalAgents: number;
    healthStats: Record<string, number>;
    performanceStats: {
        averageResponseTime: number;
        averageSuccessRate: number;
        averageErrorRate: number;
    };
    capabilityDistribution: Record<string, number>;
    domainCoverage: Record<string, number>;
    lastUpdated: Date;
    recommendations: string[];
}
interface AgentValidationResult {
    agentName: string;
    isValid: boolean;
    errors: string[];
    warnings: string[];
    completeness: number;
}
interface ValidationReport {
    results: AgentValidationResult[];
    overallHealth: 'excellent' | 'good' | 'fair' | 'poor';
    issues: string[];
    recommendations: string[];
    timestamp: Date;
}
export {};
//# sourceMappingURL=enhanced-agent-spec-manager.d.ts.map