@iservu-inc/adf-cli 0.3.0 → 0.4.12

package/lib/filters/question-filter.js

@@ -0,0 +1,480 @@
+const { PROJECT_TYPES } = require('../analyzers/project-analyzer');
+const { applyLearnedRules } = require('../learning/rule-generator');
+
+/**
+ * Question Filter - Smart filtering based on project context
+ *
+ * This module provides intelligent question filtering to:
+ * - Skip irrelevant questions based on project type
+ * - Score question relevance (0-100)
+ * - Reduce interview time by 40-60%
+ * - Maintain answer quality
+ */
+
+/**
+ * Question relevance rules by project type
+ * Each rule specifies which questions to skip or prioritize
+ */
+const RELEVANCE_RULES = {
+  [PROJECT_TYPES.CLI_TOOL]: {
+    skip: [
+      'user interface design',
+      'responsive design',
+      'browser compatibility',
+      'frontend framework',
+      'ui/ux',
+      'styling',
+      'css',
+      'accessibility features'
+    ],
+    prioritize: [
+      'command-line',
+      'cli',
+      'terminal',
+      'arguments',
+      'flags',
+      'options',
+      'npm',
+      'package'
+    ]
+  },
+
+  [PROJECT_TYPES.API_SERVER]: {
+    skip: [
+      'user interface',
+      'frontend',
+      'styling',
+      'responsive design',
+      'browser',
+      'ui/ux'
+    ],
+    prioritize: [
+      'api',
+      'endpoint',
+      'rest',
+      'graphql',
+      'authentication',
+      'authorization',
+      'database',
+      'backend',
+      'server',
+      'security'
+    ]
+  },
+
+  [PROJECT_TYPES.LIBRARY]: {
+    skip: [
+      'deployment',
+      'hosting',
+      'server',
+      'user interface',
+      'frontend'
+    ],
+    prioritize: [
+      'api',
+      'documentation',
+      'npm',
+      'package',
+      'version',
+      'dependencies',
+      'exports',
+      'typescript'
+    ]
+  },
+
+  [PROJECT_TYPES.WEB_APP]: {
+    skip: [],  // Web apps might need most questions
+    prioritize: [
+      'frontend',
+      'backend',
+      'user interface',
+      'responsive',
+      'browser',
+      'deployment',
+      'hosting'
+    ]
+  },
+
+  [PROJECT_TYPES.FULLSTACK]: {
+    skip: [],  // Fullstack needs comprehensive questions
+    prioritize: [
+      'frontend',
+      'backend',
+      'api',
+      'database',
+      'authentication',
+      'deployment'
+    ]
+  }
+};
+
+/**
+ * Framework-specific question relevance
+ */
+const FRAMEWORK_RULES = {
+  'React': {
+    skip: ['angular', 'vue', 'svelte'],
+    prioritize: ['component', 'hooks', 'state management', 'jsx']
+  },
+  'Vue': {
+    skip: ['react', 'angular', 'svelte'],
+    prioritize: ['component', 'composition api', 'vuex']
+  },
+  'Angular': {
+    skip: ['react', 'vue', 'svelte'],
+    prioritize: ['component', 'typescript', 'rxjs', 'dependency injection']
+  },
+  'Express': {
+    skip: ['fastify', 'koa', 'hapi'],
+    prioritize: ['middleware', 'routes', 'request', 'response']
+  },
+  'NestJS': {
+    skip: ['express routing'],
+    prioritize: ['modules', 'controllers', 'services', 'dependency injection']
+  }
+};
+
+/**
+ * Filter questions based on project context
+ * @param {Array} questions - Array of question objects
+ * @param {Object} projectContext - Project analysis context
+ * @param {Object} options - Filtering options
+ * @returns {Object} Filtered questions with metadata
+ */
+function filterQuestions(questions, projectContext, options = {}) {
+  const {
+    enableSmartFiltering = true,
+    minRelevanceScore = 50,  // Skip questions below this score
+    aiClient = null,  // Optional AI client for enhanced filtering
+    learnedRules = []  // Optional learned rules (Phase 4.2)
+  } = options;
+
+  if (!enableSmartFiltering) {
+    return {
+      questions,
+      skipped: [],
+      summary: { total: questions.length, kept: questions.length, skipped: 0, skippedByLearning: 0 }
+    };
+  }
+
+  const kept = [];
+  const skipped = [];
+  let skippedByLearning = 0;
+
+  for (const question of questions) {
+    const relevance = scoreQuestionRelevance(question, projectContext, learnedRules);
+
+    if (relevance.score >= minRelevanceScore) {
+      kept.push({
+        ...question,
+        relevance: relevance.score,
+        reason: relevance.reason,
+        learningApplied: relevance.learningApplied
+      });
+    } else {
+      skipped.push({
+        ...question,
+        relevance: relevance.score,
+        reason: relevance.skipReason,
+        learningApplied: relevance.learningApplied
+      });
+
+      // Track if this was skipped due to learning
+      if (relevance.learningApplied && relevance.learningAdjustment < 0) {
+        skippedByLearning++;
+      }
+    }
+  }
+
+  return {
+    questions: kept,
+    skipped,
+    summary: {
+      total: questions.length,
+      kept: kept.length,
+      skipped: skipped.length,
+      skippedByLearning,
+      timeSaved: estimateTimeSaved(skipped.length),
+      learningActive: learnedRules.length > 0
+    }
+  };
+}
+
+/**
+ * Score question relevance (0-100)
+ * @param {Object} question - Question object
+ * @param {Object} projectContext - Project analysis context
+ * @param {Array} learnedRules - Optional learned rules to apply
+ * @returns {Object} Relevance score and reasoning
+ */
+function scoreQuestionRelevance(question, projectContext, learnedRules = []) {
+  let score = 100;  // Start with perfect relevance
+  let reasons = [];
+  let skipReasons = [];
+
+  const questionText = (question.text + ' ' + (question.guidance || '')).toLowerCase();
+  const projectType = projectContext.type;
+  const frameworks = projectContext.frameworks || [];
+
+  // Apply project type rules
+  const typeRules = RELEVANCE_RULES[projectType];
+  if (typeRules) {
+    // Check skip keywords
+    for (const skipKeyword of typeRules.skip) {
+      if (questionText.includes(skipKeyword.toLowerCase())) {
+        score -= 40;
+        skipReasons.push(`Not relevant for ${projectType} (mentions ${skipKeyword})`);
+      }
+    }
+
+    // Check prioritize keywords (boost relevance)
+    for (const prioritizeKeyword of typeRules.prioritize) {
+      if (questionText.includes(prioritizeKeyword.toLowerCase())) {
+        score += 10;
+        reasons.push(`Highly relevant for ${projectType} (${prioritizeKeyword})`);
+      }
+    }
+  }
+
+  // Apply framework-specific rules
+  for (const framework of frameworks) {
+    const frameworkRules = FRAMEWORK_RULES[framework];
+    if (frameworkRules) {
+      // Check skip keywords
+      for (const skipKeyword of frameworkRules.skip) {
+        if (questionText.includes(skipKeyword.toLowerCase())) {
+          score -= 30;
+          skipReasons.push(`Using ${framework}, not ${skipKeyword}`);
+        }
+      }
+
+      // Check prioritize keywords
+      for (const prioritizeKeyword of frameworkRules.prioritize) {
+        if (questionText.includes(prioritizeKeyword.toLowerCase())) {
+          score += 5;
+          reasons.push(`Relevant for ${framework}`);
+        }
+      }
+    }
+  }
+
+  // Question category specific rules
+  if (question.category) {
+    const categoryScore = scoreCategoryRelevance(question.category, projectContext);
+    score = score * (categoryScore / 100);
+    if (categoryScore < 50) {
+      skipReasons.push(`Category '${question.category}' less relevant for this project`);
+    }
+  }
+
+  // Apply learned rules (Phase 4.2)
+  let learningAdjustment = null;
+  if (learnedRules && learnedRules.length > 0) {
+    learningAdjustment = applyLearnedRules(question, projectContext, learnedRules);
+    score += learningAdjustment.adjustment;
+
+    // Add learning reasons
+    for (const applied of learningAdjustment.appliedRules) {
+      if (applied.adjustment < 0) {
+        skipReasons.push(`Learned: ${applied.reason}`);
+      } else {
+        reasons.push(`Learned: ${applied.reason}`);
+      }
+    }
+  }
+
+  // Normalize score to 0-100 range
+  score = Math.max(0, Math.min(100, score));
+
+  return {
+    score: Math.round(score),
+    reason: reasons.join('; ') || 'Standard relevance',
+    skipReason: skipReasons.join('; ') || 'Low relevance score',
+    learningApplied: learningAdjustment?.hasLearning || false,
+    learningAdjustment: learningAdjustment?.adjustment || 0
+  };
+}
+
+/**
+ * Score category relevance for project type
+ */
+function scoreCategoryRelevance(category, projectContext) {
+  const categoryLower = category.toLowerCase();
+  const projectType = projectContext.type;
+
+  // Category relevance by project type
+  const relevanceMap = {
+    [PROJECT_TYPES.CLI_TOOL]: {
+      'frontend': 0,
+      'ui/ux': 0,
+      'design': 0,
+      'deployment': 70,
+      'architecture': 80,
+      'testing': 90,
+      'cli': 100,
+      'package': 100
+    },
+    [PROJECT_TYPES.API_SERVER]: {
+      'frontend': 0,
+      'ui/ux': 0,
+      'design': 0,
+      'api': 100,
+      'backend': 100,
+      'security': 100,
+      'database': 100,
+      'deployment': 90
+    },
+    [PROJECT_TYPES.LIBRARY]: {
+      'frontend': 30,
+      'backend': 30,
+      'api': 100,
+      'documentation': 100,
+      'testing': 100,
+      'package': 100,
+      'deployment': 50
+    },
+    [PROJECT_TYPES.WEB_APP]: {
+      'frontend': 100,
+      'ui/ux': 100,
+      'design': 90,
+      'backend': 80,
+      'deployment': 90
+    },
+    [PROJECT_TYPES.FULLSTACK]: {
+      'frontend': 100,
+      'backend': 100,
+      'api': 90,
+      'database': 90,
+      'deployment': 100
+    }
+  };
+
+  const typeMap = relevanceMap[projectType];
+  if (!typeMap) return 100;  // Default to relevant if unknown
+
+  // Find matching category
+  for (const [cat, score] of Object.entries(typeMap)) {
+    if (categoryLower.includes(cat)) {
+      return score;
+    }
+  }
+
+  return 70;  // Default moderate relevance
+}
+
+/**
+ * Estimate time saved by skipping questions (in minutes)
+ */
+function estimateTimeSaved(skippedCount) {
+  // Assume avg 2 minutes per question (read + think + answer + AI analysis)
+  const avgTimePerQuestion = 2;
+  return skippedCount * avgTimePerQuestion;
+}
+
+/**
+ * Check if specific question should be asked based on previous answers
+ * @param {Object} question - Question to check
+ * @param {Object} previousAnswers - Map of previous answers
+ * @param {Object} projectContext - Project context
+ * @returns {boolean} Whether to ask the question
+ */
+function shouldAskQuestion(question, previousAnswers, projectContext) {
+  // If question has conditional logic
+  if (question.condition) {
+    return evaluateCondition(question.condition, previousAnswers, projectContext);
+  }
+
+  // Default to asking
+  return true;
+}
+
+/**
+ * Evaluate conditional logic for questions
+ */
+function evaluateCondition(condition, previousAnswers, projectContext) {
+  if (condition.requiresAnswer) {
+    // Question depends on a previous answer
+    const required = condition.requiresAnswer;
+    return previousAnswers[required] && previousAnswers[required].trim().length > 0;
+  }
+
+  if (condition.requiresProjectType) {
+    // Question depends on project type
+    return condition.requiresProjectType === projectContext.type;
+  }
+
+  if (condition.requiresFramework) {
+    // Question depends on framework
+    return projectContext.frameworks.includes(condition.requiresFramework);
+  }
+
+  return true;
+}
+
+/**
+ * Get summary of filtering decisions
+ */
+function getFilteringSummary(filterResult, projectContext) {
+  const { summary } = filterResult;
+
+  return {
+    message: `Smart filtering enabled: Showing ${summary.kept} of ${summary.total} questions`,
+    projectType: projectContext.type,
+    frameworks: projectContext.frameworks,
+    timeSaved: `~${summary.timeSaved} minutes`,
+    confidence: projectContext.confidence
+  };
+}
+
+/**
+ * AI-powered relevance scoring (optional enhancement)
+ * @param {Object} question - Question to score
+ * @param {Object} projectContext - Project context
+ * @param {Object} aiClient - AI client instance
+ * @returns {Promise<Object>} AI relevance assessment
+ */
+async function scoreQuestionRelevanceWithAI(question, projectContext, aiClient) {
+  if (!aiClient) {
+    return scoreQuestionRelevance(question, projectContext);
+  }
+
+  try {
+    const prompt = `Analyze if this question is relevant for the given project:
+
+Project Type: ${projectContext.type}
+Frameworks: ${projectContext.frameworks.join(', ')}
+Languages: ${projectContext.languages.join(', ')}
+
+Question: ${question.text}
+Guidance: ${question.guidance || 'None'}
+
+Score relevance 0-100 and explain briefly.
+Respond with JSON: { "score": 0-100, "reason": "why relevant/not relevant" }`;
+
+    const response = await aiClient.sendMessage(prompt, { maxTokens: 150 });
+    const match = response.content.match(/\{[\s\S]*\}/);
+
+    if (match) {
+      const analysis = JSON.parse(match[0]);
+      return {
+        score: analysis.score,
+        reason: analysis.reason,
+        skipReason: analysis.score < 50 ? analysis.reason : 'Low relevance',
+        aiPowered: true
+      };
+    }
+  } catch (error) {
+    // Fallback to rule-based scoring
+    console.warn('AI scoring failed, using rule-based approach');
+  }
+
+  return scoreQuestionRelevance(question, projectContext);
+}
+
+module.exports = {
+  filterQuestions,
+  scoreQuestionRelevance,
+  shouldAskQuestion,
+  getFilteringSummary,
+  scoreQuestionRelevanceWithAI
+};