@iservu-inc/adf-cli 0.3.0 → 0.4.12

package/lib/learning/learning-manager.js

@@ -0,0 +1,447 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const storage = require('./storage');
+const { analyzeSkipPatterns } = require('./skip-tracker');
+const { detectPatterns, getPatternSummary } = require('./pattern-detector');
+const { getActiveRules, toggleRule, removeRule } = require('./rule-generator');
+
+/**
+ * Learning Manager - CLI interface for managing learning data
+ *
+ * Provides:
+ * - View skip history
+ * - Review detected patterns
+ * - Enable/disable learning
+ * - Clear learning data
+ * - Export learning data
+ */
+
+class LearningManager {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+
+  /**
+   * Show main learning management menu
+   */
+  async showMenu() {
+    // Load stats
+    const stats = await storage.getLearningStats(this.projectPath);
+    const config = await storage.getLearningConfig(this.projectPath);
+    const patterns = await detectPatterns(this.projectPath);
+    const patternSummary = getPatternSummary(patterns);
+    const dataSize = await storage.getLearningDataSize(this.projectPath);
+
+    console.log(chalk.cyan.bold('\n┌─────────────────────────────────────────────────────┐'));
+    console.log(chalk.cyan.bold('│  Learning System Configuration                      │'));
+    console.log(chalk.cyan.bold('├─────────────────────────────────────────────────────┤'));
+    console.log(chalk.cyan('│'));
+    console.log(chalk.cyan(`│  📊 Learning Statistics`));
+    console.log(chalk.cyan(`│     Sessions analyzed: ${stats.totalSessions}`));
+    console.log(chalk.cyan(`│     Questions tracked: ${stats.totalAnswers + stats.totalSkips}`));
+    console.log(chalk.cyan(`│     Patterns detected: ${patternSummary.total}`));
+    console.log(chalk.cyan(`│     Storage used: ${(dataSize / 1024).toFixed(1)} KB`));
+    console.log(chalk.cyan('│'));
+
+    if (patternSummary.total > 0) {
+      console.log(chalk.cyan(`│  🎯 Detected Patterns`));
+
+      const allPatterns = [
+        ...patterns.consistentSkips.slice(0, 2),
+        ...patterns.categoryPatterns.slice(0, 1)
+      ];
+
+      for (const pattern of allPatterns.slice(0, 3)) {
+        const icon = pattern.confidence >= 80 ? '🔴' : pattern.confidence >= 60 ? '🟡' : '🟢';
+        if (pattern.type === 'consistent_skip') {
+          console.log(chalk.cyan(`│     ${icon} Skip "${pattern.questionText?.substring(0, 35)}..." (${pattern.confidence}%)`));
+        } else if (pattern.type === 'category_skip') {
+          console.log(chalk.cyan(`│     ${icon} Skip ${pattern.category} questions (${pattern.confidence}%)`));
+        }
+      }
+
+      if (patternSummary.total > 3) {
+        console.log(chalk.cyan(`│     ... and ${patternSummary.total - 3} more`));
+      }
+      console.log(chalk.cyan('│'));
+    }
+
+    console.log(chalk.cyan(`│  ⚙️  Options`));
+    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('│'));
+    console.log(chalk.cyan.bold('└─────────────────────────────────────────────────────┘\n'));
+
+    const { choice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'choice',
+        message: 'Select an option:',
+        choices: [
+          { 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' }
+        ]
+      }
+    ]);
+
+    switch (choice) {
+      case 'history':
+        await this.viewSkipHistory();
+        break;
+      case 'patterns':
+        await this.reviewPatterns();
+        break;
+      case 'rules':
+        await this.manageRules();
+        break;
+      case 'settings':
+        await this.manageSettings();
+        break;
+      case 'clear':
+        await this.clearLearningData();
+        break;
+      case 'back':
+        return 'back';
+    }
+
+    return 'continue';
+  }
+
+  /**
+   * View skip history
+   */
+  async viewSkipHistory() {
+    const analysis = await analyzeSkipPatterns(this.projectPath);
+
+    console.log(chalk.cyan.bold('\n📋 Skip History\n'));
+
+    if (analysis.totalSessions === 0) {
+      console.log(chalk.yellow('No skip history available yet.\n'));
+      console.log(chalk.gray('Skip history will be tracked as you complete interviews.\n'));
+      await this.pressEnterToContinue();
+      return;
+    }
+
+    console.log(chalk.gray(`Total Sessions: ${analysis.totalSessions}`));
+    console.log(chalk.gray(`Total Skips: ${analysis.totalSkips} (${analysis.manualSkips} manual, ${analysis.filteredSkips} filtered)\n`));
+
+    if (analysis.mostSkippedQuestions.length > 0) {
+      console.log(chalk.cyan('Most Skipped Questions:\n'));
+      for (const q of analysis.mostSkippedQuestions.slice(0, 10)) {
+        const percentage = Math.round((q.count / analysis.totalSessions) * 100);
+        console.log(chalk.white(`  ${q.count}x (${percentage}%) - ${q.text.substring(0, 60)}${q.text.length > 60 ? '...' : ''}`));
+        if (q.category) {
+          console.log(chalk.gray(`           Category: ${q.category}`));
+        }
+        console.log('');
+      }
+    }
+
+    if (analysis.mostSkippedCategories.length > 0) {
+      console.log(chalk.cyan('Most Skipped Categories:\n'));
+      for (const cat of analysis.mostSkippedCategories) {
+        console.log(chalk.white(`  ${cat.category}: ${cat.count} skips`));
+      }
+      console.log('');
+    }
+
+    await this.pressEnterToContinue();
+  }
+
+  /**
+   * Review detected patterns
+   */
+  async reviewPatterns() {
+    const patterns = await detectPatterns(this.projectPath);
+    const patternSummary = getPatternSummary(patterns);
+
+    console.log(chalk.cyan.bold('\n🔍 Detected Patterns\n'));
+
+    if (patternSummary.total === 0) {
+      console.log(chalk.yellow('No patterns detected yet.\n'));
+      console.log(chalk.gray('Patterns will be detected after 3+ interview sessions.\n'));
+      await this.pressEnterToContinue();
+      return;
+    }
+
+    console.log(chalk.gray(`Total Patterns: ${patternSummary.total}`));
+    console.log(chalk.gray(`High Confidence (≥80%): ${patternSummary.highConfidence}`));
+    console.log(chalk.gray(`Medium Confidence (60-79%): ${patternSummary.mediumConfidence}`));
+    console.log(chalk.gray(`Low Confidence (<60%): ${patternSummary.lowConfidence}\n`));
+
+    // Show high confidence patterns
+    if (patternSummary.highConfidence > 0) {
+      console.log(chalk.red.bold('🔴 High Confidence (>80%)\n'));
+
+      const highPatterns = [
+        ...patterns.consistentSkips.filter(p => p.confidence >= 80),
+        ...patterns.categoryPatterns.filter(p => p.confidence >= 80)
+      ];
+
+      for (const pattern of highPatterns.slice(0, 5)) {
+        if (pattern.type === 'consistent_skip') {
+          console.log(chalk.white(`  • Skip question: "${pattern.questionText}"`));
+          console.log(chalk.gray(`    Confidence: ${pattern.confidence}% (${pattern.skipCount} of ${pattern.sessionsAnalyzed} sessions)`));
+          console.log(chalk.green(`    ✓ Recommendation: ${pattern.recommendation}`));
+        } else if (pattern.type === 'category_skip') {
+          console.log(chalk.white(`  • Skip ${pattern.category} questions`));
+          console.log(chalk.gray(`    Confidence: ${pattern.confidence}% (${pattern.skipCount} of ${pattern.totalQuestions} questions)`));
+          console.log(chalk.green(`    ✓ Recommendation: ${pattern.recommendation}`));
+        }
+        console.log('');
+      }
+    }
+
+    // Show medium confidence patterns
+    if (patternSummary.mediumConfidence > 0) {
+      console.log(chalk.yellow.bold('🟡 Medium Confidence (60-80%)\n'));
+
+      const mediumPatterns = [
+        ...patterns.consistentSkips.filter(p => p.confidence >= 60 && p.confidence < 80),
+        ...patterns.categoryPatterns.filter(p => p.confidence >= 60 && p.confidence < 80),
+        ...patterns.userPreferences
+      ];
+
+      for (const pattern of mediumPatterns.slice(0, 3)) {
+        if (pattern.type === 'user_preference') {
+          console.log(chalk.white(`  • User preference: ${pattern.preference.replace('_', ' ')}`));
+          console.log(chalk.gray(`    Category: ${pattern.category}, Avg: ${pattern.avgWordCount} words`));
+          console.log(chalk.green(`    ℹ️  ${pattern.recommendation}`));
+        } else {
+          console.log(chalk.gray(`  • ${pattern.recommendation} (${pattern.confidence}%)`));
+        }
+        console.log('');
+      }
+    }
+
+    await this.pressEnterToContinue();
+  }
+
+  /**
+   * Manage learned rules
+   */
+  async manageRules() {
+    const rules = await getActiveRules(this.projectPath);
+
+    console.log(chalk.cyan.bold('\n⚙️  Learned Rules\n'));
+
+    if (rules.length === 0) {
+      console.log(chalk.yellow('No learned rules yet.\n'));
+      console.log(chalk.gray('Rules are automatically created from high-confidence patterns.\n'));
+      await this.pressEnterToContinue();
+      return;
+    }
+
+    console.log(chalk.gray(`Total Rules: ${rules.length} active\n`));
+
+    // Show rules
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      const status = rule.enabled ? chalk.green('✓ Enabled') : chalk.yellow('○ Disabled');
+
+      console.log(chalk.white(`${i + 1}. ${status}`));
+      console.log(chalk.gray(`   Type: ${rule.type}`));
+      console.log(chalk.gray(`   ${rule.reason}`));
+      console.log(chalk.gray(`   Confidence: ${rule.confidence}%`));
+      console.log('');
+    }
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'Enable/Disable a rule', value: 'toggle' },
+          { name: 'Back', value: 'back' }
+        ]
+      }
+    ]);
+
+    if (action === 'toggle') {
+      const { ruleIndex } = await inquirer.prompt([
+        {
+          type: 'number',
+          name: 'ruleIndex',
+          message: 'Enter rule number:',
+          validate: (input) => {
+            if (input < 1 || input > rules.length) {
+              return `Please enter a number between 1 and ${rules.length}`;
+            }
+            return true;
+          }
+        }
+      ]);
+
+      const rule = rules[ruleIndex - 1];
+      await toggleRule(this.projectPath, rule.id, !rule.enabled);
+
+      console.log(chalk.green(`\n✓ Rule ${rule.enabled ? 'disabled' : 'enabled'}\n`));
+      await this.pressEnterToContinue();
+    }
+  }
+
+  /**
+   * Manage learning settings
+   */
+  async manageSettings() {
+    const config = await storage.getLearningConfig(this.projectPath);
+
+    console.log(chalk.cyan.bold('\n⚙️  Learning System Settings\n'));
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to configure?',
+        choices: [
+          {
+            name: `Learning System: ${config.enabled ? chalk.green('✓ Enabled') : chalk.yellow('○ Disabled')}`,
+            value: 'toggle_enabled'
+          },
+          {
+            name: `Track Skip Actions: ${config.trackSkips ? chalk.green('✓') : chalk.yellow('○')}`,
+            value: 'toggle_skips'
+          },
+          {
+            name: `Track Answers: ${config.trackAnswers ? chalk.green('✓') : chalk.yellow('○')}`,
+            value: 'toggle_answers'
+          },
+          {
+            name: `Detect Patterns: ${config.detectPatterns ? chalk.green('✓') : chalk.yellow('○')}`,
+            value: 'toggle_patterns'
+          },
+          {
+            name: `Apply Learned Filters: ${config.applyLearnedFilters ? chalk.green('✓') : chalk.yellow('○')}`,
+            value: 'toggle_filters'
+          },
+          { name: `Minimum sessions for pattern: ${config.minSessionsForPattern}`, value: 'min_sessions' },
+          { name: `Minimum confidence for auto-filter: ${config.minConfidenceForAutoFilter}%`, value: 'min_confidence' },
+          { name: 'Reset to defaults', value: 'reset' },
+          { name: 'Back', value: 'back' }
+        ]
+      }
+    ]);
+
+    if (action === 'back') return;
+
+    if (action === 'toggle_enabled') {
+      config.enabled = !config.enabled;
+      await storage.saveLearningConfig(this.projectPath, config);
+      console.log(chalk.green(`\n✓ Learning system ${config.enabled ? 'enabled' : 'disabled'}\n`));
+    } else if (action === 'toggle_skips') {
+      config.trackSkips = !config.trackSkips;
+      await storage.saveLearningConfig(this.projectPath, config);
+      console.log(chalk.green(`\n✓ Skip tracking ${config.trackSkips ? 'enabled' : 'disabled'}\n`));
+    } else if (action === 'toggle_answers') {
+      config.trackAnswers = !config.trackAnswers;
+      await storage.saveLearningConfig(this.projectPath, config);
+      console.log(chalk.green(`\n✓ Answer tracking ${config.trackAnswers ? 'enabled' : 'disabled'}\n`));
+    } else if (action === 'toggle_patterns') {
+      config.detectPatterns = !config.detectPatterns;
+      await storage.saveLearningConfig(this.projectPath, config);
+      console.log(chalk.green(`\n✓ Pattern detection ${config.detectPatterns ? 'enabled' : 'disabled'}\n`));
+    } else if (action === 'toggle_filters') {
+      config.applyLearnedFilters = !config.applyLearnedFilters;
+      await storage.saveLearningConfig(this.projectPath, config);
+      console.log(chalk.green(`\n✓ Learned filters ${config.applyLearnedFilters ? 'enabled' : 'disabled'}\n`));
+    } else if (action === 'min_sessions') {
+      const { value } = await inquirer.prompt([
+        {
+          type: 'number',
+          name: 'value',
+          message: 'Minimum sessions for pattern detection:',
+          default: config.minSessionsForPattern,
+          validate: (input) => input >= 1 && input <= 10
+        }
+      ]);
+      config.minSessionsForPattern = value;
+      await storage.saveLearningConfig(this.projectPath, config);
+      console.log(chalk.green(`\n✓ Minimum sessions updated to ${value}\n`));
+    } else if (action === 'min_confidence') {
+      const { value } = await inquirer.prompt([
+        {
+          type: 'number',
+          name: 'value',
+          message: 'Minimum confidence for auto-filter (%):',
+          default: config.minConfidenceForAutoFilter,
+          validate: (input) => input >= 50 && input <= 100
+        }
+      ]);
+      config.minConfidenceForAutoFilter = value;
+      await storage.saveLearningConfig(this.projectPath, config);
+      console.log(chalk.green(`\n✓ Minimum confidence updated to ${value}%\n`));
+    } else if (action === 'reset') {
+      const defaultConfig = {
+        version: '1.0',
+        enabled: true,
+        trackSkips: true,
+        trackAnswers: true,
+        detectPatterns: true,
+        applyLearnedFilters: true,
+        shareAnonymousPatterns: false,
+        minSessionsForPattern: 3,
+        minConfidenceForAutoFilter: 75
+      };
+      await storage.saveLearningConfig(this.projectPath, defaultConfig);
+      console.log(chalk.green('\n✓ Settings reset to defaults\n'));
+    }
+
+    await this.pressEnterToContinue();
+  }
+
+  /**
+   * Clear all learning data
+   */
+  async clearLearningData() {
+    console.log(chalk.yellow.bold('\n⚠️  Clear Learning Data\n'));
+    console.log(chalk.gray('This will delete:'));
+    console.log(chalk.gray('  • Skip history'));
+    console.log(chalk.gray('  • Answer history'));
+    console.log(chalk.gray('  • Detected patterns'));
+    console.log(chalk.gray('  • Learned rules'));
+    console.log(chalk.gray('  • Statistics\n'));
+    console.log(chalk.red('This action cannot be undone.\n'));
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Are you sure you want to clear all learning data?',
+        default: false
+      }
+    ]);
+
+    if (confirm) {
+      await storage.clearLearningData(this.projectPath);
+      console.log(chalk.green('\n✓ Learning data cleared\n'));
+    } else {
+      console.log(chalk.gray('\nCancelled\n'));
+    }
+
+    await this.pressEnterToContinue();
+  }
+
+  /**
+   * Helper to pause for user input
+   */
+  async pressEnterToContinue() {
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: 'Press Enter to continue...',
+      }
+    ]);
+  }
+}
+
+module.exports = LearningManager;