@iservu-inc/adf-cli 0.4.36 → 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/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/package.json

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

package/tests/answer-analyzer.test.js

@@ -0,0 +1,262 @@
+const AnswerAnalyzer = require('../lib/analysis/answer-analyzer');
+
+describe('AnswerAnalyzer', () => {
+  let analyzer;
+  let mockAIClient;
+
+  beforeEach(() => {
+    mockAIClient = {
+      sendMessage: jest.fn()
+    };
+    analyzer = new AnswerAnalyzer(mockAIClient);
+  });
+
+  describe('heuristicExtraction', () => {
+    it('should extract tech stack from answer', () => {
+      const answer = 'I am building a React frontend with PostgreSQL database and Node.js backend';
+      const questionId = 'what-building';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack).toBeDefined();
+      expect(techStack.extractedTerms).toContain('react');
+      expect(techStack.extractedTerms).toContain('postgresql');
+      expect(techStack.extractedTerms).toContain('node');
+      expect(techStack.confidence).toBeGreaterThan(60);
+    });
+
+    it('should extract architecture patterns', () => {
+      const answer = 'I will build a frontend with a separate backend API using microservices';
+      const questionId = 'architecture';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const frontendBackend = extracted.find(e =>
+        e.type === 'architecture' && e.pattern === 'frontend-backend-separation'
+      );
+      const microservices = extracted.find(e =>
+        e.type === 'architecture' && e.pattern === 'microservices'
+      );
+
+      expect(frontendBackend).toBeDefined();
+      expect(microservices).toBeDefined();
+      expect(frontendBackend.confidence).toBeGreaterThan(70);
+    });
+
+    it('should extract platform information', () => {
+      const answer = 'This is a mobile app for iOS and Android using React Native';
+      const questionId = 'platform';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const platform = extracted.find(e => e.type === 'platform');
+      expect(platform).toBeDefined();
+      expect(platform.platform).toBe('mobile');
+      expect(platform.confidence).toBeGreaterThan(70);
+    });
+
+    it('should extract project goal from goal questions', () => {
+      const answer = 'Create a social media platform for developers to share code snippets';
+      const questionId = 'what-is-goal';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const goal = extracted.find(e => e.type === 'project_goal');
+      expect(goal).toBeDefined();
+      expect(goal.confidence).toBe(95);
+      expect(goal.content).toBe(answer);
+    });
+
+    it('should extract timeline information', () => {
+      const answer = 'I need this completed in 3 weeks for a product launch';
+      const questionId = 'timeline';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const timeline = extracted.find(e => e.type === 'timeline');
+      expect(timeline).toBeDefined();
+      expect(timeline.confidence).toBeGreaterThan(70);
+    });
+
+    it('should extract target users', () => {
+      const answer = 'The target audience is small businesses and their customers';
+      const questionId = 'users';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const users = extracted.find(e => e.type === 'target_users');
+      expect(users).toBeDefined();
+      expect(users.confidence).toBe(70);
+    });
+
+    it('should return empty array for uninformative answers', () => {
+      const answer = 'yes';
+      const questionId = 'question';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      expect(extracted).toEqual([]);
+    });
+
+    it('should handle multiple tech mentions with higher confidence', () => {
+      const answer = 'Using React, Next.js, TypeScript, PostgreSQL, Redis, and AWS';
+      const questionId = 'tech';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack).toBeDefined();
+      expect(techStack.extractedTerms.length).toBeGreaterThanOrEqual(5);
+      expect(techStack.confidence).toBeGreaterThan(80);
+    });
+  });
+
+  describe('aiExtraction', () => {
+    it('should extract information using AI when available', async () => {
+      const mockAIResponse = JSON.stringify([
+        {
+          type: 'tech_stack',
+          content: 'React and PostgreSQL',
+          confidence: 95,
+          reasoning: 'Explicitly mentioned'
+        },
+        {
+          type: 'architecture',
+          content: 'separate backend API',
+          confidence: 85,
+          reasoning: 'Implies frontend-backend separation'
+        }
+      ]);
+
+      mockAIClient.sendMessage.mockResolvedValue(mockAIResponse);
+
+      const extracted = await analyzer.aiExtraction(
+        'What tech stack?',
+        'React frontend with separate backend API using PostgreSQL',
+        'tech-stack'
+      );
+
+      expect(mockAIClient.sendMessage).toHaveBeenCalled();
+      expect(extracted).toHaveLength(2);
+      expect(extracted[0].type).toBe('tech_stack');
+      expect(extracted[0].method).toBe('ai');
+      expect(extracted[0].source).toBe('tech-stack');
+    });
+
+    it('should handle AI extraction errors gracefully', async () => {
+      mockAIClient.sendMessage.mockRejectedValue(new Error('AI error'));
+
+      const extracted = await analyzer.aiExtraction(
+        'What are you building?',
+        'A web app',
+        'goal'
+      );
+
+      expect(extracted).toEqual([]);
+    });
+
+    it('should handle invalid JSON from AI', async () => {
+      mockAIClient.sendMessage.mockResolvedValue('This is not JSON');
+
+      const extracted = await analyzer.aiExtraction(
+        'What tech?',
+        'React and Node',
+        'tech'
+      );
+
+      expect(extracted).toEqual([]);
+    });
+  });
+
+  describe('analyzeAnswer', () => {
+    it('should combine heuristic and AI results', async () => {
+      const mockAIResponse = JSON.stringify([
+        {
+          type: 'tech_stack',
+          content: 'React and Node.js',
+          confidence: 90,
+          reasoning: 'Explicitly stated'
+        }
+      ]);
+
+      mockAIClient.sendMessage.mockResolvedValue(mockAIResponse);
+
+      const extracted = await analyzer.analyzeAnswer(
+        'What tech stack?',
+        'I will use React for frontend and Node.js for backend',
+        'tech-stack'
+      );
+
+      expect(extracted.length).toBeGreaterThan(0);
+      // Should have at least tech_stack from both methods
+      const techStackItems = extracted.filter(e => e.type === 'tech_stack');
+      expect(techStackItems.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should use AI result if confidence is higher', async () => {
+      const mockAIResponse = JSON.stringify([
+        {
+          type: 'tech_stack',
+          content: 'Full tech stack analysis',
+          confidence: 95,
+          reasoning: 'Comprehensive analysis'
+        }
+      ]);
+
+      mockAIClient.sendMessage.mockResolvedValue(mockAIResponse);
+
+      const extracted = await analyzer.analyzeAnswer(
+        'What tech?',
+        'React and Node',
+        'tech'
+      );
+
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack.confidence).toBeGreaterThanOrEqual(85);
+    });
+
+    it('should work without AI client', async () => {
+      const analyzerWithoutAI = new AnswerAnalyzer(null);
+
+      const extracted = await analyzerWithoutAI.analyzeAnswer(
+        'What are you building?',
+        'A React web application with PostgreSQL database',
+        'goal'
+      );
+
+      expect(extracted.length).toBeGreaterThan(0);
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack).toBeDefined();
+    });
+  });
+
+  describe('getSummary', () => {
+    it('should generate human-readable summary', () => {
+      const extractedInfo = [
+        { type: 'tech_stack', confidence: 90 },
+        { type: 'architecture', confidence: 85 },
+        { type: 'project_goal', confidence: 95 }
+      ];
+
+      const summary = analyzer.getSummary(extractedInfo);
+
+      expect(summary).toContain('TECH STACK: 90% confidence');
+      expect(summary).toContain('ARCHITECTURE: 85% confidence');
+      expect(summary).toContain('PROJECT GOAL: 95% confidence');
+    });
+
+    it('should handle multiple items of same type', () => {
+      const extractedInfo = [
+        { type: 'tech_stack', confidence: 90 },
+        { type: 'tech_stack', confidence: 80 },
+        { type: 'architecture', confidence: 85 }
+      ];
+
+      const summary = analyzer.getSummary(extractedInfo);
+
+      // Should show highest confidence
+      expect(summary).toContain('TECH STACK: 90% confidence');
+    });
+  });
+});