@iservu-inc/adf-cli 0.9.1 → 0.11.0

package/lib/learning/decay-manager.js

@@ -0,0 +1,336 @@
+const storage = require('./storage');
+const {
+  applyDecayToStoredPatterns,
+  renewStoredPattern,
+  getDefaultDecayConfig
+} = require('./pattern-detector');
+
+/**
+ * Decay Manager - Orchestrates pattern decay operations
+ *
+ * Responsibilities:
+ * - Apply decay when loading patterns
+ * - Handle pattern renewal on skip events
+ * - Clean up stale patterns
+ * - Track decay history
+ */
+
+class DecayManager {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.decayConfig = null;
+    this.renewalTracking = {};  // Track renewals per day per pattern
+  }
+
+  /**
+   * Initialize decay manager with configuration
+   */
+  async initialize() {
+    this.decayConfig = await storage.getDecayConfig(this.projectPath);
+  }
+
+  /**
+   * Load patterns with decay applied
+   * @returns {Promise<Object>} Patterns with decay applied
+   */
+  async loadPatternsWithDecay() {
+    // Ensure config is loaded
+    if (!this.decayConfig) {
+      await this.initialize();
+    }
+
+    // Skip if decay disabled
+    if (!this.decayConfig.enabled) {
+      return await storage.getPatterns(this.projectPath);
+    }
+
+    // Load stored patterns
+    const storedPatterns = await storage.getPatterns(this.projectPath);
+
+    if (!storedPatterns || !storedPatterns.patterns || storedPatterns.patterns.length === 0) {
+      return storedPatterns;
+    }
+
+    // Apply decay to all patterns
+    const decayedPatterns = applyDecayToStoredPatterns(
+      storedPatterns.patterns,
+      this.decayConfig
+    );
+
+    // Separate active and stale patterns
+    const { activePatterns, removedPatterns } = this.cleanupStalePatterns(decayedPatterns);
+
+    // Save updated patterns
+    await storage.savePatterns(this.projectPath, {
+      ...storedPatterns,
+      patterns: activePatterns,
+      lastDecayCheck: new Date().toISOString()
+    });
+
+    // Log removed patterns if any
+    if (removedPatterns.length > 0) {
+      console.log(`[Decay] Removed ${removedPatterns.length} stale patterns`);
+
+      // Save removed patterns to history
+      await this.saveRemovedPatternsHistory(removedPatterns);
+    }
+
+    return {
+      ...storedPatterns,
+      patterns: activePatterns
+    };
+  }
+
+  /**
+   * Check if skip event matches any pattern and renew if needed
+   * @param {Object} skipEvent - Skip event from skip-tracker
+   * @returns {Promise<Array>} Renewed pattern IDs
+   */
+  async checkForPatternRenewal(skipEvent) {
+    // Ensure config is loaded
+    if (!this.decayConfig) {
+      await this.initialize();
+    }
+
+    // Skip if decay disabled
+    if (!this.decayConfig.enabled) {
+      return [];
+    }
+
+    // Load current patterns
+    const storedPatterns = await storage.getPatterns(this.projectPath);
+
+    if (!storedPatterns || !storedPatterns.patterns || storedPatterns.patterns.length === 0) {
+      return [];
+    }
+
+    const renewedPatternIds = [];
+    const today = new Date().toISOString().split('T')[0];
+
+    // Check each pattern for match
+    for (let i = 0; i < storedPatterns.patterns.length; i++) {
+      const pattern = storedPatterns.patterns[i];
+
+      // Check if skip event matches this pattern
+      if (this.skipMatchesPattern(skipEvent, pattern)) {
+        // Check renewal limit (max renewals per day)
+        const renewalKey = `${pattern.id}_${today}`;
+        const renewalsToday = this.renewalTracking[renewalKey] || 0;
+
+        if (renewalsToday < this.decayConfig.maxRenewalsPerDay) {
+          // Renew pattern
+          const renewedPattern = renewStoredPattern(pattern, this.decayConfig);
+          storedPatterns.patterns[i] = renewedPattern;
+          renewedPatternIds.push(pattern.id);
+
+          // Track renewal
+          this.renewalTracking[renewalKey] = renewalsToday + 1;
+        }
+      }
+    }
+
+    // Save updated patterns if any were renewed
+    if (renewedPatternIds.length > 0) {
+      await storage.savePatterns(this.projectPath, storedPatterns);
+      console.log(`[Decay] Renewed ${renewedPatternIds.length} patterns`);
+    }
+
+    return renewedPatternIds;
+  }
+
+  /**
+   * Check if skip event matches a pattern
+   * @param {Object} skipEvent - Skip event
+   * @param {Object} pattern - Pattern to match
+   * @returns {boolean} True if matches
+   */
+  skipMatchesPattern(skipEvent, pattern) {
+    switch (pattern.type) {
+      case 'consistent_skip':
+        return skipEvent.questionId === pattern.questionId;
+
+      case 'category_skip':
+        return skipEvent.category === pattern.category;
+
+      case 'framework_skip':
+        return skipEvent.framework === pattern.framework;
+
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Clean up stale patterns
+   * @param {Array} patterns - Patterns to check
+   * @returns {Object} { activePatterns, removedPatterns }
+   */
+  cleanupStalePatterns(patterns) {
+    // Use default config if not initialized
+    const config = this.decayConfig || {
+      removeBelow: 40,
+      maxInactiveMonths: 6
+    };
+
+    const activePatterns = [];
+    const removedPatterns = [];
+    const now = new Date();
+
+    for (const pattern of patterns) {
+      // Check confidence threshold
+      if (pattern.confidence < config.removeBelow) {
+        removedPatterns.push({
+          ...pattern,
+          status: 'removed',
+          removedAt: now.toISOString(),
+          removalReason: 'confidence_too_low'
+        });
+        continue;
+      }
+
+      // Check inactivity threshold
+      const lastSeen = new Date(pattern.lastSeen);
+      const monthsInactive = (now - lastSeen) / (1000 * 60 * 60 * 24 * 30);
+
+      if (monthsInactive >= config.maxInactiveMonths) {
+        removedPatterns.push({
+          ...pattern,
+          status: 'removed',
+          removedAt: now.toISOString(),
+          removalReason: 'inactive_too_long'
+        });
+        continue;
+      }
+
+      // Pattern is still active
+      activePatterns.push(pattern);
+    }
+
+    return { activePatterns, removedPatterns };
+  }
+
+  /**
+   * Save removed patterns to history
+   * @param {Array} removedPatterns - Patterns that were removed
+   */
+  async saveRemovedPatternsHistory(removedPatterns) {
+    try {
+      const historyEntry = {
+        timestamp: new Date().toISOString(),
+        removedCount: removedPatterns.length,
+        patterns: removedPatterns
+      };
+
+      await storage.appendToLearningHistory(
+        this.projectPath,
+        'removed-patterns.json',
+        historyEntry,
+        'removals'
+      );
+    } catch (error) {
+      console.warn(`Warning: Could not save removed patterns history: ${error.message}`);
+    }
+  }
+
+  /**
+   * Manually trigger decay calculation
+   * @returns {Promise<Object>} Decay results
+   */
+  async triggerDecayCalculation() {
+    await this.initialize();
+
+    const storedPatterns = await storage.getPatterns(this.projectPath);
+
+    if (!storedPatterns || !storedPatterns.patterns || storedPatterns.patterns.length === 0) {
+      return {
+        totalPatterns: 0,
+        activePatterns: 0,
+        removedPatterns: 0
+      };
+    }
+
+    const beforeCount = storedPatterns.patterns.length;
+
+    // Apply decay
+    const decayedPatterns = applyDecayToStoredPatterns(
+      storedPatterns.patterns,
+      this.decayConfig
+    );
+
+    // Clean up stale patterns
+    const { activePatterns, removedPatterns } = this.cleanupStalePatterns(decayedPatterns);
+
+    // Save results
+    await storage.savePatterns(this.projectPath, {
+      ...storedPatterns,
+      patterns: activePatterns,
+      lastDecayCheck: new Date().toISOString()
+    });
+
+    if (removedPatterns.length > 0) {
+      await this.saveRemovedPatternsHistory(removedPatterns);
+    }
+
+    return {
+      totalPatterns: beforeCount,
+      activePatterns: activePatterns.length,
+      removedPatterns: removedPatterns.length,
+      removed: removedPatterns
+    };
+  }
+
+  /**
+   * Get decay statistics
+   * @returns {Promise<Object>} Decay statistics
+   */
+  async getDecayStats() {
+    const patterns = await this.loadPatternsWithDecay();
+
+    if (!patterns || !patterns.patterns || patterns.patterns.length === 0) {
+      return {
+        totalPatterns: 0,
+        highConfidence: 0,
+        mediumConfidence: 0,
+        lowConfidence: 0,
+        avgConfidence: 0,
+        avgAge: 0
+      };
+    }
+
+    const now = new Date();
+    let totalConfidence = 0;
+    let totalAge = 0;
+    let highConfidence = 0;
+    let mediumConfidence = 0;
+    let lowConfidence = 0;
+
+    for (const pattern of patterns.patterns) {
+      totalConfidence += pattern.confidence;
+
+      // Calculate age in days
+      const created = new Date(pattern.createdAt);
+      const ageDays = (now - created) / (1000 * 60 * 60 * 24);
+      totalAge += ageDays;
+
+      // Count by confidence
+      if (pattern.confidence >= 80) {
+        highConfidence++;
+      } else if (pattern.confidence >= 60) {
+        mediumConfidence++;
+      } else {
+        lowConfidence++;
+      }
+    }
+
+    return {
+      totalPatterns: patterns.patterns.length,
+      highConfidence,
+      mediumConfidence,
+      lowConfidence,
+      avgConfidence: Math.round(totalConfidence / patterns.patterns.length),
+      avgAge: Math.round(totalAge / patterns.patterns.length)
+    };
+  }
+}
+
+module.exports = DecayManager;

package/lib/learning/learning-manager.js

@@ -4,6 +4,7 @@ const storage = require('./storage');
 const { analyzeSkipPatterns } = require('./skip-tracker');
 const { detectPatterns, getPatternSummary } = require('./pattern-detector');
 const { getActiveRules, toggleRule, removeRule } = require('./rule-generator');
+const { showAnalyticsDashboard } = require('./analytics-view');
 
 /**
  * Learning Manager - CLI interface for managing learning data
@@ -70,9 +71,10 @@ class LearningManager {
     console.log(chalk.cyan(`│     1. View Skip History`));
     console.log(chalk.cyan(`│     2. Review Detected Patterns`));
     console.log(chalk.cyan(`│     3. Manage Learned Rules`));
-    console.log(chalk.cyan(`│     4. Learning Settings ${config.enabled ? chalk.green('(✓ Enabled)') : chalk.yellow('(○ Disabled)')}`));
-    console.log(chalk.cyan(`│     5. Clear Learning Data`));
-    console.log(chalk.cyan(`│     6. Back to Main Menu`));
+    console.log(chalk.cyan(`│     4. ${chalk.green('📊 Analytics Dashboard')} ${chalk.gray('(NEW)')}`));
+    console.log(chalk.cyan(`│     5. Learning Settings ${config.enabled ? chalk.green('(✓ Enabled)') : chalk.yellow('(○ Disabled)')}`));
+    console.log(chalk.cyan(`│     6. Clear Learning Data`));
+    console.log(chalk.cyan(`│     7. Back to Main Menu`));
     console.log(chalk.cyan('│'));
     console.log(chalk.cyan.bold('└─────────────────────────────────────────────────────┘\n'));
 
@@ -85,9 +87,10 @@ class LearningManager {
           { name: '1. View Skip History', value: 'history' },
           { name: '2. Review Detected Patterns', value: 'patterns' },
           { name: '3. Manage Learned Rules', value: 'rules' },
-          { name: '4. Learning Settings', value: 'settings' },
-          { name: '5. Clear Learning Data', value: 'clear' },
-          { name: '6. Back to Main Menu', value: 'back' }
+          { name: chalk.green('4. 📊 Analytics Dashboard') + chalk.gray(' (NEW)'), value: 'analytics' },
+          { name: '5. Learning Settings', value: 'settings' },
+          { name: '6. Clear Learning Data', value: 'clear' },
+          { name: '7. Back to Main Menu', value: 'back' }
         ]
       }
     ]);
@@ -102,6 +105,9 @@ class LearningManager {
       case 'rules':
         await this.manageRules();
         break;
+      case 'analytics':
+        await this.showAnalytics();
+        break;
       case 'settings':
         await this.manageSettings();
         break;
@@ -398,6 +404,13 @@ class LearningManager {
     await this.pressEnterToContinue();
   }
 
+  /**
+   * Show analytics dashboard
+   */
+  async showAnalytics() {
+    await showAnalyticsDashboard(this.projectPath);
+  }
+
   /**
    * Clear all learning data
    */

package/lib/learning/pattern-detector.js

@@ -27,12 +27,20 @@ class PatternDetector {
    * @returns {Object} All detected patterns
    */
   detectAllPatterns() {
-    return {
+    const patterns = {
       consistentSkips: this.detectConsistentSkips(),
       categoryPatterns: this.detectCategoryPatterns(),
       frameworkPatterns: this.detectFrameworkPatterns(),
       userPreferences: this.detectUserPreferences()
     };
+
+    // Enhance all patterns with decay metadata
+    return {
+      consistentSkips: this.enhancePatternsWithMetadata(patterns.consistentSkips),
+      categoryPatterns: this.enhancePatternsWithMetadata(patterns.categoryPatterns),
+      frameworkPatterns: this.enhancePatternsWithMetadata(patterns.frameworkPatterns),
+      userPreferences: this.enhancePatternsWithMetadata(patterns.userPreferences)
+    };
   }
 
   /**
@@ -322,6 +330,197 @@ class PatternDetector {
 
     return frameworkData;
   }
+
+  /**
+   * Calculate decay for a pattern based on time inactive
+   * @param {Object} pattern - Pattern to apply decay to
+   * @param {Object} decayConfig - Decay configuration
+   * @returns {Object} Pattern with updated confidence
+   */
+  calculateDecay(pattern, decayConfig) {
+    // Skip if decay disabled
+    if (!decayConfig || !decayConfig.enabled) {
+      return pattern;
+    }
+
+    // Skip if user manually approved and protection enabled
+    if (pattern.userApproved && decayConfig.protectApproved) {
+      // Approved patterns decay at half rate
+      decayConfig = { ...decayConfig, baseDecayRate: decayConfig.baseDecayRate * 0.5 };
+    }
+
+    // Initialize timestamps if missing (backward compatibility)
+    const now = new Date();
+    const lastSeen = pattern.lastSeen ? new Date(pattern.lastSeen) : now;
+    const lastDecay = pattern.lastDecayCalculation ? new Date(pattern.lastDecayCalculation) : now;
+
+    // Calculate months since last seen
+    const monthsInactive = (now - lastSeen) / (1000 * 60 * 60 * 24 * 30);
+
+    // Skip if recently seen (< 1 week)
+    if (monthsInactive < 0.25) {
+      return pattern;
+    }
+
+    // Get decay rate based on confidence level
+    const decayRate = this.getDecayRate(pattern.confidence, decayConfig.baseDecayRate);
+
+    // Apply exponential decay
+    const newConfidence = pattern.confidence * Math.pow(1 - decayRate, monthsInactive);
+
+    // Round to 2 decimal places
+    const roundedConfidence = Math.round(newConfidence * 100) / 100;
+
+    // Ensure confidence doesn't go below 0
+    const finalConfidence = Math.max(0, roundedConfidence);
+
+    return {
+      ...pattern,
+      confidence: finalConfidence,
+      lastDecayCalculation: now.toISOString(),
+      // Store initial confidence if not already set
+      initialConfidence: pattern.initialConfidence || pattern.confidence
+    };
+  }
+
+  /**
+   * Get decay rate based on confidence level
+   * @param {number} confidence - Current confidence (0-100)
+   * @param {number} baseRate - Base decay rate (default 0.15)
+   * @returns {number} Adjusted decay rate
+   */
+  getDecayRate(confidence, baseRate = 0.15) {
+    // High confidence patterns decay slower
+    if (confidence >= 90) {
+      return baseRate * 0.5;  // 7.5% per month for high confidence
+    }
+    // Medium confidence patterns decay normally
+    if (confidence >= 75) {
+      return baseRate;  // 15% per month
+    }
+    // Low confidence patterns decay faster
+    return baseRate * 1.5;  // 22.5% per month for low confidence
+  }
+
+  /**
+   * Renew a pattern when it's reconfirmed by user behavior
+   * @param {Object} pattern - Pattern to renew
+   * @param {Object} decayConfig - Decay configuration
+   * @returns {Object} Renewed pattern
+   */
+  renewPattern(pattern, decayConfig) {
+    const now = new Date();
+    const renewalBoost = decayConfig?.renewalBoost || 10;
+
+    // Calculate new confidence with boost
+    let newConfidence = pattern.confidence + renewalBoost;
+
+    // Cap at initial confidence + growth allowance
+    const maxConfidence = Math.min((pattern.initialConfidence || pattern.confidence) + 5, 100);
+    newConfidence = Math.min(newConfidence, maxConfidence);
+
+    return {
+      ...pattern,
+      confidence: newConfidence,
+      lastSeen: now.toISOString(),
+      lastDecayCalculation: now.toISOString(),
+      timesRenewed: (pattern.timesRenewed || 0) + 1
+    };
+  }
+
+  /**
+   * Apply decay to all patterns
+   * @param {Array} patterns - Array of patterns
+   * @param {Object} decayConfig - Decay configuration
+   * @returns {Array} Patterns with decay applied
+   */
+  applyDecayToPatterns(patterns, decayConfig) {
+    if (!decayConfig || !decayConfig.enabled) {
+      return patterns;
+    }
+
+    return patterns.map(pattern => this.calculateDecay(pattern, decayConfig));
+  }
+
+  /**
+   * Cleanup stale patterns (remove those below threshold)
+   * @param {Array} patterns - Array of patterns
+   * @param {Object} decayConfig - Decay configuration
+   * @returns {Object} Active and removed patterns
+   */
+  cleanupStalePatterns(patterns, decayConfig) {
+    const now = new Date();
+    const activePatterns = [];
+    const removedPatterns = [];
+
+    const removeBelow = decayConfig?.removeBelow || 40;
+    const maxInactiveMonths = decayConfig?.maxInactiveMonths || 6;
+
+    for (const pattern of patterns) {
+      // Apply decay first
+      const decayedPattern = this.calculateDecay(pattern, decayConfig);
+
+      // Check if below removal threshold
+      if (decayedPattern.confidence < removeBelow) {
+        removedPatterns.push({
+          ...decayedPattern,
+          status: 'removed',
+          removedAt: now.toISOString(),
+          removalReason: 'confidence_too_low'
+        });
+      }
+      // Check if inactive for too long
+      else if (this.isInactiveTooLong(decayedPattern, maxInactiveMonths)) {
+        removedPatterns.push({
+          ...decayedPattern,
+          status: 'removed',
+          removedAt: now.toISOString(),
+          removalReason: 'inactive_too_long'
+        });
+      }
+      else {
+        activePatterns.push(decayedPattern);
+      }
+    }
+
+    return { activePatterns, removedPatterns };
+  }
+
+  /**
+   * Check if pattern has been inactive for too long
+   * @param {Object} pattern - Pattern to check
+   * @param {number} maxMonths - Maximum inactive months
+   * @returns {boolean} True if inactive too long
+   */
+  isInactiveTooLong(pattern, maxMonths = 6) {
+    if (!pattern.lastSeen) {
+      return false;  // No data, assume active
+    }
+
+    const now = new Date();
+    const lastSeen = new Date(pattern.lastSeen);
+    const monthsInactive = (now - lastSeen) / (1000 * 60 * 60 * 24 * 30);
+
+    return monthsInactive >= maxMonths;
+  }
+
+  /**
+   * Enhance patterns with decay metadata
+   * @param {Array} patterns - Patterns to enhance
+   * @returns {Array} Enhanced patterns with timestamps
+   */
+  enhancePatternsWithMetadata(patterns) {
+    const now = new Date();
+
+    return patterns.map(pattern => ({
+      ...pattern,
+      createdAt: pattern.createdAt || now.toISOString(),
+      lastSeen: pattern.lastSeen || now.toISOString(),
+      lastDecayCalculation: pattern.lastDecayCalculation || now.toISOString(),
+      initialConfidence: pattern.initialConfidence || pattern.confidence,
+      timesRenewed: pattern.timesRenewed || 0
+    }));
+  }
 }
 
 /**
@@ -369,8 +568,92 @@ function getPatternSummary(patterns) {
   };
 }
 
+/**
+ * Apply decay to patterns from storage
+ * @param {Array} patterns - Patterns to apply decay to
+ * @param {Object} decayConfig - Decay configuration
+ * @returns {Object} Active and removed patterns
+ */
+function applyDecayToStoredPatterns(patterns, decayConfig) {
+  if (!patterns || patterns.length === 0) {
+    return [];
+  }
+
+  // Create a detector instance just for decay operations
+  const detector = new PatternDetector({ sessions: [] }, { sessions: [] }, {});
+
+  // Apply decay to all patterns (returns array)
+  return detector.applyDecayToPatterns(patterns, decayConfig);
+}
+
+/**
+ * Renew a pattern (boost confidence when reconfirmed)
+ * @param {Object} pattern - Pattern to renew
+ * @param {Object} decayConfig - Decay configuration
+ * @returns {Object} Renewed pattern
+ */
+function renewStoredPattern(pattern, decayConfig) {
+  const detector = new PatternDetector({ sessions: [] }, { sessions: [] }, {});
+  return detector.renewPattern(pattern, decayConfig);
+}
+
+/**
+ * Get default decay configuration
+ * @returns {Object} Default decay config
+ */
+function getDefaultDecayConfig() {
+  return {
+    enabled: true,
+    baseDecayRate: 0.15,              // 15% per month
+    minConfidenceThreshold: 50,       // Don't filter if confidence < 50
+    removeBelow: 40,                  // Auto-remove if < 40
+    renewalBoost: 10,                 // +10 points on renewal
+    protectApproved: true,            // Approved patterns decay at 0.5x rate
+    maxInactiveMonths: 6              // Remove if inactive for 6+ months
+  };
+}
+
+/**
+ * Calculate decay for a pattern (standalone function for testing)
+ * @param {Object} pattern - Pattern object
+ * @param {Object} decayConfig - Decay configuration
+ * @returns {Object} Pattern with updated confidence
+ */
+function calculateDecay(pattern, decayConfig) {
+  const detector = new PatternDetector({ sessions: [] }, { sessions: [] }, {});
+  return detector.calculateDecay(pattern, decayConfig);
+}
+
+/**
+ * Get decay rate based on confidence level (standalone function for testing)
+ * @param {number} confidence - Pattern confidence (0-100)
+ * @param {number} baseRate - Base decay rate (default 0.15)
+ * @returns {number} Adjusted decay rate
+ */
+function getDecayRate(confidence, baseRate = 0.15) {
+  const detector = new PatternDetector({ sessions: [] }, { sessions: [] }, {});
+  return detector.getDecayRate(confidence, baseRate);
+}
+
+/**
+ * Renew pattern (standalone function for testing)
+ * @param {Object} pattern - Pattern object
+ * @param {Object} decayConfig - Decay configuration
+ * @returns {Object} Renewed pattern
+ */
+function renewPattern(pattern, decayConfig) {
+  const detector = new PatternDetector({ sessions: [] }, { sessions: [] }, {});
+  return detector.renewPattern(pattern, decayConfig);
+}
+
 module.exports = {
   PatternDetector,
   detectPatterns,
-  getPatternSummary
+  getPatternSummary,
+  applyDecayToStoredPatterns,
+  renewStoredPattern,
+  getDefaultDecayConfig,
+  calculateDecay,
+  getDecayRate,
+  renewPattern
 };