mcp-adr-analysis-server/dist/src/utils/dynamic-deployment-intelligence.d.ts

MCP server for analyzing Architectural Decision Records and project architecture

/**
 * Dynamic Deployment Intelligence System
 *
 * Instead of static registry, this uses:
 * 1. AI + ResearchOrchestrator to query LIVE documentation
 * 2. Environment detection to see what's actually available
 * 3. Memory system to learn from successful deployments
 * 4. Fallback to basic templates when needed
 *
 * This stays current as software updates daily and best practices evolve.
 */
export interface DynamicDeploymentPlan {
    detectedPlatforms: string[];
    recommendedPlatform: string;
    confidence: number;
    requiredFiles: DeploymentFileRequirement[];
    environmentVariables: EnvironmentVariable[];
    deploymentSteps: DeploymentStep[];
    validationChecks: ValidationCheck[];
    architectureDiagram: string;
    risks: DeploymentRisk[];
    estimatedDuration: string;
    prerequisites: string[];
    source: 'ai-research' | 'memory-pattern' | 'fallback-template';
    researchSources: string[];
    timestamp: string;
}
export interface DeploymentFileRequirement {
    path: string;
    purpose: string;
    required: boolean;
    isSecret: boolean;
    canAutoGenerate: boolean;
    templateContent?: string;
    validationCommand?: string;
    currentBestPractice: string;
    lastUpdated: string;
}
export interface EnvironmentVariable {
    name: string;
    purpose: string;
    required: boolean;
    isSecret: boolean;
    defaultValue?: string;
    validationPattern?: string;
}
export interface DeploymentStep {
    order: number;
    title: string;
    command: string;
    description: string;
    expectedOutput: string;
    troubleshooting: string[];
    estimatedTime: string;
}
export interface ValidationCheck {
    name: string;
    command: string;
    expectedResult: string;
    severity: 'critical' | 'error' | 'warning' | 'info';
}
export interface DeploymentRisk {
    risk: string;
    severity: 'high' | 'medium' | 'low';
    mitigation: string;
    likelihood: string;
}
export declare class DynamicDeploymentIntelligence {
    private research;
    private memory;
    private logger;
    private projectPath;
    private adrDirectory;
    constructor(projectPath: string, adrDirectory: string);
    /**
     * Generate a comprehensive, AI-powered deployment plan
     * Uses live research + learned patterns + environment detection
     */
    generateDeploymentPlan(): Promise<DynamicDeploymentPlan>;
    /**
     * Detect which deployment platforms are available in the current environment
     */
    private detectAvailableDeploymentPlatforms;
    /**
     * Analyze ADRs to understand deployment context and requirements
     */
    private analyzeAdrDeploymentContext;
    /**
     * Query memory system for learned deployment patterns
     */
    private queryLearnedDeploymentPatterns;
    /**
     * Research current best practices from live documentation
     */
    private researchCurrentDeploymentBestPractices;
    /**
     * Generate AI-powered deployment plan by synthesizing all inputs
     */
    private generateAIPoweredDeploymentPlan;
    /**
     * Store successful deployment pattern in memory for learning
     */
    private storeDeploymentPattern;
    /**
     * Enhance learned pattern with latest information
     */
    private enhanceLearnedPattern;
    /**
     * Generate fallback plan using static templates when AI fails
     */
    private generateFallbackPlan;
    /**
     * Update a deployment plan with post-execution learnings
     */
    updatePlanWithLearnings(plan: DynamicDeploymentPlan, executionResult: any, _learnings: any[]): Promise<DynamicDeploymentPlan>;
}
//# sourceMappingURL=dynamic-deployment-intelligence.d.ts.map