@iservu-inc/adf-cli 0.3.0 → 0.4.12

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
@@ -13,9 +20,10 @@ const AnswerQualityAnalyzer = require('./answer-quality-analyzer');
  */
 
 class Interviewer {
-  constructor(framework, projectPath, existingSession = null) {
+  constructor(framework, projectPath, existingSession = null, aiConfig = null) {
     this.framework = framework;
     this.projectPath = projectPath;
+    this.aiConfig = aiConfig;  // Store AI configuration
 
     if (existingSession) {
       // Resuming existing session
@@ -24,6 +32,8 @@ class Interviewer {
       this.answers = existingSession.progress.answers || {};
       this.transcript = existingSession.progress.transcript || [];
       this.isResuming = true;
+      // Use stored AI config from session if available
+      this.aiConfig = existingSession.progress.aiConfig || aiConfig;
     } else {
       // New session
       this.sessionId = this.generateSessionId();
@@ -34,6 +44,9 @@ 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() {
@@ -48,19 +61,162 @@ class Interviewer {
     console.log(chalk.gray(`Session: ${this.sessionId}`));
     console.log(chalk.gray(`Files will be saved to: .adf/sessions/${this.sessionId}/\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`));
+    } else if (!this.aiConfig) {
+      console.log(chalk.yellow('\n⚠️  No AI configuration - continuing without AI assistance\n'));
+      // Allow interview to continue without AI (graceful degradation)
+    }
+
     // Create session directory
     await fs.ensureDir(this.sessionPath);
     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);
 
     // Initialize progress tracker
-    this.progressTracker = new ProgressTracker(this.sessionPath, questionBlocks.length, this.framework);
+    this.progressTracker = new ProgressTracker(this.sessionPath, questionBlocks.length, this.framework, this.aiConfig);
     const isResumable = await this.progressTracker.initialize();
 
     if (isResumable && this.isResuming) {
@@ -119,6 +275,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();
 
@@ -250,7 +428,13 @@ class Interviewer {
     // Show guidance
     console.log(chalk.gray(`💡 ${question.guidance}`));
     console.log(chalk.green(`   ✓ Good: ${question.goodExample}`));
-    console.log(chalk.red(`   ✗ Bad: ${question.badExample}\n`));
+    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([
@@ -260,7 +444,7 @@ class Interviewer {
         message: 'Your answer:',
         validate: (input) => {
           if (!input || input.trim().length === 0) {
-            return 'Please provide an answer or type "skip" to skip remaining questions in this block';
+            return 'Please provide an answer or type "skip"';
           }
           return true;
         }
@@ -268,21 +452,61 @@ class Interviewer {
     ]);
 
     if (answer.toLowerCase() === 'skip') {
+      // Record skip event
+      if (this.skipTracker) {
+        this.skipTracker.recordSkip(question, 'manual');
+      }
       return null; // Signal to skip remaining questions
     }
 
-    // Analyze answer quality
-    const qualityMetrics = AnswerQualityAnalyzer.analyze(answer, question);
+    // Analyze answer quality (use AI if available, fallback to heuristic)
+    let qualityMetrics;
+    try {
+      if (this.aiClient) {
+        const aiAnalysis = await this.aiClient.analyzeAnswerQuality(question.text, answer);
+        qualityMetrics = {
+          wordCount: answer.trim().split(/\s+/).length,
+          qualityScore: aiAnalysis.score,
+          isComprehensive: aiAnalysis.score >= 70,
+          canSkipFollowUps: aiAnalysis.score >= 85,
+          issues: aiAnalysis.issues,
+          suggestions: aiAnalysis.suggestions,
+          missingElements: aiAnalysis.missingElements
+        };
+      } else {
+        // Fallback to heuristic analysis
+        qualityMetrics = AnswerQualityAnalyzer.analyze(answer, question);
+      }
+    } catch (error) {
+      // If AI analysis fails, use heuristic
+      console.log(chalk.yellow(`⚠️  AI analysis failed, using fallback method`));
+      qualityMetrics = AnswerQualityAnalyzer.analyze(answer, question);
+    }
 
     // Show quality feedback
-    const feedback = AnswerQualityAnalyzer.getFeedback(qualityMetrics);
-    if (feedback) {
-      console.log(chalk.cyan(`${feedback}`));
+    if (qualityMetrics.issues && qualityMetrics.issues.length > 0 && qualityMetrics.qualityScore < 70) {
+      console.log(chalk.yellow(`\n💡 Quality: ${qualityMetrics.qualityScore}/100`));
+      if (qualityMetrics.suggestions && qualityMetrics.suggestions.length > 0) {
+        console.log(chalk.gray(`   Suggestion: ${qualityMetrics.suggestions[0]}`));
+      }
+    } else {
+      const feedback = AnswerQualityAnalyzer.getFeedback(qualityMetrics);
+      if (feedback) {
+        console.log(chalk.cyan(`${feedback}`));
+      }
     }
 
     // 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'));
@@ -290,7 +514,26 @@ class Interviewer {
     }
 
     // Check if answer needs follow-up
-    const followUp = this.determineFollowUp(question, answer);
+    let followUp = null;
+
+    // Try AI-generated follow-up first
+    if (this.aiClient && qualityMetrics.issues && qualityMetrics.issues.length > 0 && qualityMetrics.qualityScore < 70) {
+      try {
+        const aiFollowUp = await this.aiClient.generateFollowUp(question.text, answer, qualityMetrics.issues);
+        if (aiFollowUp) {
+          followUp = {
+            message: "Let me ask a more specific question:",
+            question: aiFollowUp
+          };
+        }
+      } catch (error) {
+        // If AI fails, use heuristic fallback
+        followUp = this.determineFollowUp(question, answer);
+      }
+    } else {
+      // Use heuristic follow-up
+      followUp = this.determineFollowUp(question, answer);
+    }
 
     if (followUp) {
       console.log(chalk.yellow(`\n🤖 ${followUp.message}\n`));
@@ -308,7 +551,23 @@ class Interviewer {
         const combined = `${answer} | Follow-up: ${followUpAnswer}`;
 
         // Re-analyze combined answer
-        const combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+        let combinedMetrics;
+        try {
+          if (this.aiClient) {
+            const aiAnalysis = await this.aiClient.analyzeAnswerQuality(question.text, combined);
+            combinedMetrics = {
+              wordCount: combined.trim().split(/\s+/).length,
+              qualityScore: aiAnalysis.score,
+              isComprehensive: aiAnalysis.score >= 70,
+              canSkipFollowUps: aiAnalysis.score >= 85
+            };
+          } else {
+            combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+          }
+        } catch {
+          combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+        }
+
         await this.progressTracker.answerQuestion(question.id, question.text, combined, combinedMetrics);
 
         console.log(chalk.green('\n✓ Saved\n'));

package/lib/frameworks/progress-tracker.js

@@ -8,7 +8,7 @@ const chalk = require('chalk');
  */
 
 class ProgressTracker {
-  constructor(sessionPath, totalBlocks, framework = null) {
+  constructor(sessionPath, totalBlocks, framework = null, aiConfig = null) {
     this.sessionPath = sessionPath;
     this.progressFile = path.join(sessionPath, '_progress.json');
     this.progressBackupFile = path.join(sessionPath, '_progress.backup.json');
@@ -17,6 +17,13 @@ class ProgressTracker {
     this.progress = {
       sessionId: path.basename(sessionPath),
       framework: framework, // Store framework for resume
+      aiConfig: aiConfig ? {
+        provider: aiConfig.provider,
+        providerName: aiConfig.providerName,
+        model: aiConfig.model,
+        envVar: aiConfig.envVar
+        // Note: We don't store the API key for security
+      } : null,
       status: 'in-progress',
       startedAt: new Date().toISOString(),
       lastUpdated: new Date().toISOString(),