claude-code-subagents-orchestrator/dist/core/prompt-generator.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 { TaskClassification, DelegationContext, WorkflowStep, ExecutionContext } from '../types/enhanced-core.js';
import { AgentSpecReader } from './filesystem.js';
export declare class PromptGenerationEngine {
    private taskClassifier;
    private agentSpecReader;
    private promptTemplates;
    private delegationPhrases;
    private recoveryTemplates;
    constructor(agentSpecReader: AgentSpecReader);
    generateDelegationPrompt(task: string, context: DelegationContext, options?: PromptGenerationOptions): Promise<DelegationPrompt>;
    generateWorkflowPrompts(workflow: WorkflowStep[], context: ExecutionContext, options?: WorkflowPromptOptions): Promise<WorkflowPromptSet>;
    generateRecoveryPrompt(originalTask: string, failureContext: FailureContext, options?: RecoveryPromptOptions): Promise<RecoveryPrompt>;
    parseAgentSpecification(agentId: string): Promise<ParsedAgentSpec>;
    private classifyTask;
    private getAgentSpecification;
    private selectPromptTemplate;
    private generateCorePrompt;
    private addDelegationEnforcement;
    private addValidationRequirements;
    private addArtifactPreservation;
    private generateValidationTokens;
    private initializePromptTemplates;
    private initializeDelegationPhrases;
    private initializeRecoveryTemplates;
    private formatFocusAreas;
    private formatCapabilities;
    private formatConstraints;
    private extractCapabilities;
    private extractFocusAreas;
    private extractConstraints;
    private extractTriggerPatterns;
    private extractDelegationHooks;
    private extractExamples;
    private extractStepDependencies;
    private hasImplicitDependency;
    private calculateExecutionOrder;
    private identifyParallelGroups;
    private canRunInParallel;
    private calculateWorkflowComplexity;
    private estimateWorkflowDuration;
    private identifyCriticalPath;
    private generateWorkflowStepPrompt;
    private analyzeFailurePatterns;
    private classifyFailureType;
    private identifyRootCause;
    private assessRecoverability;
    private generateSuggestedActions;
    private calculateAnalysisConfidence;
    private selectRecoveryStrategy;
    private selectAlternativeAgent;
    private getDefaultRecoveryTemplate;
    private generateRecoveryPromptFromTemplate;
    private addEnhancedDelegationEnforcement;
    private suggestAlternativeAgents;
    private generateFallbackOptions;
    private generateEnhancedConstraints;
    private generateEscalationAnalysis;
    private selectEscalatedAgent;
    private generateValidationRequirements;
}
interface DelegationPrompt {
    prompt: string;
    classification: TaskClassification;
    targetAgent: string;
    enforcementLevel: 'strict' | 'moderate' | 'advisory';
    validationTokens: ValidationTokens;
    metadata: {
        generatedAt: Date;
        templateUsed: string;
        delegationStrategy: string;
        confidence: number;
        bypassProtection: boolean;
    };
}
interface ValidationTokens {
    primary: string;
    secondary: string;
    session: string;
}
interface PromptGenerationOptions {
    templateName?: string;
    enforcementLevel?: 'strict' | 'moderate' | 'advisory';
    includeDependencies?: boolean;
    dependencies?: string[];
    complexity?: 'low' | 'medium' | 'high';
}
interface WorkflowPromptOptions extends PromptGenerationOptions {
    parallelExecution?: boolean;
    maxParallelSteps?: number;
    timeoutMs?: number;
}
interface WorkflowPromptSet {
    prompts: Map<string, DelegationPrompt>;
    dependencies: Map<string, string[]>;
    executionOrder: string[];
    parallelGroups: string[][];
    metadata: {
        totalSteps: number;
        complexityScore: number;
        estimatedDuration: number;
        criticalPath: string[];
    };
}
interface ParsedAgentSpec {
    id: string;
    capabilities: string[];
    focusAreas: string[];
    constraints: string[];
    triggerPatterns: string[];
    delegationHooks: Record<string, any>;
    systemPrompt: string;
    examples: any[];
    metadata: {
        version: string;
        complexity: string;
        category: string;
        lastUpdated: Date;
    };
}
interface FailureContext {
    error?: {
        code?: string;
        message?: string;
        details?: any;
    };
    retryCount: number;
    originalAgent?: string;
    originalTask?: string;
    executionTime?: number;
    lastAttemptTimestamp?: Date;
}
interface FailureAnalysis {
    failureType: string;
    rootCause: string;
    recoverability: 'high' | 'medium' | 'low';
    suggestedActions: string[];
    confidence: number;
}
interface RecoveryStrategy {
    type: 'retry_with_alternative' | 'retry_with_modifications' | 'escalation';
    confidence: number;
    requiresEscalation: boolean;
    alternativeAgent?: string;
    modifications: string[];
}
interface RecoveryPrompt {
    prompt: string;
    strategy: RecoveryStrategy;
    failureAnalysis: FailureAnalysis;
    alternativeAgents: string[];
    fallbackOptions: string[];
    metadata: {
        generatedAt: Date;
        originalFailureCount: number;
        recoveryConfidence: number;
        escalationRequired: boolean;
    };
}
interface RecoveryPromptOptions {
    maxRetries?: number;
    escalationThreshold?: number;
    originalAgent?: string;
    preferredRecoveryStrategy?: string;
}
export {};
//# sourceMappingURL=prompt-generator.d.ts.map