@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/feedback/pattern-promotion.ts

@@ -1,373 +0,0 @@
-/**
- * Pattern Promotion Manager
- * ADR-023: Quality Feedback Loop System
- *
- * Manages pattern lifecycle through promotion and demotion tiers.
- */
-
-import type {
-  PatternTier,
-  PromotionCriteria,
-  PatternPromotionEvent,
-  PatternDemotionEvent,
-  FeedbackConfig,
-} from './types.js';
-import { DEFAULT_PROMOTION_CRITERIA, DEFAULT_FEEDBACK_CONFIG } from './types.js';
-import type { RealQEReasoningBank } from '../learning/real-qe-reasoning-bank.js';
-import type { QEPattern } from '../learning/qe-patterns.js';
-
-// ============================================================================
-// Pattern Metrics Interface
-// ============================================================================
-
-/**
- * Pattern metrics for promotion evaluation
- */
-export interface PatternMetrics {
-  patternId: string;
-  successCount: number;
-  failureCount: number;
-  successRate: number;
-  qualityScore: number;
-  ageDays: number;
-  recentSuccessRate: number;
-  recentFailureCount: number;
-}
-
-// ============================================================================
-// Pattern Promotion Manager
-// ============================================================================
-
-/**
- * Manages pattern promotion and demotion
- */
-export class PatternPromotionManager {
-  private criteria: Record<PatternTier, PromotionCriteria>;
-  private promotionHistory: PatternPromotionEvent[] = [];
-  private demotionHistory: PatternDemotionEvent[] = [];
-  private reasoningBank: RealQEReasoningBank | null = null;
-  private config: FeedbackConfig;
-
-  constructor(config: Partial<FeedbackConfig> = {}) {
-    this.config = { ...DEFAULT_FEEDBACK_CONFIG, ...config };
-    this.criteria = { ...DEFAULT_PROMOTION_CRITERIA };
-  }
-
-  /**
-   * Connect to ReasoningBank
-   */
-  connectReasoningBank(bank: RealQEReasoningBank): void {
-    this.reasoningBank = bank;
-  }
-
-  /**
-   * Evaluate if a pattern should be promoted
-   */
-  evaluatePromotion(pattern: QEPattern, metrics: PatternMetrics): PatternPromotionEvent | null {
-    const currentTier = pattern.tier as PatternTier;
-    const nextTier = this.getNextTier(currentTier);
-
-    if (!nextTier) {
-      // Already at highest tier
-      return null;
-    }
-
-    const targetCriteria = this.criteria[nextTier];
-    if (this.meetsPromotionCriteria(metrics, targetCriteria)) {
-      const event: PatternPromotionEvent = {
-        patternId: pattern.id!,
-        fromTier: currentTier,
-        toTier: nextTier,
-        reason: this.generatePromotionReason(metrics, targetCriteria),
-        metrics: {
-          successCount: metrics.successCount,
-          successRate: metrics.successRate,
-          qualityScore: metrics.qualityScore,
-          ageDays: metrics.ageDays,
-        },
-        timestamp: new Date(),
-      };
-
-      this.promotionHistory.push(event);
-      return event;
-    }
-
-    return null;
-  }
-
-  /**
-   * Evaluate if a pattern should be demoted
-   */
-  evaluateDemotion(pattern: QEPattern, metrics: PatternMetrics): PatternDemotionEvent | null {
-    if (!this.config.autoDemote) return null;
-
-    const currentTier = pattern.tier as PatternTier;
-    if (currentTier === 'short-term') {
-      // Already at lowest tier
-      return null;
-    }
-
-    // Demotion criteria: recent poor performance
-    const shouldDemote =
-      metrics.recentSuccessRate < 0.4 ||
-      metrics.recentFailureCount >= 5 ||
-      metrics.qualityScore < 0.3;
-
-    if (shouldDemote) {
-      const previousTier = this.getPreviousTier(currentTier);
-      if (!previousTier) return null;
-
-      const event: PatternDemotionEvent = {
-        patternId: pattern.id!,
-        fromTier: currentTier,
-        toTier: previousTier,
-        reason: this.generateDemotionReason(metrics),
-        metrics: {
-          recentSuccessRate: metrics.recentSuccessRate,
-          recentQualityScore: metrics.qualityScore,
-          failureCount: metrics.recentFailureCount,
-        },
-        timestamp: new Date(),
-      };
-
-      this.demotionHistory.push(event);
-      return event;
-    }
-
-    return null;
-  }
-
-  /**
-   * Process promotion or demotion
-   */
-  async processPatternChange(pattern: QEPattern, metrics: PatternMetrics): Promise<{
-    action: 'promoted' | 'demoted' | 'unchanged';
-    event?: PatternPromotionEvent | PatternDemotionEvent;
-  }> {
-    // First check for demotion (takes priority)
-    const demotionEvent = this.evaluateDemotion(pattern, metrics);
-    if (demotionEvent) {
-      if (this.reasoningBank) {
-        await this.reasoningBank.demotePattern(pattern.id!);
-      }
-      return { action: 'demoted', event: demotionEvent };
-    }
-
-    // Then check for promotion
-    const promotionEvent = this.evaluatePromotion(pattern, metrics);
-    if (promotionEvent) {
-      if (this.reasoningBank) {
-        await this.reasoningBank.promotePattern(pattern.id!);
-      }
-      return { action: 'promoted', event: promotionEvent };
-    }
-
-    return { action: 'unchanged' };
-  }
-
-  /**
-   * Check if metrics meet promotion criteria
-   */
-  private meetsPromotionCriteria(metrics: PatternMetrics, criteria: PromotionCriteria): boolean {
-    return (
-      metrics.successCount >= criteria.minSuccessCount &&
-      metrics.successRate >= criteria.minSuccessRate &&
-      metrics.qualityScore >= criteria.minQualityScore &&
-      metrics.ageDays >= criteria.minAgeDays
-    );
-  }
-
-  /**
-   * Get next tier for promotion
-   */
-  private getNextTier(currentTier: PatternTier): PatternTier | null {
-    const tierOrder: PatternTier[] = ['short-term', 'working', 'long-term', 'permanent'];
-    const currentIndex = tierOrder.indexOf(currentTier);
-    if (currentIndex < tierOrder.length - 1) {
-      return tierOrder[currentIndex + 1];
-    }
-    return null;
-  }
-
-  /**
-   * Get previous tier for demotion
-   */
-  private getPreviousTier(currentTier: PatternTier): PatternTier | null {
-    const tierOrder: PatternTier[] = ['short-term', 'working', 'long-term', 'permanent'];
-    const currentIndex = tierOrder.indexOf(currentTier);
-    if (currentIndex > 0) {
-      return tierOrder[currentIndex - 1];
-    }
-    return null;
-  }
-
-  /**
-   * Generate promotion reason
-   */
-  private generatePromotionReason(metrics: PatternMetrics, criteria: PromotionCriteria): string {
-    const reasons: string[] = [];
-
-    if (metrics.successCount >= criteria.minSuccessCount) {
-      reasons.push(`${metrics.successCount} successful uses (>=${criteria.minSuccessCount})`);
-    }
-    if (metrics.successRate >= criteria.minSuccessRate) {
-      reasons.push(`${(metrics.successRate * 100).toFixed(0)}% success rate (>=${criteria.minSuccessRate * 100}%)`);
-    }
-    if (metrics.qualityScore >= criteria.minQualityScore) {
-      reasons.push(`${(metrics.qualityScore * 100).toFixed(0)}% quality score (>=${criteria.minQualityScore * 100}%)`);
-    }
-
-    return `Pattern promoted: ${reasons.join(', ')}`;
-  }
-
-  /**
-   * Generate demotion reason
-   */
-  private generateDemotionReason(metrics: PatternMetrics): string {
-    const reasons: string[] = [];
-
-    if (metrics.recentSuccessRate < 0.4) {
-      reasons.push(`low recent success rate (${(metrics.recentSuccessRate * 100).toFixed(0)}%)`);
-    }
-    if (metrics.recentFailureCount >= 5) {
-      reasons.push(`${metrics.recentFailureCount} recent failures`);
-    }
-    if (metrics.qualityScore < 0.3) {
-      reasons.push(`low quality score (${(metrics.qualityScore * 100).toFixed(0)}%)`);
-    }
-
-    return `Pattern demoted: ${reasons.join(', ')}`;
-  }
-
-  /**
-   * Update promotion criteria
-   */
-  updateCriteria(tier: PatternTier, criteria: Partial<PromotionCriteria>): void {
-    this.criteria[tier] = { ...this.criteria[tier], ...criteria };
-  }
-
-  /**
-   * Get promotion criteria for a tier
-   */
-  getCriteria(tier: PatternTier): PromotionCriteria {
-    return { ...this.criteria[tier] };
-  }
-
-  /**
-   * Get all criteria
-   */
-  getAllCriteria(): Record<PatternTier, PromotionCriteria> {
-    return { ...this.criteria };
-  }
-
-  /**
-   * Get promotion history
-   */
-  getPromotionHistory(limit = 100): PatternPromotionEvent[] {
-    return this.promotionHistory.slice(-limit);
-  }
-
-  /**
-   * Get demotion history
-   */
-  getDemotionHistory(limit = 100): PatternDemotionEvent[] {
-    return this.demotionHistory.slice(-limit);
-  }
-
-  /**
-   * Get statistics
-   */
-  getStats(): {
-    totalPromotions: number;
-    totalDemotions: number;
-    promotionsByTier: Record<PatternTier, number>;
-    demotionsByTier: Record<PatternTier, number>;
-    recentPromotions: number;
-    recentDemotions: number;
-  } {
-    // Count promotions by target tier
-    const promotionsByTier: Record<PatternTier, number> = {
-      'short-term': 0,
-      'working': 0,
-      'long-term': 0,
-      'permanent': 0,
-    };
-    for (const event of this.promotionHistory) {
-      promotionsByTier[event.toTier]++;
-    }
-
-    // Count demotions by target tier
-    const demotionsByTier: Record<PatternTier, number> = {
-      'short-term': 0,
-      'working': 0,
-      'long-term': 0,
-      'permanent': 0,
-    };
-    for (const event of this.demotionHistory) {
-      demotionsByTier[event.toTier]++;
-    }
-
-    // Recent (last 7 days)
-    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
-    const recentPromotions = this.promotionHistory.filter(
-      e => e.timestamp.getTime() > sevenDaysAgo
-    ).length;
-    const recentDemotions = this.demotionHistory.filter(
-      e => e.timestamp.getTime() > sevenDaysAgo
-    ).length;
-
-    return {
-      totalPromotions: this.promotionHistory.length,
-      totalDemotions: this.demotionHistory.length,
-      promotionsByTier,
-      demotionsByTier,
-      recentPromotions,
-      recentDemotions,
-    };
-  }
-
-  /**
-   * Export history for persistence
-   */
-  exportHistory(): {
-    promotions: PatternPromotionEvent[];
-    demotions: PatternDemotionEvent[];
-  } {
-    return {
-      promotions: [...this.promotionHistory],
-      demotions: [...this.demotionHistory],
-    };
-  }
-
-  /**
-   * Import history from persistence
-   */
-  importHistory(history: {
-    promotions?: PatternPromotionEvent[];
-    demotions?: PatternDemotionEvent[];
-  }): void {
-    if (history.promotions) {
-      this.promotionHistory.push(...history.promotions);
-    }
-    if (history.demotions) {
-      this.demotionHistory.push(...history.demotions);
-    }
-  }
-
-  /**
-   * Clear history
-   */
-  clearHistory(): void {
-    this.promotionHistory = [];
-    this.demotionHistory = [];
-  }
-}
-
-/**
- * Create a new pattern promotion manager
- */
-export function createPatternPromotionManager(
-  config?: Partial<FeedbackConfig>
-): PatternPromotionManager {
-  return new PatternPromotionManager(config);
-}

