@iservu-inc/adf-cli 0.4.35 → 0.5.0

package/lib/analysis/question-mapper.js

@@ -0,0 +1,293 @@
+/**
+ * Question Mapper
+ *
+ * Maps each question to the information types it's designed to gather.
+ * This allows the system to determine which questions can be skipped
+ * if that information has already been extracted from previous answers.
+ *
+ * For example:
+ * - "What are you building?" -> [PROJECT_GOAL, TECH_STACK, FEATURES, PLATFORM]
+ * - "What tech stack will you use?" -> [TECH_STACK, ARCHITECTURE]
+ * - "Who are your users?" -> [TARGET_USERS, PROJECT_GOAL]
+ */
+class QuestionMapper {
+  constructor() {
+    // Information types (should match AnswerAnalyzer)
+    this.INFO_TYPES = {
+      TECH_STACK: 'tech_stack',
+      ARCHITECTURE: 'architecture',
+      PROJECT_GOAL: 'project_goal',
+      TARGET_USERS: 'target_users',
+      FEATURES: 'features',
+      CONSTRAINTS: 'constraints',
+      TIMELINE: 'timeline',
+      TEAM_SIZE: 'team_size',
+      PLATFORM: 'platform',
+      DEPLOYMENT: 'deployment',
+      SECURITY: 'security',
+      PERFORMANCE: 'performance'
+    };
+
+    // Build mappings based on question patterns
+    this.buildMappings();
+  }
+
+  /**
+   * Build mappings for common question patterns
+   */
+  buildMappings() {
+    this.patterns = [
+      // Goal/Purpose questions
+      {
+        keywords: ['goal', 'building', 'purpose', 'create', 'develop', 'project'],
+        types: [this.INFO_TYPES.PROJECT_GOAL],
+        priority: 1 // Higher priority = more fundamental question
+      },
+
+      // Tech Stack questions
+      {
+        keywords: ['tech', 'stack', 'technology', 'framework', 'language', 'tools'],
+        types: [this.INFO_TYPES.TECH_STACK],
+        priority: 2
+      },
+
+      // Architecture questions
+      {
+        keywords: ['architecture', 'structure', 'design', 'organize', 'components'],
+        types: [this.INFO_TYPES.ARCHITECTURE],
+        priority: 2
+      },
+
+      // User questions
+      {
+        keywords: ['users', 'audience', 'customers', 'personas', 'who will use'],
+        types: [this.INFO_TYPES.TARGET_USERS],
+        priority: 3
+      },
+
+      // Feature questions
+      {
+        keywords: ['features', 'functionality', 'capabilities', 'do', 'functions'],
+        types: [this.INFO_TYPES.FEATURES],
+        priority: 3
+      },
+
+      // Platform questions
+      {
+        keywords: ['platform', 'web', 'mobile', 'desktop', 'where', 'run'],
+        types: [this.INFO_TYPES.PLATFORM],
+        priority: 2
+      },
+
+      // Timeline questions
+      {
+        keywords: ['timeline', 'deadline', 'when', 'schedule', 'launch'],
+        types: [this.INFO_TYPES.TIMELINE],
+        priority: 4
+      },
+
+      // Team questions
+      {
+        keywords: ['team', 'developers', 'people', 'resources', 'who'],
+        types: [this.INFO_TYPES.TEAM_SIZE],
+        priority: 4
+      },
+
+      // Constraints questions
+      {
+        keywords: ['constraints', 'limitations', 'requirements', 'must', 'cannot'],
+        types: [this.INFO_TYPES.CONSTRAINTS],
+        priority: 3
+      },
+
+      // Deployment questions
+      {
+        keywords: ['deploy', 'hosting', 'infrastructure', 'production', 'server'],
+        types: [this.INFO_TYPES.DEPLOYMENT, this.INFO_TYPES.TECH_STACK],
+        priority: 4
+      },
+
+      // Security questions
+      {
+        keywords: ['security', 'authentication', 'authorization', 'secure', 'privacy'],
+        types: [this.INFO_TYPES.SECURITY],
+        priority: 3
+      },
+
+      // Performance questions
+      {
+        keywords: ['performance', 'speed', 'scale', 'optimization', 'fast'],
+        types: [this.INFO_TYPES.PERFORMANCE],
+        priority: 4
+      }
+    ];
+  }
+
+  /**
+   * Map a question to information types it gathers
+   *
+   * @param {Object} question - Question object with id and text
+   * @returns {Object} - { types: [], priority: number, confidence: number }
+   */
+  mapQuestion(question) {
+    const questionText = (question.text || '').toLowerCase();
+    const questionId = (question.id || '').toLowerCase();
+    const combinedText = `${questionText} ${questionId}`;
+
+    const matchedTypes = new Set();
+    let highestPriority = 5; // Lower number = higher priority
+
+    // Check each pattern
+    this.patterns.forEach(pattern => {
+      const matches = pattern.keywords.some(keyword =>
+        combinedText.includes(keyword)
+      );
+
+      if (matches) {
+        pattern.types.forEach(type => matchedTypes.add(type));
+        if (pattern.priority < highestPriority) {
+          highestPriority = pattern.priority;
+        }
+      }
+    });
+
+    // If no matches found, make a best guess based on question structure
+    if (matchedTypes.size === 0) {
+      matchedTypes.add(this.INFO_TYPES.PROJECT_GOAL); // Default assumption
+    }
+
+    return {
+      types: Array.from(matchedTypes),
+      priority: highestPriority,
+      confidence: matchedTypes.size > 0 ? 85 : 40 // How confident are we in this mapping
+    };
+  }
+
+  /**
+   * Check if a question's information types are already satisfied in the knowledge graph
+   *
+   * @param {Object} question - Question object
+   * @param {KnowledgeGraph} knowledgeGraph - Knowledge graph instance
+   * @param {number} minConfidence - Minimum confidence threshold (default 70)
+   * @returns {Object} - { canSkip: boolean, reason: string, satisfiedTypes: [], missingTypes: [] }
+   */
+  canSkipQuestion(question, knowledgeGraph, minConfidence = 70) {
+    const mapping = this.mapQuestion(question);
+    const satisfiedTypes = [];
+    const missingTypes = [];
+
+    mapping.types.forEach(type => {
+      if (knowledgeGraph.has(type, minConfidence)) {
+        satisfiedTypes.push({
+          type,
+          confidence: knowledgeGraph.getConfidence(type)
+        });
+      } else {
+        missingTypes.push(type);
+      }
+    });
+
+    // Can skip if ALL required types are satisfied
+    const canSkip = missingTypes.length === 0 && satisfiedTypes.length > 0;
+
+    let reason = '';
+    if (canSkip) {
+      const typeLabels = satisfiedTypes.map(t => t.type.replace(/_/g, ' ')).join(', ');
+      const avgConfidence = Math.round(
+        satisfiedTypes.reduce((sum, t) => sum + t.confidence, 0) / satisfiedTypes.length
+      );
+      reason = `Already have: ${typeLabels} (${avgConfidence}% confidence)`;
+    } else if (satisfiedTypes.length > 0) {
+      const partial = satisfiedTypes.map(t => t.type.replace(/_/g, ' ')).join(', ');
+      const missing = missingTypes.map(t => t.replace(/_/g, ' ')).join(', ');
+      reason = `Partial: have ${partial}, need ${missing}`;
+    }
+
+    return {
+      canSkip,
+      reason,
+      satisfiedTypes,
+      missingTypes,
+      questionPriority: mapping.priority
+    };
+  }
+
+  /**
+   * Reorder questions based on knowledge graph
+   * Prioritize questions that gather missing information
+   *
+   * @param {Array} questions - Array of question objects
+   * @param {KnowledgeGraph} knowledgeGraph - Knowledge graph instance
+   * @returns {Array} - Reordered questions with skip recommendations
+   */
+  reorderQuestions(questions, knowledgeGraph) {
+    const scoredQuestions = questions.map(question => {
+      const skipInfo = this.canSkipQuestion(question, knowledgeGraph);
+
+      // Calculate relevance score
+      // Higher score = more important to ask
+      let score = 100;
+
+      if (skipInfo.canSkip) {
+        // Can skip entirely
+        score = 0;
+      } else if (skipInfo.satisfiedTypes.length > 0) {
+        // Partially satisfied, lower priority
+        const percentSatisfied = skipInfo.satisfiedTypes.length /
+          (skipInfo.satisfiedTypes.length + skipInfo.missingTypes.length);
+        score = Math.round((1 - percentSatisfied) * 100);
+      } else {
+        // Not satisfied at all, full priority
+        score = 100;
+      }
+
+      // Boost score for high-priority questions
+      if (skipInfo.questionPriority === 1) {
+        score = Math.min(100, score * 1.3);
+      } else if (skipInfo.questionPriority === 2) {
+        score = Math.min(100, score * 1.15);
+      }
+
+      return {
+        question,
+        skipInfo,
+        relevanceScore: score
+      };
+    });
+
+    // Sort by relevance score (highest first)
+    scoredQuestions.sort((a, b) => b.relevanceScore - a.relevanceScore);
+
+    return scoredQuestions;
+  }
+
+  /**
+   * Get statistics about question mappings
+   */
+  getStats(questions, knowledgeGraph) {
+    let canSkip = 0;
+    let partial = 0;
+    let needed = 0;
+
+    questions.forEach(question => {
+      const skipInfo = this.canSkipQuestion(question, knowledgeGraph);
+      if (skipInfo.canSkip) {
+        canSkip++;
+      } else if (skipInfo.satisfiedTypes.length > 0) {
+        partial++;
+      } else {
+        needed++;
+      }
+    });
+
+    return {
+      total: questions.length,
+      canSkip,
+      partial,
+      needed,
+      estimatedTimeSaved: canSkip * 1.5 // Assume 1.5 min per question
+    };
+  }
+}
+
+module.exports = QuestionMapper;

