@iservu-inc/adf-cli 0.8.0 → 0.9.0

package/lib/ai/analysis-config.js

@@ -0,0 +1,418 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+/**
+ * AI Analysis Configuration Manager
+ * Controls performance vs intelligence tradeoffs during interviews
+ */
+
+const DEFAULT_CONFIG = {
+  enabled: true,
+  performanceMode: 'balanced', // 'fast', 'balanced', 'comprehensive'
+  features: {
+    qualityAnalysis: true,      // AI-powered answer quality analysis
+    intelligentReordering: true, // Dynamic question reordering based on answers
+    followUpQuestions: true,     // AI-generated follow-up questions
+    patternDetection: true,      // Learn from answer patterns
+    smartFiltering: true         // Skip redundant questions intelligently
+  }
+};
+
+const PERFORMANCE_MODES = {
+  fast: {
+    name: 'Fast Mode',
+    description: 'Minimal AI analysis - faster but less intelligent',
+    features: {
+      qualityAnalysis: false,
+      intelligentReordering: false,
+      followUpQuestions: false,
+      patternDetection: false,
+      smartFiltering: false
+    }
+  },
+  balanced: {
+    name: 'Balanced Mode',
+    description: 'Moderate AI analysis - good balance of speed and intelligence',
+    features: {
+      qualityAnalysis: true,
+      intelligentReordering: false,
+      followUpQuestions: true,
+      patternDetection: true,
+      smartFiltering: true
+    }
+  },
+  comprehensive: {
+    name: 'Comprehensive Mode',
+    description: 'Full AI analysis - slower but most intelligent',
+    features: {
+      qualityAnalysis: true,
+      intelligentReordering: true,
+      followUpQuestions: true,
+      patternDetection: true,
+      smartFiltering: true
+    }
+  }
+};
+
+/**
+ * Get config file path
+ */
+function getAnalysisConfigPath(projectPath = process.cwd()) {
+  return path.join(projectPath, '.adf', 'analysis-config.json');
+}
+
+/**
+ * Load analysis configuration
+ */
+async function loadAnalysisConfig(projectPath = process.cwd()) {
+  const configPath = getAnalysisConfigPath(projectPath);
+
+  if (!await fs.pathExists(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+
+  try {
+    const config = await fs.readJson(configPath);
+    // Merge with defaults to ensure all keys exist
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      features: {
+        ...DEFAULT_CONFIG.features,
+        ...(config.features || {})
+      }
+    };
+  } catch (error) {
+    console.log(chalk.yellow(`⚠️  Failed to load analysis config: ${error.message}`));
+    return DEFAULT_CONFIG;
+  }
+}
+
+/**
+ * Save analysis configuration
+ */
+async function saveAnalysisConfig(config, projectPath = process.cwd()) {
+  const configPath = getAnalysisConfigPath(projectPath);
+
+  try {
+    await fs.ensureDir(path.dirname(configPath));
+    await fs.writeJson(configPath, config, { spaces: 2 });
+    return true;
+  } catch (error) {
+    console.log(chalk.red(`❌ Failed to save analysis config: ${error.message}`));
+    return false;
+  }
+}
+
+/**
+ * Get feature status summary
+ */
+function getFeatureStatusSummary(config) {
+  const features = config.features;
+  const enabledCount = Object.values(features).filter(v => v).length;
+  const totalCount = Object.keys(features).length;
+
+  if (enabledCount === totalCount) {
+    return chalk.green(`All features enabled (${totalCount}/${totalCount})`);
+  } else if (enabledCount === 0) {
+    return chalk.red(`All features disabled (0/${totalCount})`);
+  } else {
+    return chalk.yellow(`${enabledCount}/${totalCount} features enabled`);
+  }
+}
+
+/**
+ * Interactive configuration menu
+ */
+async function configureAnalysisSettings(projectPath = process.cwd()) {
+  console.log(chalk.cyan.bold('\n🧠 AI Analysis Settings\n'));
+  console.log(chalk.gray('Control the balance between performance and intelligence during interviews\n'));
+
+  // Load current config
+  const currentConfig = await loadAnalysisConfig(projectPath);
+
+  // Main menu
+  while (true) {
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.cyan('\n📊 Current Configuration:\n'));
+    console.log(chalk.gray('Performance Mode: ') + chalk.white.bold(PERFORMANCE_MODES[currentConfig.performanceMode].name));
+    console.log(chalk.gray('Status: ') + getFeatureStatusSummary(currentConfig));
+    console.log('');
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          {
+            name: '🚀 Change Performance Mode (Fast/Balanced/Comprehensive)',
+            value: 'mode',
+            short: 'Change Mode'
+          },
+          {
+            name: '🎛️  Configure Individual Features',
+            value: 'features',
+            short: 'Configure Features'
+          },
+          {
+            name: '📖 View Feature Descriptions',
+            value: 'info',
+            short: 'View Info'
+          },
+          {
+            name: '♻️  Reset to Defaults',
+            value: 'reset',
+            short: 'Reset'
+          },
+          new inquirer.Separator(),
+          {
+            name: chalk.green('✓ Save and Exit'),
+            value: 'save',
+            short: 'Save'
+          },
+          {
+            name: chalk.gray('← Cancel'),
+            value: 'cancel',
+            short: 'Cancel'
+          }
+        ],
+        pageSize: 12
+      }
+    ]);
+
+    if (action === 'save') {
+      const saved = await saveAnalysisConfig(currentConfig, projectPath);
+      if (saved) {
+        console.log(chalk.green.bold('\n✅ AI Analysis settings saved!\n'));
+        console.log(chalk.gray(`Config saved to: ${getAnalysisConfigPath(projectPath)}\n`));
+      }
+      break;
+    } else if (action === 'cancel') {
+      console.log(chalk.yellow('\n✋ Changes discarded.\n'));
+      break;
+    } else if (action === 'mode') {
+      await changePerformanceMode(currentConfig);
+    } else if (action === 'features') {
+      await configureIndividualFeatures(currentConfig);
+    } else if (action === 'info') {
+      await showFeatureInfo();
+    } else if (action === 'reset') {
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Reset all settings to defaults?',
+          default: false
+        }
+      ]);
+
+      if (confirm) {
+        currentConfig.performanceMode = DEFAULT_CONFIG.performanceMode;
+        currentConfig.features = { ...DEFAULT_CONFIG.features };
+        console.log(chalk.green('\n✓ Reset to defaults\n'));
+      }
+    }
+  }
+}
+
+/**
+ * Change performance mode
+ */
+async function changePerformanceMode(currentConfig) {
+  console.log(chalk.gray('\n' + '─'.repeat(60) + '\n'));
+
+  const { mode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'mode',
+      message: 'Select performance mode:',
+      choices: [
+        {
+          name: `${chalk.cyan('⚡ Fast Mode')} - ${PERFORMANCE_MODES.fast.description}`,
+          value: 'fast',
+          short: 'Fast'
+        },
+        {
+          name: `${chalk.yellow('⚖️  Balanced Mode')} - ${PERFORMANCE_MODES.balanced.description}`,
+          value: 'balanced',
+          short: 'Balanced'
+        },
+        {
+          name: `${chalk.green('🎯 Comprehensive Mode')} - ${PERFORMANCE_MODES.comprehensive.description}`,
+          value: 'comprehensive',
+          short: 'Comprehensive'
+        },
+        new inquirer.Separator(),
+        {
+          name: chalk.gray('← Back'),
+          value: 'back'
+        }
+      ]
+    }
+  ]);
+
+  if (mode !== 'back') {
+    currentConfig.performanceMode = mode;
+    currentConfig.features = { ...PERFORMANCE_MODES[mode].features };
+    console.log(chalk.green(`\n✓ Mode changed to: ${PERFORMANCE_MODES[mode].name}\n`));
+  }
+}
+
+/**
+ * Configure individual features
+ */
+async function configureIndividualFeatures(currentConfig) {
+  console.log(chalk.gray('\n' + '─'.repeat(60) + '\n'));
+  console.log(chalk.yellow('⚠️  Changing individual features will set mode to "Custom"\n'));
+
+  const { features } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'features',
+      message: 'Select features to enable (space to toggle, enter to confirm):',
+      choices: [
+        {
+          name: 'AI-Powered Quality Analysis',
+          value: 'qualityAnalysis',
+          checked: currentConfig.features.qualityAnalysis
+        },
+        {
+          name: 'Intelligent Question Reordering',
+          value: 'intelligentReordering',
+          checked: currentConfig.features.intelligentReordering
+        },
+        {
+          name: 'AI-Generated Follow-Up Questions',
+          value: 'followUpQuestions',
+          checked: currentConfig.features.followUpQuestions
+        },
+        {
+          name: 'Pattern Detection & Learning',
+          value: 'patternDetection',
+          checked: currentConfig.features.patternDetection
+        },
+        {
+          name: 'Smart Question Filtering',
+          value: 'smartFiltering',
+          checked: currentConfig.features.smartFiltering
+        }
+      ]
+    }
+  ]);
+
+  // Update features based on selection
+  currentConfig.features.qualityAnalysis = features.includes('qualityAnalysis');
+  currentConfig.features.intelligentReordering = features.includes('intelligentReordering');
+  currentConfig.features.followUpQuestions = features.includes('followUpQuestions');
+  currentConfig.features.patternDetection = features.includes('patternDetection');
+  currentConfig.features.smartFiltering = features.includes('smartFiltering');
+
+  // Check if matches any preset mode
+  let matchedMode = null;
+  for (const [mode, config] of Object.entries(PERFORMANCE_MODES)) {
+    if (JSON.stringify(config.features) === JSON.stringify(currentConfig.features)) {
+      matchedMode = mode;
+      break;
+    }
+  }
+
+  if (matchedMode) {
+    currentConfig.performanceMode = matchedMode;
+    console.log(chalk.green(`\n✓ Features updated (matches ${PERFORMANCE_MODES[matchedMode].name})\n`));
+  } else {
+    currentConfig.performanceMode = 'custom';
+    console.log(chalk.green('\n✓ Features updated (Custom mode)\n'));
+  }
+}
+
+/**
+ * Show feature information
+ */
+async function showFeatureInfo() {
+  console.log(chalk.gray('\n' + '─'.repeat(60)));
+  console.log(chalk.cyan.bold('\n📚 Feature Descriptions\n'));
+
+  const features = [
+    {
+      name: chalk.white.bold('AI-Powered Quality Analysis'),
+      description: 'Uses AI to analyze your answer quality in real-time',
+      impact: 'Provides feedback on answer completeness and suggests improvements',
+      performance: chalk.yellow('Medium impact') + ' - adds 1-2 seconds per answer'
+    },
+    {
+      name: chalk.white.bold('Intelligent Question Reordering'),
+      description: 'Dynamically reorders upcoming questions based on your answers',
+      impact: 'Asks more relevant questions based on what you\'ve already said',
+      performance: chalk.red('High impact') + ' - adds 2-3 seconds per answer'
+    },
+    {
+      name: chalk.white.bold('AI-Generated Follow-Up Questions'),
+      description: 'Generates contextual follow-up questions when answers need clarification',
+      impact: 'Gets more detailed information through targeted follow-ups',
+      performance: chalk.yellow('Medium impact') + ' - adds 1-2 seconds when triggered'
+    },
+    {
+      name: chalk.white.bold('Pattern Detection & Learning'),
+      description: 'Learns from your answer patterns to improve future interviews',
+      impact: 'Remembers your preferences and skips questions you typically skip',
+      performance: chalk.green('Low impact') + ' - minimal performance cost'
+    },
+    {
+      name: chalk.white.bold('Smart Question Filtering'),
+      description: 'Automatically skips questions already answered elsewhere',
+      impact: 'Reduces redundancy by not asking questions you\'ve already covered',
+      performance: chalk.green('Low impact') + ' - minimal performance cost'
+    }
+  ];
+
+  features.forEach((feature, i) => {
+    console.log(chalk.cyan(`${i + 1}. ${feature.name}`));
+    console.log(chalk.gray(`   ${feature.description}`));
+    console.log(chalk.gray(`   Impact: ${feature.impact}`));
+    console.log(chalk.gray(`   Performance: ${feature.performance}`));
+    console.log('');
+  });
+
+  console.log(chalk.gray('─'.repeat(60)));
+
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: 'Press Enter to continue...',
+      default: ''
+    }
+  ]);
+
+  console.log('');
+}
+
+/**
+ * Get feature status for display in config menu
+ */
+async function getAnalysisStatus(projectPath = process.cwd()) {
+  const config = await loadAnalysisConfig(projectPath);
+  const mode = PERFORMANCE_MODES[config.performanceMode];
+  const enabledCount = Object.values(config.features).filter(v => v).length;
+
+  return {
+    configured: true,
+    mode: config.performanceMode,
+    modeName: mode ? mode.name : 'Custom',
+    enabledCount: enabledCount,
+    totalCount: Object.keys(config.features).length
+  };
+}
+
+module.exports = {
+  loadAnalysisConfig,
+  saveAnalysisConfig,
+  configureAnalysisSettings,
+  getAnalysisStatus,
+  getAnalysisConfigPath,
+  DEFAULT_CONFIG,
+  PERFORMANCE_MODES
+};

