import type { ProjectContext } from './index.js';
export type AIToolType = 'context7' | 'exa' | 'sequential-thinking' | 'serena';
export type TriggerType = 'documentation_needed' | 'pattern_discovery' | 'complex_reasoning' | 'semantic_analysis' | 'tdd_phase' | 'performance_optimization' | 'error_resolution' | 'code_generation' | 'architecture_design';
export type TDDPhase = 'RED' | 'GREEN' | 'REFACTOR';
export type ToolPriority = 'critical' | 'high' | 'medium' | 'low';
export type ToolExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
export interface AIToolConfig {
    type: AIToolType;
    enabled: boolean;
    priority: ToolPriority;
    timeoutMs: number;
    retryAttempts: number;
    parallelExecution: boolean;
    triggers: TriggerType[];
    capabilities: ToolCapability[];
    constraints: ToolConstraint[];
}
export interface ToolCapability {
    name: string;
    description: string;
    inputTypes: string[];
    outputTypes: string[];
    complexity: 'low' | 'medium' | 'high';
    estimatedDurationMs: number;
}
export interface ToolConstraint {
    type: 'resource' | 'dependency' | 'conflict' | 'timing';
    description: string;
    value: string | number | boolean;
    severity: 'warning' | 'error';
}
export interface ToolOrchestrationRequest {
    id: string;
    trigger: TriggerType;
    context: ToolExecutionContext;
    requirements: ToolRequirement[];
    constraints: OrchestrationConstraint[];
    priority: ToolPriority;
    maxExecutionTime: number;
    tddPhase?: TDDPhase;
}
export interface ToolExecutionContext {
    projectContext: ProjectContext;
    userRequest: string;
    codebaseSnapshot: CodebaseSnapshot;
    sessionHistory: ToolExecutionHistory[];
    currentObjective: string;
    performanceMetrics: PerformanceMetrics;
}
export interface ToolRequirement {
    toolType: AIToolType;
    capability: string;
    inputData: Record<string, any>;
    expectedOutput: string;
    criticality: 'required' | 'preferred' | 'optional';
    fallbackOptions: string[];
}
export interface OrchestrationConstraint {
    type: 'sequential' | 'parallel' | 'conditional' | 'resource';
    description: string;
    affectedTools: AIToolType[];
    condition?: string;
    parameters: Record<string, any>;
}
export interface ToolExecutionPlan {
    id: string;
    request: ToolOrchestrationRequest;
    strategy: ExecutionStrategy;
    phases: ExecutionPhase[];
    estimatedDuration: number;
    resourceRequirements: ResourceRequirement[];
    riskAssessment: RiskAssessment;
    fallbackPlans: FallbackPlan[];
}
export interface ExecutionStrategy {
    name: string;
    type: 'sequential' | 'parallel' | 'hybrid' | 'adaptive';
    description: string;
    optimizationGoals: OptimizationGoal[];
    adaptationRules: AdaptationRule[];
}
export interface ExecutionPhase {
    id: string;
    name: string;
    description: string;
    toolExecutions: ToolExecution[];
    dependencies: string[];
    parallelizable: boolean;
    estimatedDuration: number;
    successCriteria: SuccessCriterion[];
}
export interface ToolExecution {
    id: string;
    toolType: AIToolType;
    capability: string;
    input: ToolInput;
    expectedOutput: ToolOutput;
    status: ToolExecutionStatus;
    startTime?: Date;
    endTime?: Date;
    duration?: number;
    result?: ToolExecutionResult;
    errors?: ToolExecutionError[];
}
export interface ToolInput {
    type: string;
    data: Record<string, any>;
    metadata: {
        source: string;
        timestamp: Date;
        priority: ToolPriority;
        format: string;
        validation: ValidationRule[];
    };
}
export interface ToolOutput {
    type: string;
    data: Record<string, any>;
    metadata: {
        toolType: AIToolType;
        capability: string;
        timestamp: Date;
        confidence: number;
        quality: QualityMetrics;
        format: string;
    };
}
export interface ToolExecutionResult {
    success: boolean;
    output?: ToolOutput;
    error?: ToolExecutionError;
    performance: PerformanceMetrics;
    quality: QualityMetrics;
    metadata: {
        executionId: string;
        toolType: AIToolType;
        duration: number;
        resourceUsage: ResourceUsage;
        cacheHit: boolean;
    };
}
export interface ToolCommunicationMessage {
    id: string;
    fromTool: AIToolType;
    toTool: AIToolType;
    messageType: 'data_share' | 'coordination' | 'conflict_resolution' | 'validation';
    content: Record<string, any>;
    priority: ToolPriority;
    timestamp: Date;
    requiresResponse: boolean;
    correlationId?: string;
}
export interface ToolCoordinationProtocol {
    name: string;
    description: string;
    participatingTools: AIToolType[];
    communicationPatterns: CommunicationPattern[];
    conflictResolutionRules: ConflictResolutionRule[];
    synchronizationPoints: SynchronizationPoint[];
}
export interface CommunicationPattern {
    name: string;
    type: 'request_response' | 'publish_subscribe' | 'pipeline' | 'scatter_gather';
    description: string;
    participants: AIToolType[];
    messageFlow: MessageFlowStep[];
}
export interface ConflictResolutionRule {
    id: string;
    name: string;
    description: string;
    conflictType: 'data_inconsistency' | 'resource_contention' | 'timing_conflict' | 'priority_conflict';
    resolutionStrategy: ResolutionStrategy;
    priority: number;
    conditions: string[];
}
export interface TDDPhaseConfig {
    phase: TDDPhase;
    requiredTools: AIToolType[];
    optionalTools: AIToolType[];
    triggers: TDDTrigger[];
    validationRules: TDDValidationRule[];
    transitionCriteria: TDDTransitionCriterion[];
}
export interface TDDTrigger {
    event: string;
    toolType: AIToolType;
    action: string;
    conditions: string[];
    priority: ToolPriority;
}
export interface TDDValidationRule {
    phase: TDDPhase;
    rule: string;
    description: string;
    validator: string;
    required: boolean;
}
export interface TDDTransitionCriterion {
    fromPhase: TDDPhase;
    toPhase: TDDPhase;
    condition: string;
    description: string;
    requiredValidations: string[];
}
export interface PerformanceMetrics {
    executionTime: number;
    memoryUsage: number;
    cpuUsage: number;
    networkIO: number;
    diskIO: number;
    cacheHitRate: number;
    throughput: number;
    latency: number;
}
export interface QualityMetrics {
    accuracy: number;
    completeness: number;
    consistency: number;
    relevance: number;
    confidence: number;
    freshness: number;
    usability: number;
    maintainability: number;
}
export interface ResourceUsage {
    memory: {
        peak: number;
        average: number;
        allocated: number;
    };
    cpu: {
        peak: number;
        average: number;
        cores: number;
    };
    network: {
        bytesIn: number;
        bytesOut: number;
        requests: number;
    };
    storage: {
        reads: number;
        writes: number;
        bytesRead: number;
        bytesWritten: number;
    };
}
export interface OptimizationGoal {
    name: string;
    type: 'performance' | 'quality' | 'cost' | 'user_satisfaction';
    target: number;
    weight: number;
    constraints: string[];
}
export interface AdaptationRule {
    id: string;
    name: string;
    condition: string;
    action: string;
    parameters: Record<string, any>;
    priority: number;
    enabled: boolean;
}
export interface SuccessCriterion {
    name: string;
    description: string;
    metric: string;
    threshold: number;
    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq';
    required: boolean;
}
export interface RiskAssessment {
    overallRisk: 'low' | 'medium' | 'high' | 'critical';
    risks: Risk[];
    mitigationStrategies: MitigationStrategy[];
    contingencyPlans: ContingencyPlan[];
}
export interface Risk {
    id: string;
    name: string;
    description: string;
    category: 'technical' | 'operational' | 'security' | 'performance';
    probability: number;
    impact: number;
    riskScore: number;
    affectedComponents: string[];
}
export interface MitigationStrategy {
    riskId: string;
    strategy: string;
    description: string;
    cost: number;
    effectiveness: number;
    implementationTime: number;
}
export interface FallbackPlan {
    id: string;
    name: string;
    description: string;
    triggerConditions: string[];
    alternativeStrategy: ExecutionStrategy;
    estimatedImpact: {
        performance: number;
        quality: number;
        cost: number;
    };
}
export interface ToolExecutionHistory {
    executionId: string;
    timestamp: Date;
    request: ToolOrchestrationRequest;
    plan: ToolExecutionPlan;
    results: ToolExecutionResult[];
    overallResult: OrchestrationResult;
    lessons: LessonLearned[];
}
export interface OrchestrationResult {
    success: boolean;
    completedPhases: number;
    totalPhases: number;
    overallQuality: QualityMetrics;
    overallPerformance: PerformanceMetrics;
    userSatisfaction: number;
    recommendations: string[];
    warnings: string[];
    errors: ToolExecutionError[];
}
export interface LessonLearned {
    category: 'performance' | 'quality' | 'strategy' | 'coordination';
    description: string;
    impact: 'positive' | 'negative' | 'neutral';
    confidence: number;
    applicability: string[];
    recommendation: string;
}
export interface CodebaseSnapshot {
    timestamp: Date;
    commitHash?: string;
    fileCount: number;
    linesOfCode: number;
    languages: string[];
    dependencies: string[];
    testCoverage: number;
    codeQuality: QualityMetrics;
}
export interface ValidationRule {
    name: string;
    type: 'format' | 'range' | 'pattern' | 'custom';
    rule: string;
    message: string;
    severity: 'error' | 'warning' | 'info';
}
export interface ResourceRequirement {
    type: 'memory' | 'cpu' | 'network' | 'storage';
    amount: number;
    unit: string;
    priority: ToolPriority;
    shared: boolean;
}
export interface ResolutionStrategy {
    id?: string;
    name: string;
    type: 'priority_based' | 'consensus' | 'majority_vote' | 'expert_override' | 'user_decision';
    description: string;
    parameters: Record<string, any>;
    strategy?: string;
    reasoning?: string;
    applicableContexts?: any;
    resolutionMethod?: any;
    conflictTypes?: string[];
    successRate?: number;
    implementation?: any;
}
export interface SynchronizationPoint {
    name: string;
    description: string;
    participants: AIToolType[];
    condition: string;
    timeout: number;
    failureAction: 'abort' | 'continue' | 'retry';
}
export interface MessageFlowStep {
    step: number;
    from: AIToolType;
    to: AIToolType;
    messageType: string;
    condition?: string;
    timeout?: number;
}
export interface ContingencyPlan {
    riskId: string;
    plan: string;
    description: string;
    triggerThreshold: number;
    actions: string[];
    estimatedRecoveryTime: number;
}
export interface ToolExecutionError {
    code: string;
    message: string;
    toolType: AIToolType;
    phase: string;
    timestamp: Date;
    severity: 'warning' | 'error' | 'critical';
    context: Record<string, any>;
    stackTrace?: string;
    resolution?: string;
}
export interface AIToolIntegrationPlaybook {
    configureTools(configs: AIToolConfig[]): Promise<void>;
    getToolConfiguration(toolType: AIToolType): AIToolConfig | null;
    orchestrateTools(request: ToolOrchestrationRequest): Promise<OrchestrationResult>;
    createExecutionPlan(request: ToolOrchestrationRequest): Promise<ToolExecutionPlan>;
    executePlan(plan: ToolExecutionPlan): Promise<OrchestrationResult>;
    configureTDDPhases(configs: TDDPhaseConfig[]): Promise<void>;
    triggerTDDPhase(phase: TDDPhase, context: ToolExecutionContext): Promise<OrchestrationResult>;
    registerCoordinationProtocol(protocol: ToolCoordinationProtocol): Promise<void>;
    sendToolMessage(message: ToolCommunicationMessage): Promise<void>;
    resolveConflict(conflictType: string, participants: AIToolType[]): Promise<ResolutionStrategy>;
    getPerformanceMetrics(): Promise<PerformanceMetrics>;
    getQualityMetrics(): Promise<QualityMetrics>;
    getExecutionHistory(limit?: number): Promise<ToolExecutionHistory[]>;
    analyzeLessonsLearned(): Promise<LessonLearned[]>;
    optimizeStrategies(): Promise<void>;
    validateConfiguration(): Promise<ValidationResult[]>;
    getSystemStatus(): Promise<SystemStatus>;
}
export interface ValidationResult {
    valid: boolean;
    component: string;
    issues: ValidationIssue[];
    recommendations: string[];
}
export interface ValidationIssue {
    severity: 'error' | 'warning' | 'info';
    message: string;
    component: string;
    resolution?: string;
}
export interface SystemStatus {
    overall: 'healthy' | 'degraded' | 'critical';
    tools: Record<AIToolType, ToolStatus>;
    performance: PerformanceMetrics;
    activeExecutions: number;
    queuedRequests: number;
    errors: ToolExecutionError[];
}
export interface ToolStatus {
    available: boolean;
    healthy: boolean;
    lastUsed: Date;
    performance: PerformanceMetrics;
    errors: ToolExecutionError[];
    capabilities: ToolCapability[];
}
//# sourceMappingURL=ai-tool-integration.d.ts.map