package/src/feedback/quality-score-calculator.ts

@@ -1,334 +0,0 @@
-/**
- * Quality Score Calculator
- * ADR-023: Quality Feedback Loop System
- *
- * Calculates comprehensive quality scores from multiple dimensions.
- */
-
-import type {
-  QualityScore,
-  QualityDimensions,
-  QualityWeights,
-  TestOutcome,
-  CoverageMetrics,
-} from './types.js';
-import { DEFAULT_QUALITY_WEIGHTS } from './types.js';
-
-// ============================================================================
-// Quality Score Calculator
-// ============================================================================
-
-/**
- * Calculates quality scores from test outcomes and metrics
- */
-export class QualityScoreCalculator {
-  private weights: QualityWeights;
-  private historicalScores: number[] = [];
-  private readonly maxHistory: number;
-
-  constructor(weights: Partial<QualityWeights> = {}, maxHistory = 100) {
-    this.weights = { ...DEFAULT_QUALITY_WEIGHTS, ...weights };
-    this.maxHistory = maxHistory;
-  }
-
-  /**
-   * Calculate quality score from a test outcome
-   */
-  calculateFromOutcome(outcome: TestOutcome): QualityScore {
-    const dimensions = this.calculateDimensions(outcome);
-    const overall = this.calculateOverall(dimensions);
-
-    // Track for trend analysis
-    this.trackScore(overall);
-
-    return {
-      overall,
-      dimensions,
-      weights: this.weights,
-      trend: this.calculateTrend(),
-      calculatedAt: new Date(),
-    };
-  }
-
-  /**
-   * Calculate quality dimensions from outcome
-   */
-  private calculateDimensions(outcome: TestOutcome): QualityDimensions {
-    return {
-      effectiveness: this.calculateEffectiveness(outcome),
-      coverage: this.calculateCoverageScore(outcome.coverage),
-      mutationKill: outcome.mutationScore ?? 0.5,
-      stability: this.calculateStability(outcome),
-      maintainability: outcome.maintainabilityScore,
-      performance: this.calculatePerformanceScore(outcome.executionTimeMs),
-    };
-  }
-
-  /**
-   * Calculate effectiveness (pass rate without flakiness)
-   */
-  private calculateEffectiveness(outcome: TestOutcome): number {
-    if (!outcome.passed) return 0;
-    if (outcome.flaky) return 0.3;
-    return 1.0;
-  }
-
-  /**
-   * Calculate coverage score (normalized 0-1)
-   */
-  private calculateCoverageScore(coverage: CoverageMetrics): number {
-    // Weighted average of coverage metrics
-    return (
-      coverage.lines * 0.4 +
-      coverage.branches * 0.35 +
-      coverage.functions * 0.25
-    ) / 100;
-  }
-
-  /**
-   * Calculate stability score (inverse of flakiness)
-   */
-  private calculateStability(outcome: TestOutcome): number {
-    if (outcome.flaky) return 0.2;
-    if (outcome.flakinessScore !== undefined) {
-      return 1 - outcome.flakinessScore;
-    }
-    return 1.0;
-  }
-
-  /**
-   * Calculate performance score based on execution time
-   */
-  private calculatePerformanceScore(executionTimeMs: number): number {
-    // Thresholds for performance scoring
-    const EXCELLENT = 100;   // <100ms = 1.0
-    const GOOD = 500;        // <500ms = 0.8
-    const ACCEPTABLE = 2000; // <2s = 0.6
-    const SLOW = 5000;       // <5s = 0.4
-    const VERY_SLOW = 10000; // <10s = 0.2
-
-    if (executionTimeMs < EXCELLENT) return 1.0;
-    if (executionTimeMs < GOOD) return 0.8;
-    if (executionTimeMs < ACCEPTABLE) return 0.6;
-    if (executionTimeMs < SLOW) return 0.4;
-    if (executionTimeMs < VERY_SLOW) return 0.2;
-    return 0.1;
-  }
-
-  /**
-   * Calculate overall quality score from dimensions
-   */
-  private calculateOverall(dimensions: QualityDimensions): number {
-    return (
-      this.weights.effectiveness * dimensions.effectiveness +
-      this.weights.coverage * dimensions.coverage +
-      this.weights.mutationKill * dimensions.mutationKill +
-      this.weights.stability * dimensions.stability +
-      this.weights.maintainability * dimensions.maintainability +
-      this.weights.performance * dimensions.performance
-    );
-  }
-
-  /**
-   * Track score for trend analysis
-   */
-  private trackScore(score: number): void {
-    this.historicalScores.push(score);
-    if (this.historicalScores.length > this.maxHistory) {
-      this.historicalScores = this.historicalScores.slice(-this.maxHistory);
-    }
-  }
-
-  /**
-   * Calculate quality trend
-   */
-  private calculateTrend(): 'improving' | 'stable' | 'declining' {
-    if (this.historicalScores.length < 10) return 'stable';
-
-    const recent = this.historicalScores.slice(-10);
-    const older = this.historicalScores.slice(-20, -10);
-
-    if (older.length === 0) return 'stable';
-
-    const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
-    const olderAvg = older.reduce((a, b) => a + b, 0) / older.length;
-
-    const diff = recentAvg - olderAvg;
-
-    if (diff > 0.05) return 'improving';
-    if (diff < -0.05) return 'declining';
-    return 'stable';
-  }
-
-  /**
-   * Calculate aggregate quality score from multiple outcomes
-   */
-  calculateAggregate(outcomes: TestOutcome[]): QualityScore {
-    if (outcomes.length === 0) {
-      return {
-        overall: 0,
-        dimensions: {
-          effectiveness: 0,
-          coverage: 0,
-          mutationKill: 0,
-          stability: 0,
-          maintainability: 0,
-          performance: 0,
-        },
-        weights: this.weights,
-        trend: 'stable',
-        calculatedAt: new Date(),
-      };
-    }
-
-    // Calculate average dimensions
-    const dimensionSums: QualityDimensions = {
-      effectiveness: 0,
-      coverage: 0,
-      mutationKill: 0,
-      stability: 0,
-      maintainability: 0,
-      performance: 0,
-    };
-
-    for (const outcome of outcomes) {
-      const dims = this.calculateDimensions(outcome);
-      dimensionSums.effectiveness += dims.effectiveness;
-      dimensionSums.coverage += dims.coverage;
-      dimensionSums.mutationKill += dims.mutationKill;
-      dimensionSums.stability += dims.stability;
-      dimensionSums.maintainability += dims.maintainability;
-      dimensionSums.performance += dims.performance;
-    }
-
-    const count = outcomes.length;
-    const avgDimensions: QualityDimensions = {
-      effectiveness: dimensionSums.effectiveness / count,
-      coverage: dimensionSums.coverage / count,
-      mutationKill: dimensionSums.mutationKill / count,
-      stability: dimensionSums.stability / count,
-      maintainability: dimensionSums.maintainability / count,
-      performance: dimensionSums.performance / count,
-    };
-
-    const overall = this.calculateOverall(avgDimensions);
-
-    return {
-      overall,
-      dimensions: avgDimensions,
-      weights: this.weights,
-      trend: this.calculateTrend(),
-      calculatedAt: new Date(),
-    };
-  }
-
-  /**
-   * Calculate delta between two quality scores
-   */
-  calculateDelta(before: QualityScore, after: QualityScore): {
-    overallDelta: number;
-    dimensionDeltas: Record<keyof QualityDimensions, number>;
-    improved: boolean;
-  } {
-    const dimensionDeltas: Record<keyof QualityDimensions, number> = {
-      effectiveness: after.dimensions.effectiveness - before.dimensions.effectiveness,
-      coverage: after.dimensions.coverage - before.dimensions.coverage,
-      mutationKill: after.dimensions.mutationKill - before.dimensions.mutationKill,
-      stability: after.dimensions.stability - before.dimensions.stability,
-      maintainability: after.dimensions.maintainability - before.dimensions.maintainability,
-      performance: after.dimensions.performance - before.dimensions.performance,
-    };
-
-    const overallDelta = after.overall - before.overall;
-
-    return {
-      overallDelta,
-      dimensionDeltas,
-      improved: overallDelta > 0,
-    };
-  }
-
-  /**
-   * Get recommendations based on quality score
-   */
-  getRecommendations(score: QualityScore): string[] {
-    const recommendations: string[] = [];
-    const dims = score.dimensions;
-
-    if (dims.effectiveness < 0.8) {
-      recommendations.push('Improve test pass rate - investigate failing tests');
-    }
-    if (dims.coverage < 0.7) {
-      recommendations.push('Increase code coverage - target uncovered paths');
-    }
-    if (dims.mutationKill < 0.6) {
-      recommendations.push('Strengthen assertions - tests may be too weak');
-    }
-    if (dims.stability < 0.9) {
-      recommendations.push('Address test flakiness - stabilize intermittent tests');
-    }
-    if (dims.maintainability < 0.7) {
-      recommendations.push('Improve test maintainability - reduce complexity');
-    }
-    if (dims.performance < 0.6) {
-      recommendations.push('Optimize test performance - reduce execution time');
-    }
-
-    if (recommendations.length === 0) {
-      recommendations.push('Quality is excellent - maintain current practices');
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * Update weights
-   */
-  updateWeights(newWeights: Partial<QualityWeights>): void {
-    this.weights = { ...this.weights, ...newWeights };
-  }
-
-  /**
-   * Get current weights
-   */
-  getWeights(): QualityWeights {
-    return { ...this.weights };
-  }
-
-  /**
-   * Get statistics
-   */
-  getStats(): {
-    scoresTracked: number;
-    currentTrend: 'improving' | 'stable' | 'declining';
-    avgRecentScore: number;
-  } {
-    const recent = this.historicalScores.slice(-10);
-    const avgRecentScore = recent.length > 0
-      ? recent.reduce((a, b) => a + b, 0) / recent.length
-      : 0;
-
-    return {
-      scoresTracked: this.historicalScores.length,
-      currentTrend: this.calculateTrend(),
-      avgRecentScore,
-    };
-  }
-
-  /**
-   * Clear history
-   */
-  clearHistory(): void {
-    this.historicalScores = [];
-  }
-}
-
-/**
- * Create a new quality score calculator
- */
-export function createQualityScoreCalculator(
-  weights?: Partial<QualityWeights>,
-  maxHistory?: number
-): QualityScoreCalculator {
-  return new QualityScoreCalculator(weights, maxHistory);
-}