package/lib/commands/config.js

@@ -3,6 +3,7 @@ const chalk = require('chalk');
 const fs = require('fs-extra');
 const path = require('path');
 const { configureAIProvider, getEnvFilePath, loadEnvFile } = require('../ai/ai-config');
+const { configureAnalysisSettings, getAnalysisStatus } = require('../ai/analysis-config');
 const LearningManager = require('../learning/learning-manager');
 const { getLearningStats, getLearningConfig } = require('../learning/storage');
 
@@ -15,6 +16,11 @@ const CONFIG_CATEGORIES = {
     description: 'Configure AI provider (Anthropic, OpenAI, Google Gemini, OpenRouter)',
     value: 'ai-provider'
   },
+  AI_ANALYSIS: {
+    name: 'AI Analysis Settings',
+    description: 'Control AI analysis features and performance modes',
+    value: 'ai-analysis'
+  },
   IDE_DEPLOYMENT: {
     name: 'IDE Deployment',
     description: 'Deploy requirements to IDEs (Windsurf, Cursor, VSCode, etc.)',
@@ -110,6 +116,17 @@ function displayLearningStatus(status) {
   }
 }
 
+/**
+ * Display configuration status for AI Analysis
+ */
+function displayAnalysisStatus(status) {
+  if (status.configured) {
+    return `${chalk.green('✓ Configured')} ${chalk.gray(`(${status.modeName}, ${status.enabledCount}/${status.totalCount} features)`)}`;
+  } else {
+    return chalk.gray('○ Default settings');
+  }
+}
+
 /**
  * Main config command
  */
