mcp-adr-analysis-server/dist/src/types/reflexion-framework.d.ts

MCP server for analyzing Architectural Decision Records and project architecture

/**
 * TypeScript interfaces for Reflexion Framework
 * Implements Actor-Evaluator-Self-Reflection pattern for continuous learning
 */
import { z } from 'zod';
/**
 * Base prompt object for reflexion framework
 */
export interface PromptObject {
    /** The main prompt text */
    prompt: string;
    /** Instructions for using the prompt */
    instructions: string;
    /** Additional context data */
    context: any;
}
export type MemoryType = 'episodic' | 'semantic' | 'procedural' | 'meta' | 'feedback';
export type EvaluationCriterion = 'task-success' | 'quality' | 'efficiency' | 'accuracy' | 'completeness' | 'relevance' | 'clarity' | 'innovation';
export type ReflectionDepth = 'basic' | 'detailed' | 'comprehensive';
export type LearningPhase = 'memory-retrieval' | 'task-execution' | 'performance-evaluation' | 'self-reflection' | 'memory-integration';
/**
 * Configuration for the Reflexion learning framework
 */
export interface ReflexionConfig {
    /** Whether memory system is enabled */
    memoryEnabled: boolean;
    /** Maximum memories per type */
    maxMemoryEntries: number;
    /** Depth of reflection analysis */
    reflectionDepth: ReflectionDepth;
    /** Criteria used for evaluating performance */
    evaluationCriteria: EvaluationCriterion[];
    /** How quickly to adapt from experiences (0-1) */
    learningRate: number;
    /** How long to keep memories (days) */
    memoryRetention: number;
    /** Enable external feedback integration */
    feedbackIntegration: boolean;
    /** Automatic memory cleanup */
    autoCleanup: boolean;
    /** Minimum relevance for memory retrieval (0-1) */
    relevanceThreshold: number;
    /** Minimum confidence for lesson application (0-1) */
    confidenceThreshold: number;
}
export declare const ReflexionConfigSchema: z.ZodObject<{
    memoryEnabled: z.ZodBoolean;
    maxMemoryEntries: z.ZodNumber;
    reflectionDepth: z.ZodEnum<{
        basic: "basic";
        detailed: "detailed";
        comprehensive: "comprehensive";
    }>;
    evaluationCriteria: z.ZodArray<z.ZodEnum<{
        relevance: "relevance";
        clarity: "clarity";
        efficiency: "efficiency";
        "task-success": "task-success";
        quality: "quality";
        accuracy: "accuracy";
        completeness: "completeness";
        innovation: "innovation";
    }>>;
    learningRate: z.ZodNumber;
    memoryRetention: z.ZodNumber;
    feedbackIntegration: z.ZodBoolean;
    autoCleanup: z.ZodBoolean;
    relevanceThreshold: z.ZodNumber;
    confidenceThreshold: z.ZodNumber;
}, z.core.$strip>;
export interface ToolReflexionConfig {
    toolName: string;
    taskTypes: string[];
    reflexionConfig: ReflexionConfig;
    customEvaluators?: CustomEvaluator[];
    memoryCategories?: string[];
    learningObjectives?: string[];
}
/**
 * Represents a single task execution attempt in the Reflexion framework
 */
export interface TaskAttempt {
    /** Unique identifier for this attempt */
    attemptId: string;
    /** Type of task being attempted */
    taskType: string;
    /** Context information for the task */
    context: any;
    /** Action taken during the attempt */
    action: string;
    /** Outcome of the task execution */
    outcome: TaskOutcome;
    /** Evaluation of the attempt's performance */
    evaluation: EvaluationResult;
    /** Self-reflection analysis */
    reflection: SelfReflection;
    /** Timestamp when attempt was made */
    timestamp: string;
    /** Additional metadata about the attempt */
    metadata: AttemptMetadata;
    /** IDs of memories used during execution */
    relatedMemories: string[];
    /** IDs of memories created from this attempt */
    generatedMemories: string[];
}
/**
 * Outcome of a task execution attempt
 */
