@iservu-inc/adf-cli 0.3.0 → 0.4.12

package/lib/learning/pattern-detector.js

@@ -0,0 +1,376 @@
+const storage = require('./storage');
+const { v4: uuidv4 } = require('uuid');
+
+/**
+ * Pattern Detector - Analyzes skip/answer history to detect patterns
+ *
+ * Detects:
+ * - Consistent skip patterns (same question skipped repeatedly)
+ * - Category skip patterns (user skips most questions in a category)
+ * - Framework-specific patterns (framework + question combinations)
+ * - User preferences (answer style, detail level)
+ */
+
+class PatternDetector {
+  constructor(skipHistory, answerHistory, config = {}) {
+    this.skipHistory = skipHistory;
+    this.answerHistory = answerHistory;
+    this.config = {
+      minSessionsForPattern: config.minSessionsForPattern || 3,
+      minConfidenceForAutoFilter: config.minConfidenceForAutoFilter || 75,
+      ...config
+    };
+  }
+
+  /**
+   * Detect all patterns
+   * @returns {Object} All detected patterns
+   */
+  detectAllPatterns() {
+    return {
+      consistentSkips: this.detectConsistentSkips(),
+      categoryPatterns: this.detectCategoryPatterns(),
+      frameworkPatterns: this.detectFrameworkPatterns(),
+      userPreferences: this.detectUserPreferences()
+    };
+  }
+
+  /**
+   * Detect consistent skip patterns
+   * @returns {Array} Consistent skip patterns
+   */
+  detectConsistentSkips() {
+    const patterns = [];
+    const questionSkipData = this.aggregateQuestionSkips();
+
+    for (const [questionId, data] of Object.entries(questionSkipData)) {
+      const totalSessions = this.skipHistory.sessions.length;
+      const skipCount = data.skipCount;
+      const confidence = Math.round((skipCount / totalSessions) * 100);
+
+      // Pattern threshold: skipped in 75%+ of sessions with minimum sessions
+      if (skipCount >= this.config.minSessionsForPattern && confidence >= 75) {
+        patterns.push({
+          id: `pattern_skip_${questionId}`,
+          type: 'consistent_skip',
+          questionId,
+          questionText: data.text,
+          category: data.category,
+          confidence,
+          sessionsAnalyzed: totalSessions,
+          skipCount,
+          recommendation: confidence >= this.config.minConfidenceForAutoFilter
+            ? 'Auto-filter this question'
+            : 'Monitor for more sessions',
+          status: 'detected',
+          userApproved: false
+        });
+      }
+    }
+
+    return patterns.sort((a, b) => b.confidence - a.confidence);
+  }
+
+  /**
+   * Detect category skip patterns
+   * @returns {Array} Category skip patterns
+   */
+  detectCategoryPatterns() {
+    const patterns = [];
+    const categoryData = this.aggregateCategoryData();
+
+    for (const [category, data] of Object.entries(categoryData)) {
+      if (data.totalQuestions === 0) continue;
+
+      const skipRate = Math.round((data.skipCount / data.totalQuestions) * 100);
+
+      // Pattern threshold: 70%+ skip rate in category with minimum appearances
+      if (data.totalQuestions >= 5 && skipRate >= 70) {
+        patterns.push({
+          id: `pattern_category_${category}`,
+          type: 'category_skip',
+          category,
+          confidence: skipRate,
+          totalQuestions: data.totalQuestions,
+          skipCount: data.skipCount,
+          recommendation: skipRate >= this.config.minConfidenceForAutoFilter
+            ? `Reduce relevance for ${category} questions`
+            : 'Monitor category skip behavior',
+          status: 'detected',
+          userApproved: false
+        });
+      }
+    }
+
+    return patterns.sort((a, b) => b.confidence - a.confidence);
+  }
+
+  /**
+   * Detect framework-specific skip patterns
+   * @returns {Array} Framework skip patterns
+   */
+  detectFrameworkPatterns() {
+    const patterns = [];
+    const frameworkSkipData = this.aggregateFrameworkSkips();
+
+    for (const [framework, questions] of Object.entries(frameworkSkipData)) {
+      for (const [questionId, data] of Object.entries(questions)) {
+        const frameworkSessions = this.skipHistory.sessions.filter(
+          s => s.frameworks && s.frameworks.includes(framework)
+        ).length;
+
+        if (frameworkSessions < this.config.minSessionsForPattern) continue;
+
+        const confidence = Math.round((data.skipCount / frameworkSessions) * 100);
+
+        // Pattern threshold: 75%+ skip rate for framework + question combo
+        if (confidence >= 75) {
+          patterns.push({
+            id: `pattern_framework_${framework}_${questionId}`,
+            type: 'framework_skip',
+            framework,
+            questionId,
+            questionText: data.text,
+            category: data.category,
+            confidence,
+            sessionsAnalyzed: frameworkSessions,
+            skipCount: data.skipCount,
+            recommendation: `Skip "${data.text}" for ${framework} projects`,
+            status: 'detected',
+            userApproved: false
+          });
+        }
+      }
+    }
+
+    return patterns.sort((a, b) => b.confidence - a.confidence);
+  }
+
+  /**
+   * Detect user preference patterns
+   * @returns {Array} User preference patterns
+   */
+  detectUserPreferences() {
+    const patterns = [];
+
+    if (!this.answerHistory || !this.answerHistory.sessions) {
+      return patterns;
+    }
+
+    // Analyze answer length by category
+    const categoryAnswerData = {};
+
+    for (const session of this.answerHistory.sessions) {
+      for (const answer of session.answers || []) {
+        if (!answer.category) continue;
+
+        if (!categoryAnswerData[answer.category]) {
+          categoryAnswerData[answer.category] = {
+            totalAnswers: 0,
+            totalWords: 0,
+            avgWords: 0
+          };
+        }
+
+        categoryAnswerData[answer.category].totalAnswers++;
+        categoryAnswerData[answer.category].totalWords += answer.wordCount || 0;
+      }
+    }
+
+    // Detect brief answer preferences
+    for (const [category, data] of Object.entries(categoryAnswerData)) {
+      if (data.totalAnswers < 3) continue;
+
+      data.avgWords = Math.round(data.totalWords / data.totalAnswers);
+
+      // Brief answers: <30 words on average
+      if (data.avgWords < 30) {
+        patterns.push({
+          id: `pattern_pref_brief_${category}`,
+          type: 'user_preference',
+          category,
+          preference: 'brief_answers',
+          avgWordCount: data.avgWords,
+          confidence: 70,
+          recommendation: `User prefers brief answers for ${category} questions`,
+          status: 'detected',
+          userApproved: false
+        });
+      }
+      // Detailed answers: >100 words on average
+      else if (data.avgWords > 100) {
+        patterns.push({
+          id: `pattern_pref_detailed_${category}`,
+          type: 'user_preference',
+          category,
+          preference: 'detailed_answers',
+          avgWordCount: data.avgWords,
+          confidence: 70,
+          recommendation: `User prefers detailed answers for ${category} questions`,
+          status: 'detected',
+          userApproved: false
+        });
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Aggregate question skip data
+   * @returns {Object} Question skip data
+   */
+  aggregateQuestionSkips() {
+    const questionData = {};
+
+    for (const session of this.skipHistory.sessions) {
+      const sessionQuestions = new Set(); // Track unique questions per session
+
+      for (const skip of session.skips || []) {
+        // Only count manual skips for pattern detection
+        if (skip.reason !== 'manual') continue;
+
+        if (!questionData[skip.questionId]) {
+          questionData[skip.questionId] = {
+            text: skip.text,
+            category: skip.category,
+            skipCount: 0,
+            sessions: []
+          };
+        }
+
+        // Only count once per session
+        if (!sessionQuestions.has(skip.questionId)) {
+          questionData[skip.questionId].skipCount++;
+          questionData[skip.questionId].sessions.push(session.sessionId);
+          sessionQuestions.add(skip.questionId);
+        }
+      }
+    }
+
+    return questionData;
+  }
+
+  /**
+   * Aggregate category data (total questions vs skips)
+   * @returns {Object} Category data
+   */
+  aggregateCategoryData() {
+    const categoryData = {};
+
+    for (const session of this.skipHistory.sessions) {
+      // Count all questions by category (skipped + answered)
+      const sessionCategories = {};
+
+      for (const skip of session.skips || []) {
+        if (!skip.category) continue;
+
+        if (!sessionCategories[skip.category]) {
+          sessionCategories[skip.category] = { total: 0, skipped: 0 };
+        }
+
+        sessionCategories[skip.category].total++;
+        if (skip.reason === 'manual') {
+          sessionCategories[skip.category].skipped++;
+        }
+      }
+
+      // Aggregate across sessions
+      for (const [category, counts] of Object.entries(sessionCategories)) {
+        if (!categoryData[category]) {
+          categoryData[category] = { totalQuestions: 0, skipCount: 0 };
+        }
+
+        categoryData[category].totalQuestions += counts.total;
+        categoryData[category].skipCount += counts.skipped;
+      }
+    }
+
+    return categoryData;
+  }
+
+  /**
+   * Aggregate framework-specific skip data
+   * @returns {Object} Framework skip data
+   */
+  aggregateFrameworkSkips() {
+    const frameworkData = {};
+
+    for (const session of this.skipHistory.sessions) {
+      const frameworks = session.frameworks || [];
+
+      for (const framework of frameworks) {
+        if (!frameworkData[framework]) {
+          frameworkData[framework] = {};
+        }
+
+        for (const skip of session.skips || []) {
+          if (skip.reason !== 'manual') continue;
+
+          if (!frameworkData[framework][skip.questionId]) {
+            frameworkData[framework][skip.questionId] = {
+              text: skip.text,
+              category: skip.category,
+              skipCount: 0
+            };
+          }
+
+          frameworkData[framework][skip.questionId].skipCount++;
+        }
+      }
+    }
+
+    return frameworkData;
+  }
+}
+
+/**
+ * Detect patterns from project history
+ * @param {string} projectPath - Project root path
+ * @returns {Promise<Object>} Detected patterns
+ */
+async function detectPatterns(projectPath) {
+  const skipHistory = await storage.getSkipHistory(projectPath);
+  const answerHistory = await storage.getAnswerHistory(projectPath);
+  const config = await storage.getLearningConfig(projectPath);
+
+  const detector = new PatternDetector(skipHistory, answerHistory, config);
+  return detector.detectAllPatterns();
+}
+
+/**
+ * Get pattern summary statistics
+ * @param {Object} patterns - Detected patterns
+ * @returns {Object} Summary statistics
+ */
+function getPatternSummary(patterns) {
+  const allPatterns = [
+    ...(patterns.consistentSkips || []),
+    ...(patterns.categoryPatterns || []),
+    ...(patterns.frameworkPatterns || []),
+    ...(patterns.userPreferences || [])
+  ];
+
+  const highConfidence = allPatterns.filter(p => p.confidence >= 80).length;
+  const mediumConfidence = allPatterns.filter(p => p.confidence >= 60 && p.confidence < 80).length;
+  const lowConfidence = allPatterns.filter(p => p.confidence < 60).length;
+
+  return {
+    total: allPatterns.length,
+    highConfidence,
+    mediumConfidence,
+    lowConfidence,
+    byType: {
+      consistentSkips: patterns.consistentSkips?.length || 0,
+      categoryPatterns: patterns.categoryPatterns?.length || 0,
+      frameworkPatterns: patterns.frameworkPatterns?.length || 0,
+      userPreferences: patterns.userPreferences?.length || 0
+    }
+  };
+}
+
+module.exports = {
+  PatternDetector,
+  detectPatterns,
+  getPatternSummary
+};

package/lib/learning/rule-generator.js

@@ -0,0 +1,304 @@
+const storage = require('./storage');
+
+/**
+ * Rule Generator - Converts detected patterns into filtering rules
+ *
+ * Generates rules like:
+ * - Skip specific questions
+ * - Reduce relevance for categories
+ * - Framework-specific adjustments
+ * - User preference adjustments
+ */
+
+/**
+ * Generate filtering rules from patterns
+ * @param {Object} patterns - Detected patterns
+ * @param {Object} config - Learning configuration
+ * @returns {Array} Generated rules
+ */
+function generateRulesFromPatterns(patterns, config = {}) {
+  const rules = [];
+  const minConfidence = config.minConfidenceForAutoFilter || 75;
+
+  // Rules from consistent skip patterns
+  for (const pattern of patterns.consistentSkips || []) {
+    if (pattern.confidence >= minConfidence) {
+      rules.push({
+        id: `rule_${pattern.id}`,
+        type: 'skip_question',
+        questionId: pattern.questionId,
+        adjustment: -100, // Completely filter out
+        reason: `Consistently skipped (${pattern.confidence}% confidence, ${pattern.skipCount}/${pattern.sessionsAnalyzed} sessions)`,
+        confidence: pattern.confidence,
+        patternId: pattern.id,
+        appliedSince: new Date().toISOString(),
+        enabled: true
+      });
+    }
+  }
+
+  // Rules from category patterns
+  for (const pattern of patterns.categoryPatterns || []) {
+    if (pattern.confidence >= minConfidence) {
+      // Reduce relevance but don't completely filter
+      rules.push({
+        id: `rule_${pattern.id}`,
+        type: 'reduce_relevance',
+        category: pattern.category,
+        adjustment: -30, // Reduce score by 30 points
+        reason: `Category skip rate: ${pattern.confidence}% (${pattern.skipCount}/${pattern.totalQuestions} questions)`,
+        confidence: pattern.confidence,
+        patternId: pattern.id,
+        appliedSince: new Date().toISOString(),
+        enabled: true
+      });
+    }
+  }
+
+  // Rules from framework patterns
+  for (const pattern of patterns.frameworkPatterns || []) {
+    if (pattern.confidence >= minConfidence) {
+      rules.push({
+        id: `rule_${pattern.id}`,
+        type: 'framework_skip',
+        framework: pattern.framework,
+        questionId: pattern.questionId,
+        adjustment: -50, // Strong reduction for framework-specific skips
+        reason: `${pattern.framework} users skip this (${pattern.confidence}% confidence)`,
+        confidence: pattern.confidence,
+        patternId: pattern.id,
+        appliedSince: new Date().toISOString(),
+        enabled: true
+      });
+    }
+  }
+
+  // Rules from user preferences (informational, lower priority)
+  for (const pattern of patterns.userPreferences || []) {
+    if (pattern.preference === 'brief_answers' && pattern.avgWordCount < 20) {
+      // User gives very brief answers to this category
+      rules.push({
+        id: `rule_${pattern.id}`,
+        type: 'preference_brief',
+        category: pattern.category,
+        adjustment: -15, // Slight reduction
+        reason: `User prefers brief answers (avg ${pattern.avgWordCount} words)`,
+        confidence: pattern.confidence,
+        patternId: pattern.id,
+        appliedSince: new Date().toISOString(),
+        enabled: true
+      });
+    }
+  }
+
+  return rules;
+}
+
+/**
+ * Apply learned rules to a question's relevance score
+ * @param {Object} question - Question object
+ * @param {Object} projectContext - Project context
+ * @param {Array} rules - Learned rules
+ * @returns {Object} Adjustment details
+ */
+function applyLearnedRules(question, projectContext, rules) {
+  let totalAdjustment = 0;
+  const appliedRules = [];
+
+  for (const rule of rules) {
+    if (!rule.enabled) continue;
+
+    let applies = false;
+
+    switch (rule.type) {
+      case 'skip_question':
+        if (question.id === rule.questionId) {
+          applies = true;
+        }
+        break;
+
+      case 'reduce_relevance':
+        if (question.category === rule.category) {
+          applies = true;
+        }
+        break;
+
+      case 'framework_skip':
+        if (
+          question.id === rule.questionId &&
+          projectContext.frameworks &&
+          projectContext.frameworks.includes(rule.framework)
+        ) {
+          applies = true;
+        }
+        break;
+
+      case 'preference_brief':
+        if (question.category === rule.category) {
+          applies = true;
+        }
+        break;
+    }
+
+    if (applies) {
+      totalAdjustment += rule.adjustment;
+      appliedRules.push({
+        ruleId: rule.id,
+        type: rule.type,
+        adjustment: rule.adjustment,
+        reason: rule.reason,
+        confidence: rule.confidence
+      });
+    }
+  }
+
+  return {
+    adjustment: totalAdjustment,
+    appliedRules,
+    hasLearning: appliedRules.length > 0
+  };
+}
+
+/**
+ * Get rule explanations for user display
+ * @param {Array} rules - Learned rules
+ * @returns {Array} Formatted rule explanations
+ */
+function getRuleExplanations(rules) {
+  const explanations = [];
+
+  // Group by type
+  const byType = {
+    skip_question: [],
+    reduce_relevance: [],
+    framework_skip: [],
+    preference_brief: []
+  };
+
+  for (const rule of rules) {
+    if (rule.enabled && byType[rule.type]) {
+      byType[rule.type].push(rule);
+    }
+  }
+
+  // Skip question rules
+  if (byType.skip_question.length > 0) {
+    explanations.push({
+      type: 'skip_question',
+      count: byType.skip_question.length,
+      message: `Skip ${byType.skip_question.length} question${byType.skip_question.length > 1 ? 's' : ''} (consistently skipped)`,
+      details: byType.skip_question.map(r => r.reason)
+    });
+  }
+
+  // Category reduction rules
+  if (byType.reduce_relevance.length > 0) {
+    const categories = byType.reduce_relevance.map(r => r.category).join(', ');
+    explanations.push({
+      type: 'reduce_relevance',
+      count: byType.reduce_relevance.length,
+      message: `Reduce relevance for: ${categories}`,
+      details: byType.reduce_relevance.map(r => r.reason)
+    });
+  }
+
+  // Framework skip rules
+  if (byType.framework_skip.length > 0) {
+    explanations.push({
+      type: 'framework_skip',
+      count: byType.framework_skip.length,
+      message: `Framework-specific filtering (${byType.framework_skip.length} rule${byType.framework_skip.length > 1 ? 's' : ''})`,
+      details: byType.framework_skip.map(r => r.reason)
+    });
+  }
+
+  // Preference rules
+  if (byType.preference_brief.length > 0) {
+    explanations.push({
+      type: 'preference_brief',
+      count: byType.preference_brief.length,
+      message: `User preference adjustments (${byType.preference_brief.length} categor${byType.preference_brief.length > 1 ? 'ies' : 'y'})`,
+      details: byType.preference_brief.map(r => r.reason)
+    });
+  }
+
+  return explanations;
+}
+
+/**
+ * Update learned rules based on new patterns
+ * @param {string} projectPath - Project root path
+ * @param {Object} patterns - Newly detected patterns
+ */
+async function updateLearnedRules(projectPath, patterns) {
+  const config = await storage.getLearningConfig(projectPath);
+  const currentRules = await storage.getLearnedRules(projectPath);
+
+  // Generate new rules from patterns
+  const newRules = generateRulesFromPatterns(patterns, config);
+
+  // Merge with existing rules (don't duplicate)
+  const existingRuleIds = new Set(currentRules.rules.map(r => r.id));
+  const rulesToAdd = newRules.filter(r => !existingRuleIds.has(r.id));
+
+  // Add new rules
+  currentRules.rules.push(...rulesToAdd);
+
+  // Save updated rules
+  await storage.saveLearnedRules(projectPath, currentRules);
+
+  return {
+    added: rulesToAdd.length,
+    total: currentRules.rules.length
+  };
+}
+
+/**
+ * Get active learned rules
+ * @param {string} projectPath - Project root path
+ * @returns {Promise<Array>} Active rules
+ */
+async function getActiveRules(projectPath) {
+  const rulesData = await storage.getLearnedRules(projectPath);
+  return rulesData.rules.filter(r => r.enabled);
+}
+
+/**
+ * Enable or disable a specific rule
+ * @param {string} projectPath - Project root path
+ * @param {string} ruleId - Rule ID
+ * @param {boolean} enabled - Enable/disable
+ */
+async function toggleRule(projectPath, ruleId, enabled) {
+  const rulesData = await storage.getLearnedRules(projectPath);
+  const rule = rulesData.rules.find(r => r.id === ruleId);
+
+  if (rule) {
+    rule.enabled = enabled;
+    await storage.saveLearnedRules(projectPath, rulesData);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Remove a learned rule
+ * @param {string} projectPath - Project root path
+ * @param {string} ruleId - Rule ID
+ */
+async function removeRule(projectPath, ruleId) {
+  const rulesData = await storage.getLearnedRules(projectPath);
+  rulesData.rules = rulesData.rules.filter(r => r.id !== ruleId);
+  await storage.saveLearnedRules(projectPath, rulesData);
+}
+
+module.exports = {
+  generateRulesFromPatterns,
+  applyLearnedRules,
+  getRuleExplanations,
+  updateLearnedRules,
+  getActiveRules,
+  toggleRule,
+  removeRule
+};