@@ -120,6 +137,7 @@ async function config() {
 
   // Check configuration status for all categories
   const aiStatus = await isAIConfigured(cwd);
+  const analysisStatus = await getAnalysisStatus(cwd);
   const deploymentStatus = await getDeploymentStatus(cwd);
   const learningStatus = await getLearningStatus(cwd);
 
@@ -130,6 +148,11 @@ async function config() {
       value: CONFIG_CATEGORIES.AI_PROVIDER.value,
       short: CONFIG_CATEGORIES.AI_PROVIDER.name
     },
+    {
+      name: `${CONFIG_CATEGORIES.AI_ANALYSIS.name} - ${displayAnalysisStatus(analysisStatus)}`,
+      value: CONFIG_CATEGORIES.AI_ANALYSIS.value,
+      short: CONFIG_CATEGORIES.AI_ANALYSIS.name
+    },
     {
       name: `${CONFIG_CATEGORIES.IDE_DEPLOYMENT.name} - ${displayDeploymentStatus(deploymentStatus)}`,
       value: CONFIG_CATEGORIES.IDE_DEPLOYMENT.value,
@@ -168,6 +191,10 @@ async function config() {
       await configureAIProviderCategory(cwd, aiStatus);
       break;
 
+    case 'ai-analysis':
+      await configureAnalysisSettings(cwd);
+      break;
+
     case 'ide-deployment':
       await configureIDEDeploymentCategory(cwd, deploymentStatus);
       break;

package/lib/frameworks/interviewer.js

@@ -63,6 +63,16 @@ class Interviewer {
     console.log(chalk.gray(`Session: ${this.sessionId}`));
     console.log(chalk.gray(`Files will be saved to: .adf/sessions/${this.sessionId}/\n`));
 
+    // Load AI Analysis configuration
+    const { loadAnalysisConfig } = require('../ai/analysis-config');
+    this.analysisConfig = await loadAnalysisConfig(this.projectPath);
+
+    // Show performance mode
+    const modeEmoji = this.analysisConfig.performanceMode === 'fast' ? '⚡' :
+                      this.analysisConfig.performanceMode === 'comprehensive' ? '🎯' : '⚖️';
+    console.log(chalk.gray(`${modeEmoji} Analysis Mode: ${this.analysisConfig.performanceMode}`));
+    console.log(chalk.gray(`   (Configure with: adf config)\n`));
+
     // Setup global Ctrl+C handler for graceful exit from anywhere
     const exitHandler = async () => {
       console.log(chalk.yellow('\n\n💾 Saving progress and exiting...'));
@@ -135,82 +145,101 @@ class Interviewer {
       }
     }
 
-    // Initialize AI Client
-    if (!this.aiClient && this.aiConfig) {
+    // Initialize AI Client (only if quality analysis or follow-ups are enabled)
+    const needsAI = this.analysisConfig.features.qualityAnalysis ||
+                    this.analysisConfig.features.followUpQuestions ||
+                    this.analysisConfig.features.intelligentReordering;
+
+    if (!this.aiClient && this.aiConfig && needsAI) {
       const AIClient = require('../ai/ai-client');
       this.aiClient = new AIClient(this.aiConfig);
       console.log(chalk.green(`\n✓ AI Provider: ${this.aiConfig.providerName} (${this.aiConfig.model})\n`));
-    } else if (!this.aiConfig) {
-      console.log(chalk.yellow('⚠️  No AI configuration - continuing without AI assistance\n'));
-      // Allow interview to continue without AI (graceful degradation)
+    } else if (!this.aiConfig && needsAI) {
+      console.log(chalk.yellow('⚠️  No AI configuration - AI features disabled\n'));
+      // Disable AI-dependent features
+      this.analysisConfig.features.qualityAnalysis = false;
+      this.analysisConfig.features.followUpQuestions = false;
+      this.analysisConfig.features.intelligentReordering = false;
+    } else if (!needsAI) {
+      console.log(chalk.gray('ℹ️  AI features disabled by configuration\n'));
     }
 
     // Initialize Dynamic Pipeline (Intelligent Question System)
-    this.dynamicPipeline = new DynamicPipeline(this.sessionPath, this.aiClient, {
-      enabled: true,
-      minSkipConfidence: 75,
-      showAnalysis: true,
-      verbose: false
-    });
-    await this.dynamicPipeline.initialize();
+    // Only enable if intelligentReordering is enabled
+    if (this.analysisConfig.features.intelligentReordering) {
+      this.dynamicPipeline = new DynamicPipeline(this.sessionPath, this.aiClient, {
+        enabled: true,
+        minSkipConfidence: 75,
+        showAnalysis: true,
+        verbose: false
+      });
+      await this.dynamicPipeline.initialize();
+    } else {
+      // Create disabled pipeline
+      this.dynamicPipeline = null;
+    }
 
     // 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();
+    // Analyze project for smart filtering (only if smart filtering is enabled)
     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
-      });
+    if (this.analysisConfig.features.smartFiltering) {
+      const spinner = ora('Analyzing your project for context...').start();
 
-      // Load learning configuration and learned rules
-      const learningConfig = await getLearningConfig(this.projectPath);
-      if (learningConfig.enabled && learningConfig.applyLearnedFilters) {
-        this.learnedRules = await getActiveRules(this.projectPath);
-      }
+      try {
+        projectContext = await analyzeProject(this.projectPath);
+        spinner.succeed(chalk.green(`✓ Project analyzed: ${getProjectSummary(projectContext)}`));
+
+        // Initialize skip tracker with project context (only if pattern detection enabled)
+        if (this.analysisConfig.features.patternDetection) {
+          this.skipTracker = new SkipTracker(this.projectPath, {
+            projectType: projectContext.type,
+            frameworks: projectContext.frameworks,
+            languages: projectContext.languages
+          });
 
-      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(', ')}`));
+          // Load learning configuration and learned rules
+          const learningConfig = await getLearningConfig(this.projectPath);
+          if (learningConfig.enabled && learningConfig.applyLearnedFilters) {
+            this.learnedRules = await getActiveRules(this.projectPath);
+          }
         }
-        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('');
-        }
+        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}%`));
 
-        // 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
+          // Show learning status
+          if (this.learnedRules && this.learnedRules.length > 0) {
+            console.log(chalk.gray(`   Learning: ${this.learnedRules.length} learned rule${this.learnedRules.length > 1 ? 's' : ''} active\n`));
+          } else {
+            console.log('');
           }
-        ]);
 
-        enableSmartFiltering = useSmartFiltering;
+          // 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) {
@@ -637,10 +666,10 @@ class Interviewer {
       process.exit(0);
     }
 
-    // Analyze answer quality (use AI if available, fallback to heuristic)
+    // Analyze answer quality (use AI if enabled and available, fallback to heuristic)
     let qualityMetrics;
     try {
-      if (this.aiClient) {
+      if (this.analysisConfig.features.qualityAnalysis && this.aiClient) {
         const aiAnalysis = await this.aiClient.analyzeAnswerQuality(question.text, answer);
         qualityMetrics = {
           wordCount: answer.trim().split(/\s+/).length,
@@ -661,16 +690,18 @@ class Interviewer {
       qualityMetrics = AnswerQualityAnalyzer.analyze(answer, question);
     }
 
-    // Show quality 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}`));
+    // Show quality feedback (only if quality analysis is enabled)
+    if (this.analysisConfig.features.qualityAnalysis) {
+      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}`));
+        }
       }
     }
 
@@ -696,26 +727,28 @@ class Interviewer {
       return answer;
     }
 
-    // Check if answer needs follow-up
+    // Check if answer needs follow-up (only if follow-up questions are enabled)
     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
-          };
+    if (this.analysisConfig.features.followUpQuestions) {
+      // 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);
         }
-      } catch (error) {
-        // If AI fails, use heuristic fallback
+      } else {
+        // Use heuristic follow-up
         followUp = this.determineFollowUp(question, answer);
       }
-    } else {
-      // Use heuristic follow-up
-      followUp = this.determineFollowUp(question, answer);
     }
 
     if (followUp) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework with multi-provider AI support",
   "main": "index.js",
   "bin": {