export interface TaskOutcome {
    /** Whether the task was successful */
    success: boolean;
    /** Result data from the task execution */
    result: any;
    /** Errors encountered during execution */
    errors: string[];
    /** Warnings generated during execution */
    warnings: string[];
    /** Time taken to execute (milliseconds) */
    executionTime: number;
    /** Resources consumed during execution */
    resourcesUsed: ResourceUsage;
    /** Quality metrics for the outcome */
    qualityMetrics: QualityMetrics;
    /** Optional user feedback on the outcome */
    userFeedback?: UserFeedback;
}
export interface ResourceUsage {
    memoryAccessed: number;
    memoryCreated: number;
    processingTime: number;
    promptTokens: number;
    cacheHits: number;
    cacheMisses: number;
}
export interface QualityMetrics {
    accuracy: number;
    completeness: number;
    relevance: number;
    clarity: number;
    innovation: number;
    efficiency: number;
}
export interface AttemptMetadata {
    attemptNumber: number;
    previousAttempts: string[];
    improvementFromPrevious: number;
    strategiesUsed: string[];
    lessonsApplied: string[];
    challengesFaced: string[];
}
export interface EvaluationResult {
    overallScore: number;
    criteriaScores: Record<EvaluationCriterion, number>;
    feedback: EvaluationFeedback[];
    strengths: string[];
    weaknesses: string[];
    improvementAreas: string[];
    confidence: number;
    evaluationTime: number;
    evaluatorVersion: string;
    metadata: EvaluationMetadata;
}
export interface EvaluationFeedback {
    criterion: EvaluationCriterion;
    score: number;
    reasoning: string;
    suggestions: string[];
    examples?: string[];
    severity: 'low' | 'medium' | 'high' | 'critical';
}
export interface EvaluationMetadata {
    evaluatedAt: string;
    evaluationMethod: string;
    contextFactors: string[];
    biasChecks: BiasCheck[];
    reliability: number;
    comparativeAnalysis?: ComparativeAnalysis;
}
export interface BiasCheck {
    biasType: string;
    detected: boolean;
    severity: 'low' | 'medium' | 'high';
    mitigation: string;
}
export interface ComparativeAnalysis {
    comparedTo: string[];
    relativePerformance: number;
    improvementAreas: string[];
    regressionAreas: string[];
}
export interface CustomEvaluator {
    name: string;
    criterion: EvaluationCriterion;
    weight: number;
    evaluationPrompt: string;
    expectedOutputFormat: string;
    validationRules: ValidationRule[];
}
export interface ValidationRule {
    type: 'range' | 'format' | 'content' | 'logic';
    condition: string;
    errorMessage: string;
    severity: 'warning' | 'error';
}
export interface SelfReflection {
    reflectionId: string;
    reflectionText: string;
    lessonsLearned: LessonLearned[];
    actionableInsights: ActionableInsight[];
    futureStrategies: Strategy[];
    knowledgeGaps: KnowledgeGap[];
    confidenceLevel: number;
    applicability: string[];
    reflectionTime: number;
    metadata: ReflectionMetadata;
}
export interface LessonLearned {
    lesson: string;
    category: string;
    importance: 'low' | 'medium' | 'high' | 'critical';
    evidence: string[];
    applicableContexts: string[];
    confidence: number;
    generalizability: number;
}
export interface ActionableInsight {
    insight: string;
    action: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    timeframe: 'immediate' | 'short-term' | 'medium-term' | 'long-term';
    resources: string[];
    expectedImpact: number;
    riskLevel: 'low' | 'medium' | 'high';
}
export interface Strategy {
    strategy: string;
    description: string;
    applicableScenarios: string[];
    prerequisites: string[];
    expectedOutcomes: string[];
    riskFactors: string[];
    successMetrics: string[];
}
export interface KnowledgeGap {
    gap: string;
    category: string;
    impact: 'low' | 'medium' | 'high' | 'critical';
    learningPriority: number;
    suggestedResources: string[];
    estimatedLearningTime: string;
}
export interface ReflectionMetadata {
    reflectedAt: string;
    reflectionDepth: ReflectionDepth;
    triggerEvent: string;
    contextFactors: string[];
    emotionalState?: string;
    cognitiveLoad: number;
    reflectionQuality: number;
}
export interface ReflexionMemory {
    memoryId: string;
    memoryType: MemoryType;
    content: MemoryContent;
    relevanceScore: number;
    accessCount: number;
    lastAccessed: string;
    createdAt: string;
    expiresAt?: string;
    tags: string[];
    metadata: MemoryMetadata;
    relationships: MemoryRelationship[];
}
export interface MemoryContent {
    summary: string;
    details: string;
    context: any;
    lessons: string[];
    applicableScenarios: string[];
    relatedMemories: string[];
    evidence: string[];
    outcomes: string[];
    strategies: string[];
    warnings: string[];
}
export interface MemoryMetadata {
    source: string;
    quality: number;
    reliability: number;
    generalizability: number;
    updateCount: number;
    lastUpdated: string;
    category: string;
    subcategory?: string;
    importance: 'low' | 'medium' | 'high' | 'critical';
}
export interface MemoryRelationship {
    relatedMemoryId: string;
    relationshipType: 'similar' | 'contradicts' | 'builds-on' | 'prerequisite' | 'outcome';
    strength: number;
    description: string;
}
export interface MemoryQuery {
    taskType?: string;
    context?: any;
    keywords?: string[];
    memoryTypes?: MemoryType[];
    timeRange?: {
        start: string;
        end: string;
    };
    relevanceThreshold?: number;
    maxResults?: number;
    includeExpired?: boolean;
}
export interface MemorySearchResult {
    memories: ReflexionMemory[];
    totalFound: number;
    searchTime: number;
    relevanceScores: Record<string, number>;
    searchMetadata: SearchMetadata;
}
export interface SearchMetadata {
    searchQuery: MemoryQuery;
    searchStrategy: string;
    indexesUsed: string[];
    cacheHits: number;
    searchQuality: number;
}
export interface LearningProgress {
    taskType: string;
    totalAttempts: number;
    successRate: number;
    averageScore: number;
    improvementTrend: number;
    lastImprovement: string;
    keyLessons: string[];
    persistentIssues: string[];
    nextFocusAreas: string[];
    learningVelocity: number;
    plateauDetection: PlateauAnalysis;
    metadata: LearningMetadata;
}
export interface PlateauAnalysis {
    isOnPlateau: boolean;
    plateauDuration: number;
    plateauConfidence: number;
    suggestedInterventions: string[];
    alternativeApproaches: string[];
}
export interface LearningMetadata {
    trackingStarted: string;
    lastUpdated: string;
    dataQuality: number;
    sampleSize: number;
    confidenceInterval: number;
    statisticalSignificance: number;
    trendAnalysis: TrendAnalysis;
}
export interface TrendAnalysis {
    shortTermTrend: number;
    mediumTermTrend: number;
    longTermTrend: number;
    volatility: number;
    predictability: number;
}
export interface ReflexionResult {
    enhancedPrompt: PromptObject;
    taskAttempt: TaskAttempt;
    learningOutcome: LearningOutcome;
    memoryUpdates: MemoryUpdate[];
    performanceMetrics: ReflexionPerformanceMetrics;
    recommendations: string[];
}
export interface LearningOutcome {
    lessonsLearned: number;
    memoriesCreated: number;
    memoriesUpdated: number;
    improvementAchieved: number;
    knowledgeGapsIdentified: number;
    strategiesRefined: number;
    confidenceChange: number;
}
export interface MemoryUpdate {
    memoryId: string;
    updateType: 'create' | 'update' | 'strengthen' | 'weaken' | 'expire';
    changes: string[];
    reason: string;
    impact: number;
}
export interface ReflexionPerformanceMetrics {
    totalReflexionTime: number;
    memoryRetrievalTime: number;
    evaluationTime: number;
    reflectionTime: number;
    memoryIntegrationTime: number;
    memoriesAccessed: number;
    memoriesCreated: number;
    learningEfficiency: number;
    resourceUtilization: number;
}
export interface UserFeedback {
    rating: number;
    comments: string;
    categories: string[];
    helpfulness: number;
    accuracy: number;
    suggestions: string[];
    submittedAt: string;
    userId?: string;
}
export declare const TaskAttemptSchema: z.ZodObject<{
    attemptId: z.ZodString;
    taskType: z.ZodString;
    context: z.ZodAny;
    action: z.ZodString;
    outcome: z.ZodObject<{
        success: z.ZodBoolean;
        result: z.ZodAny;
        errors: z.ZodArray<z.ZodString>;
        warnings: z.ZodArray<z.ZodString>;
        executionTime: z.ZodNumber;
        resourcesUsed: z.ZodObject<{
            memoryAccessed: z.ZodNumber;
            memoryCreated: z.ZodNumber;
            processingTime: z.ZodNumber;
            promptTokens: z.ZodNumber;
            cacheHits: z.ZodNumber;
            cacheMisses: z.ZodNumber;
        }, z.core.$strip>;
        qualityMetrics: z.ZodObject<{
            accuracy: z.ZodNumber;
            completeness: z.ZodNumber;
            relevance: z.ZodNumber;
            clarity: z.ZodNumber;
            innovation: z.ZodNumber;
            efficiency: z.ZodNumber;
        }, z.core.$strip>;
    }, z.core.$strip>;
    evaluation: z.ZodObject<{
        overallScore: z.ZodNumber;
        criteriaScores: z.ZodRecord<z.ZodString, z.ZodNumber>;
        feedback: z.ZodArray<z.ZodAny>;
        strengths: z.ZodArray<z.ZodString>;
        weaknesses: z.ZodArray<z.ZodString>;
        improvementAreas: z.ZodArray<z.ZodString>;
        confidence: z.ZodNumber;
        evaluationTime: z.ZodNumber;
        evaluatorVersion: z.ZodString;
    }, z.core.$strip>;
    reflection: z.ZodObject<{
        reflectionId: z.ZodString;
        reflectionText: z.ZodString;
        lessonsLearned: z.ZodArray<z.ZodAny>;
        actionableInsights: z.ZodArray<z.ZodAny>;
        futureStrategies: z.ZodArray<z.ZodAny>;
        knowledgeGaps: z.ZodArray<z.ZodAny>;
        confidenceLevel: z.ZodNumber;
        applicability: z.ZodArray<z.ZodString>;
        reflectionTime: z.ZodNumber;
    }, z.core.$strip>;
    timestamp: z.ZodString;
    metadata: z.ZodAny;
    relatedMemories: z.ZodArray<z.ZodString>;
    generatedMemories: z.ZodArray<z.ZodString>;
}, z.core.$strip>;
//# sourceMappingURL=reflexion-framework.d.ts.map