@codai/memorai-core/dist/ai/PredictiveMemoryLifecycleManager.d.ts

Simplified advanced memory engine - no tiers, just powerful semantic search with persistence

/**
 * Predictive Memory Lifecycle Manager
 * AI-powered system for predicting and managing memory lifecycles with advanced forecasting
 */
import { EventEmitter } from 'events';
import { MemoryMetadata } from '../types/index.js';
export interface MemoryLifecycleStage {
    stage: 'creation' | 'encoding' | 'consolidation' | 'retrieval' | 'modification' | 'decay' | 'archival' | 'deletion';
    timestamp: Date;
    probability: number;
    factors: LifecycleFactor[];
    duration: number;
    triggers: LifecycleTrigger[];
    metadata: Record<string, any>;
}
export interface LifecycleFactor {
    type: 'temporal' | 'usage' | 'importance' | 'context' | 'user_behavior' | 'system_load';
    name: string;
    value: number;
    weight: number;
    impact: 'positive' | 'negative' | 'neutral';
    confidence: number;
}
export interface LifecycleTrigger {
    id: string;
    type: 'time_based' | 'usage_based' | 'importance_based' | 'manual' | 'system_based';
    condition: string;
    threshold: number;
    action: LifecycleAction;
    priority: 'low' | 'medium' | 'high' | 'critical';
    enabled: boolean;
}
export interface LifecycleAction {
    type: 'promote' | 'demote' | 'archive' | 'delete' | 'refresh' | 'consolidate' | 'replicate';
    target: string;
    parameters: Record<string, any>;
    automation: boolean;
    rollback: boolean;
}
export interface MemoryLifecyclePrediction {
    memoryId: string;
    currentStage: MemoryLifecycleStage;
    nextStage: MemoryLifecycleStage;
    timeToNextStage: number;
    confidence: number;
    alternativeStages: MemoryLifecycleStage[];
    recommendations: LifecycleRecommendation[];
    risks: LifecycleRisk[];
    opportunities: LifecycleOpportunity[];
}
export interface LifecycleRecommendation {
    id: string;
    type: 'optimization' | 'preservation' | 'consolidation' | 'archival' | 'deletion';
    description: string;
    rationale: string;
    expectedBenefit: string;
    implementation: {
        difficulty: 'easy' | 'medium' | 'hard';
        resources: string[];
        timeline: string;
        cost: 'low' | 'medium' | 'high';
    };
    priority: number;
}
export interface LifecycleRisk {
    id: string;
    type: 'data_loss' | 'performance_degradation' | 'storage_overflow' | 'compliance_violation';
    description: string;
    probability: number;
    impact: number;
    severity: 'low' | 'medium' | 'high' | 'critical';
    mitigation: string[];
    timeline: string;
}
export interface LifecycleOpportunity {
    id: string;
    type: 'optimization' | 'automation' | 'insight_generation' | 'cost_reduction';
    description: string;
    potential: number;
    effort: number;
    timeline: string;
    expectedROI: number;
}
export interface LifecycleOptimization {
    memoryId: string;
    currentPerformance: {
        accessTime: number;
        storageEfficiency: number;
        retrievalAccuracy: number;
        maintenanceCost: number;
    };
    optimizedPerformance: {
        accessTime: number;
        storageEfficiency: number;
        retrievalAccuracy: number;
        maintenanceCost: number;
    };
    improvement: {
        accessTimeReduction: number;
        storageEfficiencyGain: number;
        retrievalAccuracyGain: number;
        maintenanceCostReduction: number;
    };
    optimizations: OptimizationAction[];
}
export interface OptimizationAction {
    type: 'compression' | 'indexing' | 'caching' | 'replication' | 'migration' | 'pruning';
    description: string;
    impact: number;
    effort: number;
    automation: boolean;
    prerequisites: string[];
}
export interface LifecycleAnalytics {
    totalMemories: number;
    stageDistribution: Record<string, number>;
    averageLifecycleLength: number;
    predictiveAccuracy: number;
    optimizationSuccess: number;
    costSavings: {
        storage: number;
        compute: number;
        bandwidth: number;
        maintenance: number;
    };
    performanceGains: {
        averageAccessTime: number;
        retrievalAccuracy: number;
        storageEfficiency: number;
    };
    trends: {
        creationRate: number;
        deletionRate: number;
        archivalRate: number;
        averageImportance: number;
    };
}
export declare class PredictiveMemoryLifecycleManager extends EventEmitter {
    private lifecyclePredictions;
    private lifecycleOptimizations;
    private lifecycleTriggers;
    private analytics;
    private predictionUpdateInterval;
    private optimizationInterval;
    private analyticsInterval;
    constructor();
    /**
     * Predict memory lifecycle for a specific memory
     */
    predictMemoryLifecycle(memory: MemoryMetadata): Promise<MemoryLifecyclePrediction>;
    /**
     * Optimize memory lifecycle based on predictions
     */
    optimizeMemoryLifecycle(memoryId: string): Promise<LifecycleOptimization>;
    /**
     * Execute lifecycle actions based on triggers
     */
    executeLifecycleActions(memoryId: string, actions: LifecycleAction[]): Promise<{
        success: boolean;
        results: any[];
        errors: string[];
    }>;
    /**
     * Get comprehensive lifecycle analytics
     */
    getLifecycleAnalytics(): LifecycleAnalytics;
    /**
     * Create custom lifecycle trigger
     */
    createLifecycleTrigger(trigger: Omit<LifecycleTrigger, 'id'>): LifecycleTrigger;
    /**
     * Batch process lifecycle predictions for multiple memories
     */
    batchPredictLifecycles(memories: MemoryMetadata[]): Promise<MemoryLifecyclePrediction[]>;
    private analyzeCurrentStage;
    private predictNextStage;
    private calculateTimeToNextStage;
    private generateAlternativeStages;
    private generateLifecycleRecommendations;
    private identifyLifecycleRisks;
    private findLifecycleOpportunities;
    private calculatePredictionConfidence;
    private getStageTransitions;
    private calculateTransitionProbabilities;
    private getTypicalStageDuration;
    private analyzeLifecycleFactors;
    private getApplicableTriggers;
    private analyzeCurrentPerformance;
    private generateOptimizationActions;
    private simulateOptimizedPerformance;
    private executeAction;
    private initializeAnalytics;
    private initializeDefaultTriggers;
    private startLifecycleMonitoring;
    private updateAnalytics;
    /**
     * Cleanup on shutdown
     */
    shutdown(): void;
}
//# sourceMappingURL=PredictiveMemoryLifecycleManager.d.ts.map