@iservu-inc/adf-cli 0.3.6 → 0.4.13

package/lib/frameworks/interviewer.js

@@ -2,9 +2,16 @@ const fs = require('fs-extra');
 const path = require('path');
 const inquirer = require('inquirer');
 const chalk = require('chalk');
+const ora = require('ora');
 const { getQuestionsForFramework } = require('./questions');
 const ProgressTracker = require('./progress-tracker');
 const AnswerQualityAnalyzer = require('./answer-quality-analyzer');
+const { analyzeProject, getProjectSummary } = require('../analyzers/project-analyzer');
+const { filterQuestions, getFilteringSummary } = require('../filters/question-filter');
+const { SkipTracker } = require('../learning/skip-tracker');
+const { detectPatterns } = require('../learning/pattern-detector');
+const { updateLearnedRules, getActiveRules, getRuleExplanations } = require('../learning/rule-generator');
+const { getLearningConfig } = require('../learning/storage');
 
 /**
  * Conversational AI Interviewer
@@ -38,6 +45,8 @@ class Interviewer {
 
     this.progressTracker = null;
     this.aiClient = null;  // Will be initialized in start()
+    this.skipTracker = null;  // Will be initialized in start() with project context
+    this.learnedRules = [];  // Will be loaded in start()
   }
 
   generateSessionId() {
@@ -52,14 +61,37 @@ class Interviewer {
     console.log(chalk.gray(`Session: ${this.sessionId}`));
     console.log(chalk.gray(`Files will be saved to: .adf/sessions/${this.sessionId}/\n`));
 
+    // Configure AI if not already configured (new sessions only)
+    if (!this.aiConfig && !this.isResuming) {
+      console.log(chalk.cyan.bold('━'.repeat(60)));
+      console.log(chalk.cyan.bold('\n📋 Block 1: AI Configuration\n'));
+      console.log(chalk.gray('Configure your AI provider for intelligent follow-up questions\n'));
+
+      const { configureAI } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'configureAI',
+          message: 'Configure AI provider now? (Recommended for best experience)',
+          default: true
+        }
+      ]);
+
+      if (configureAI) {
+        const { configureAIProvider } = require('../ai/ai-config');
+        this.aiConfig = await configureAIProvider(this.projectPath);
+      } else {
+        console.log(chalk.yellow('\n💡 You can configure AI later with: adf config\n'));
+      }
+    }
+
     // Initialize AI Client
     if (!this.aiClient && this.aiConfig) {
       const AIClient = require('../ai/ai-client');
       this.aiClient = new AIClient(this.aiConfig);
-      console.log(chalk.green(`✓ AI Provider: ${this.aiConfig.providerName} (${this.aiConfig.model})\n`));
+      console.log(chalk.green(`\n✓ AI Provider: ${this.aiConfig.providerName} (${this.aiConfig.model})\n`));
     } else if (!this.aiConfig) {
-      console.log(chalk.red('\n✖ Error: No AI configuration provided. Cannot start interview.\n'));
-      process.exit(1);
+      console.log(chalk.yellow('⚠️  No AI configuration - continuing without AI assistance\n'));
+      // Allow interview to continue without AI (graceful degradation)
     }
 
     // Create session directory
@@ -67,8 +99,141 @@ class Interviewer {
     await fs.ensureDir(path.join(this.sessionPath, 'qa-responses'));
     await fs.ensureDir(path.join(this.sessionPath, 'outputs'));
 
+    // Analyze project for smart filtering
+    const spinner = ora('Analyzing your project for context...').start();
+    let projectContext = null;
+    let enableSmartFiltering = false;
+
+    try {
+      projectContext = await analyzeProject(this.projectPath);
+      spinner.succeed(chalk.green(`✓ Project analyzed: ${getProjectSummary(projectContext)}`));
+
+      // Initialize skip tracker with project context
+      this.skipTracker = new SkipTracker(this.projectPath, {
+        projectType: projectContext.type,
+        frameworks: projectContext.frameworks,
+        languages: projectContext.languages
+      });
+
+      // Load learning configuration and learned rules
+      const learningConfig = await getLearningConfig(this.projectPath);
+      if (learningConfig.enabled && learningConfig.applyLearnedFilters) {
+        this.learnedRules = await getActiveRules(this.projectPath);
+      }
+
+      if (projectContext.confidence >= 50) {
+        // Show project context
+        console.log(chalk.gray(`\n📊 Project Context:`));
+        console.log(chalk.gray(`   Type: ${projectContext.type}`));
+        if (projectContext.frameworks.length > 0) {
+          console.log(chalk.gray(`   Frameworks: ${projectContext.frameworks.join(', ')}`));
+        }
+        if (projectContext.languages.length > 0) {
+          console.log(chalk.gray(`   Languages: ${projectContext.languages.join(', ')}`));
+        }
+        console.log(chalk.gray(`   Confidence: ${projectContext.confidence}%`));
+
+        // Show learning status
+        if (this.learnedRules.length > 0) {
+          console.log(chalk.gray(`   Learning: ${this.learnedRules.length} learned rule${this.learnedRules.length > 1 ? 's' : ''} active\n`));
+        } else {
+          console.log('');
+        }
+
+        // Ask user if they want smart filtering
+        const { useSmartFiltering } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'useSmartFiltering',
+            message: 'Enable smart filtering to skip irrelevant questions? (Recommended)',
+            default: true
+          }
+        ]);
+
+        enableSmartFiltering = useSmartFiltering;
+
+        // If user enables filtering and we have learned rules, ask about applying them
+        if (enableSmartFiltering && this.learnedRules.length > 0) {
+          const ruleExplanations = getRuleExplanations(this.learnedRules);
+          console.log(chalk.cyan('\n🧠 I\'ve learned from your previous sessions:'));
+          for (const exp of ruleExplanations.slice(0, 3)) {  // Show top 3
+            console.log(chalk.gray(`   • ${exp.message}`));
+          }
+
+          const { applyLearning } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'applyLearning',
+              message: 'Apply learned preferences? (You can manage these in: adf config learning)',
+              default: true
+            }
+          ]);
+
+          if (!applyLearning) {
+            this.learnedRules = [];  // User declined
+            console.log(chalk.gray('\n○ Learning disabled for this session\n'));
+          } else {
+            console.log(chalk.green('\n✓ Learning enabled - applying your preferences\n'));
+          }
+        } else if (enableSmartFiltering) {
+          console.log(chalk.green('\n✓ Smart filtering enabled - I\'ll focus on relevant questions\n'));
+        } else {
+          console.log(chalk.gray('\n○ Smart filtering disabled - I\'ll ask all questions\n'));
+        }
+      } else {
+        spinner.warn(chalk.yellow(`Project analysis incomplete (${projectContext.confidence}% confidence) - asking all questions`));
+        console.log('');
+      }
+    } catch (error) {
+      spinner.fail(chalk.yellow('Could not analyze project - asking all questions'));
+      console.log('');
+      projectContext = { type: 'unknown', frameworks: [], languages: [], confidence: 0 };
+
+      // Still initialize skip tracker for basic tracking
+      this.skipTracker = new SkipTracker(this.projectPath, {
+        projectType: 'unknown',
+        frameworks: [],
+        languages: []
+      });
+    }
+
     // Get questions for framework
-    const questions = getQuestionsForFramework(this.framework);
+    let questions = getQuestionsForFramework(this.framework);
+
+    // Apply smart filtering if enabled
+    let filteringResult = null;
+    if (enableSmartFiltering && projectContext.confidence >= 50) {
+      filteringResult = filterQuestions(questions, projectContext, {
+        enableSmartFiltering: true,
+        minRelevanceScore: 50,
+        aiClient: this.aiClient,
+        learnedRules: this.learnedRules  // Pass learned rules
+      });
+
+      questions = filteringResult.questions.map(q => ({
+        ...q,
+        relevance: q.relevance  // Keep relevance score
+      }));
+
+      // Record filtered questions to skip tracker
+      if (this.skipTracker && filteringResult.skipped.length > 0) {
+        this.skipTracker.recordFilteredQuestions(filteringResult.skipped);
+      }
+
+      // Show filtering summary
+      if (filteringResult.summary.skipped > 0) {
+        console.log(chalk.cyan(`🎯 Smart Filtering Results:`));
+        console.log(chalk.green(`   ✓ ${filteringResult.summary.kept} relevant questions selected`));
+        console.log(chalk.gray(`   ○ ${filteringResult.summary.skipped} questions skipped`));
+
+        // Show learning-based skips if any
+        if (filteringResult.summary.learningActive && filteringResult.summary.skippedByLearning > 0) {
+          console.log(chalk.magenta(`   🧠 ${filteringResult.summary.skippedByLearning} skipped based on your learning history`));
+        }
+
+        console.log(chalk.blue(`   ⏱️  Estimated time saved: ~${filteringResult.summary.timeSaved} minutes\n`));
+      }
+    }
 
     // Group questions into blocks by phase
     const questionBlocks = this.groupQuestionsIntoBlocks(questions);
@@ -133,6 +298,28 @@ class Interviewer {
     // Save session metadata
     await this.saveMetadata();
 
+    // Save learning data and update patterns (Phase 4.2)
+    if (this.skipTracker) {
+      try {
+        // Save skip tracker session
+        await this.skipTracker.saveSession();
+
+        // Detect patterns and update learned rules
+        const learningConfig = await getLearningConfig(this.projectPath);
+        if (learningConfig.enabled && learningConfig.detectPatterns) {
+          const patterns = await detectPatterns(this.projectPath);
+          const updateResult = await updateLearnedRules(this.projectPath, patterns);
+
+          if (updateResult.added > 0) {
+            console.log(chalk.cyan(`\n🧠 Learning System: Detected ${updateResult.added} new pattern${updateResult.added > 1 ? 's' : ''}`));
+            console.log(chalk.gray(`   View with: adf config learning\n`));
+          }
+        }
+      } catch (error) {
+        console.warn(chalk.yellow('⚠️  Could not save learning data:', error.message));
+      }
+    }
+
     // Mark session as complete
     await this.progressTracker.complete();
 
@@ -267,6 +454,11 @@ class Interviewer {
     console.log(chalk.red(`   ✗ Bad: ${question.badExample}`));
     console.log(chalk.gray(`   (Type "skip" to skip remaining questions in this block)\n`));
 
+    // Start tracking time for this question
+    if (this.skipTracker) {
+      this.skipTracker.startQuestion(question.id);
+    }
+
     // Get answer
     const { answer } = await inquirer.prompt([
       {
@@ -283,6 +475,10 @@ class Interviewer {
     ]);
 
     if (answer.toLowerCase() === 'skip') {
+      // Record skip event
+      if (this.skipTracker) {
+        this.skipTracker.recordSkip(question, 'manual');
+      }
       return null; // Signal to skip remaining questions
     }
 
@@ -326,6 +522,14 @@ class Interviewer {
     // Track answer with quality metrics
     await this.progressTracker.answerQuestion(question.id, question.text, answer, qualityMetrics);
 
+    // Record answer to skip tracker (Phase 4.2)
+    if (this.skipTracker) {
+      this.skipTracker.recordAnswer(question, answer, {
+        qualityScore: qualityMetrics.qualityScore,
+        richness: qualityMetrics.isComprehensive ? 'comprehensive' : 'basic'
+      });
+    }
+
     // Check if answer is comprehensive enough to skip follow-ups
     if (qualityMetrics.canSkipFollowUps) {
       console.log(chalk.green('\n✓ Saved\n'));