package/lib/commands/config.js

@@ -15,14 +15,16 @@ const CONFIG_CATEGORIES = {
     description: 'Configure AI provider (Anthropic, OpenAI, Google Gemini, OpenRouter)',
     value: 'ai-provider'
   },
+  IDE_DEPLOYMENT: {
+    name: 'IDE Deployment',
+    description: 'Deploy requirements to IDEs (Windsurf, Cursor, VSCode, etc.)',
+    value: 'ide-deployment'
+  },
   LEARNING_SYSTEM: {
     name: 'Learning System',
     description: 'Manage interview learning data and preferences',
     value: 'learning'
   }
-  // Future config categories can be added here:
-  // PROJECT_SETTINGS: { name: 'Project Settings', description: '...', value: 'project' },
-  // DEPLOYMENT: { name: 'Deployment Preferences', description: '...', value: 'deployment' },
 };
 
 /**
@@ -118,6 +120,7 @@ async function config() {
 
   // Check configuration status for all categories
   const aiStatus = await isAIConfigured(cwd);
+  const deploymentStatus = await getDeploymentStatus(cwd);
   const learningStatus = await getLearningStatus(cwd);
 
   // Build choices with status indicators
@@ -127,6 +130,11 @@ async function config() {
       value: CONFIG_CATEGORIES.AI_PROVIDER.value,
       short: CONFIG_CATEGORIES.AI_PROVIDER.name
     },
+    {
+      name: `${CONFIG_CATEGORIES.IDE_DEPLOYMENT.name} - ${displayDeploymentStatus(deploymentStatus)}`,
+      value: CONFIG_CATEGORIES.IDE_DEPLOYMENT.value,
+      short: CONFIG_CATEGORIES.IDE_DEPLOYMENT.name
+    },
     {
       name: `${CONFIG_CATEGORIES.LEARNING_SYSTEM.name} - ${displayLearningStatus(learningStatus)}`,
       value: CONFIG_CATEGORIES.LEARNING_SYSTEM.value,
@@ -160,11 +168,14 @@ async function config() {
       await configureAIProviderCategory(cwd, aiStatus);
       break;
 
+    case 'ide-deployment':
+      await configureIDEDeploymentCategory(cwd, deploymentStatus);
+      break;
+
     case 'learning':
       await configureLearningCategory(cwd, learningStatus);
       break;
 
-    // Future categories will be handled here
     default:
       console.log(chalk.red('\n❌ Configuration category not implemented yet.\n'));
   }
@@ -207,6 +218,118 @@ async function configureAIProviderCategory(cwd, aiStatus) {
   }
 }
 
+/**
+ * Check deployment status
+ */
+async function getDeploymentStatus(projectPath = process.cwd()) {
+  const adfDir = path.join(projectPath, '.adf');
+
+  if (!await fs.pathExists(adfDir)) {
+    return { hasSession: false, tools: [] };
+  }
+
+  // Check for latest session
+  const sessionsDir = path.join(adfDir, 'sessions');
+  if (!await fs.pathExists(sessionsDir)) {
+    return { hasSession: false, tools: [] };
+  }
+
+  const sessions = await fs.readdir(sessionsDir);
+  if (sessions.length === 0) {
+    return { hasSession: false, tools: [] };
+  }
+
+  // Check which IDE tools have been deployed
+  const deployedTools = [];
+  const ideMarkers = [
+    { name: 'Windsurf', path: '.windsurf/rules' },
+    { name: 'Cursor', path: '.cursor/rules' },
+    { name: 'VSCode', path: '.github/copilot-instructions.md' },
+    { name: 'Claude Code', path: '.claude/commands' }
+  ];
+
+  for (const marker of ideMarkers) {
+    if (await fs.pathExists(path.join(projectPath, marker.path))) {
+      deployedTools.push(marker.name);
+    }
+  }
+
+  return {
+    hasSession: true,
+    sessionCount: sessions.length,
+    tools: deployedTools
+  };
+}
+
+/**
+ * Display deployment status
+ */
+function displayDeploymentStatus(status) {
+  if (status.hasSession && status.tools.length > 0) {
+    return `${chalk.green('✓ Deployed')} ${chalk.gray(`(${status.tools.join(', ')})`)}`;
+  } else if (status.hasSession) {
+    return chalk.yellow('○ Session exists, not deployed');
+  } else {
+    return chalk.gray('○ No sessions yet');
+  }
+}
+
+/**
+ * Configure IDE Deployment category
+ */
+async function configureIDEDeploymentCategory(cwd, deploymentStatus) {
+  const { deployToTool } = require('./deploy');
+
+  console.log(chalk.gray('\n' + '─'.repeat(60) + '\n'));
+
+  if (!deploymentStatus.hasSession) {
+    console.log(chalk.yellow('⚠️  No ADF sessions found.\n'));
+    console.log(chalk.gray('You need to run `adf init` first to create requirements.'));
+    console.log(chalk.gray('Then you can deploy them to your IDE.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan(`Found ${deploymentStatus.sessionCount} session(s)\n`));
+
+  if (deploymentStatus.tools.length > 0) {
+    console.log(chalk.green('✓ Already deployed to:'));
+    deploymentStatus.tools.forEach(tool => {
+      console.log(chalk.gray(`  • ${tool}`));
+    });
+    console.log('');
+  }
+
+  // Ask which tools to deploy to
+  const { tools } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'tools',
+      message: 'Select IDEs to deploy to (space to select, enter to confirm):',
+      choices: [
+        { name: 'Windsurf', value: 'windsurf', checked: deploymentStatus.tools.includes('Windsurf') },
+        { name: 'Cursor', value: 'cursor', checked: deploymentStatus.tools.includes('Cursor') },
+        { name: 'VSCode/Copilot', value: 'vscode', checked: deploymentStatus.tools.includes('VSCode') },
+        { name: 'Claude Code', value: 'claude-code', checked: deploymentStatus.tools.includes('Claude Code') },
+        { name: 'Gemini CLI', value: 'gemini-cli' }
+      ],
+      validate: (answer) => {
+        if (answer.length === 0) {
+          return 'You must choose at least one IDE.';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  // Deploy to each selected tool
+  for (const tool of tools) {
+    console.log('');
+    await deployToTool(tool, { silent: false });
+  }
+
+  console.log(chalk.green.bold('\n✅ Deployment complete!\n'));
+}
+
 /**
  * Configure Learning System category
  */

package/lib/frameworks/interviewer.js

@@ -12,6 +12,7 @@ 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');
+const DynamicPipeline = require('../analysis/dynamic-pipeline');
 
 /**
  * Conversational AI Interviewer
@@ -47,6 +48,7 @@ class Interviewer {
     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()
+    this.dynamicPipeline = null;  // Will be initialized in start() with AI client
   }
 
   generateSessionId() {
@@ -125,6 +127,15 @@ class Interviewer {
       // Allow interview to continue without AI (graceful degradation)
     }
 
+    // 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();
+
     // Create session directory
     await fs.ensureDir(this.sessionPath);
     await fs.ensureDir(path.join(this.sessionPath, 'qa-responses'));
@@ -318,6 +329,11 @@ class Interviewer {
 
       // Save block answers
       await this.saveBlockAnswers(block);
+
+      // Show knowledge summary every 2 blocks
+      if (this.dynamicPipeline && (i + 1) % 2 === 0 && i + 1 < questionBlocks.length) {
+        this.dynamicPipeline.displayKnowledgeSummary();
+      }
     }
 
     // Generate framework outputs
@@ -354,6 +370,11 @@ class Interviewer {
     // Mark session as complete
     await this.progressTracker.complete();
 
+    // Display Dynamic Pipeline stats
+    if (this.dynamicPipeline) {
+      this.dynamicPipeline.displayFinalStats();
+    }
+
     console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
     console.log(chalk.cyan(`📁 Session saved to: .adf/sessions/${this.sessionId}/\n`));
 
@@ -470,9 +491,38 @@ class Interviewer {
   async askBlockQuestions(block, currentBlock, totalBlocks) {
     const blockAnswers = {};
     let questionsAnswered = 0;
+    let questionsSkipped = 0;
 
     for (let i = 0; i < block.questions.length; i++) {
       const question = block.questions[i];
+
+      // Check if we should skip this question based on knowledge graph
+      if (this.dynamicPipeline) {
+        const skipCheck = this.dynamicPipeline.shouldSkipQuestion(question);
+
+        if (skipCheck.shouldSkip) {
+          console.log(chalk.cyan(`Question ${i + 1}/${block.questions.length}`) + chalk.gray(` (Block ${currentBlock}/${totalBlocks})`) + '\n');
+          console.log(chalk.gray('━'.repeat(60)));
+          console.log(chalk.yellow(`\n⏭️  Skipping: ${question.text}`));
+          console.log(chalk.green(`   ✓ ${skipCheck.reason}\n`));
+          console.log(chalk.gray('━'.repeat(60)) + '\n');
+
+          questionsSkipped++;
+
+          // Log skip to transcript
+          this.transcript.push({
+            type: 'question-skipped-intelligent',
+            question: question.text,
+            questionId: question.id,
+            reason: skipCheck.reason,
+            confidence: skipCheck.confidence,
+            timestamp: new Date().toISOString()
+          });
+
+          continue;
+        }
+      }
+
       const answer = await this.askQuestion(question, i + 1, block.questions.length, currentBlock, totalBlocks);
 
       if (answer === null) {
@@ -494,6 +544,10 @@ class Interviewer {
       });
     }
 
+    if (questionsSkipped > 0 && questionsAnswered > 0) {
+      console.log(chalk.cyan(`\n📊 Block Summary: ${questionsAnswered} answered, ${questionsSkipped} intelligently skipped\n`));
+    }
+
     return questionsAnswered;
   }
 
@@ -583,6 +637,11 @@ class Interviewer {
       });
     }
 
+    // Process answer with Dynamic Pipeline (Phase 4.4)
+    if (this.dynamicPipeline) {
+      await this.dynamicPipeline.processAnswer(question.id, question.text, answer);
+    }
+
     // Check if answer is comprehensive enough to skip follow-ups
     if (qualityMetrics.canSkipFollowUps) {
       console.log(chalk.green('\n✓ Saved\n'));

package/lib/generators/cursor-generator.js

@@ -42,7 +42,7 @@ class CursorGenerator extends ToolConfigGenerator {
     await this.ensureDir('.cursor');
 
     const content = this.framework === 'rapid' ?
-      this.generateRulesPRP() :
+      await this.generateRulesPRP() :
       this.framework === 'balanced' ?
       this.generateRulesBalanced() :
       this.generateRulesBMAD();
@@ -50,9 +50,27 @@ class CursorGenerator extends ToolConfigGenerator {
     return await this.writeToProject('.cursor/rules', content);
   }
 
-  generateRulesPRP() {
+  async generateRulesPRP() {
     const projectName = this.getProjectName();
     const sections = this.outputs.sections || {};
+    const answers = await this.loadSessionAnswers();
+
+    // Extract content with fallback to answers
+    let goal = sections['1._goal_definition'] || sections['goal_definition'];
+    let techStack = this.extractTechStack(sections);
+    let blueprint = sections['4._implementation_blueprint'] || sections['implementation_blueprint'];
+    let validation = sections['5._validation'] || sections['validation'];
+
+    // Fallback to extracted answers if sections are empty
+    if (!goal || goal.length < 20) {
+      const whatBuilding = this.extractWhatBuildingFromAnswers(answers);
+      if (whatBuilding) goal = whatBuilding;
+    }
+
+    if (!techStack || techStack.includes('See framework')) {
+      const techFromAnswers = this.extractTechStackFromAnswers(answers);
+      if (techFromAnswers) techStack = techFromAnswers;
+    }
 
     return `# ${projectName} - Cursor Rules
 
@@ -60,19 +78,19 @@ You are a senior developer working on ${projectName}.
 
 ## Project Goal
 
-${sections['1._goal_definition'] || sections['goal_definition'] || 'See PRP for details'}
+${goal || 'See PRP for complete details'}
 
 ## Tech Stack
 
-${this.extractTechStack(sections)}
+${techStack || 'See PRP for tech stack details'}
 
 ## Implementation Blueprint
 
-${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || 'See PRP for details'}
+${blueprint || 'See PRP for implementation details'}
 
 ## Success Criteria
 
-${sections['5._validation'] || sections['validation'] || 'See PRP for validation criteria'}
+${validation || 'See PRP for validation criteria'}
 
 ## Before Implementing Features
 
@@ -369,6 +387,59 @@ You can delete this .cursorrules file.
       return '0.3.0';
     }
   }
+
+  /**
+   * Load session answers from _progress.json
+   */
+  async loadSessionAnswers() {
+    const fs = require('fs-extra');
+    const path = require('path');
+    const progressPath = path.join(this.sessionPath, '_progress.json');
+
+    try {
+      if (await fs.pathExists(progressPath)) {
+        const progress = await fs.readJson(progressPath);
+        return progress.answers || {};
+      }
+    } catch (error) {
+      // Fall back to empty if can't load
+    }
+
+    return {};
+  }
+
+  /**
+   * Extract tech stack from any answer
+   */
+  extractTechStackFromAnswers(answers) {
+    for (const [questionId, answer] of Object.entries(answers)) {
+      if (typeof answer === 'string') {
+        const lower = answer.toLowerCase();
+        if (lower.includes('react') || lower.includes('vue') || lower.includes('angular') ||
+            lower.includes('node') || lower.includes('python') || lower.includes('next') ||
+            lower.includes('postgres') || lower.includes('mongo') || lower.includes('mysql')) {
+          return answer;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Extract "what are you building" from any answer
+   */
+  extractWhatBuildingFromAnswers(answers) {
+    for (const [questionId, answer] of Object.entries(answers)) {
+      if (questionId.toLowerCase().includes('goal') ||
+          questionId.toLowerCase().includes('building') ||
+          questionId.toLowerCase().includes('project')) {
+        if (typeof answer === 'string' && answer.length > 20) {
+          return answer;
+        }
+      }
+    }
+    return null;
+  }
 }
 
 module.exports = CursorGenerator;