@iservu-inc/adf-cli 0.4.35 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,226 @@ All notable changes to `@iservu-inc/adf-cli` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2025-10-05
+
+### 🧠 Intelligent Answer Analysis & Dynamic Question Pipeline
+
+**MAJOR FEATURE:** AI-powered answer analysis that extracts multiple pieces of information from each answer and intelligently skips redundant questions.
+
+#### What This Means for Users
+
+**Before v0.5.0:**
+```
+Q: What are you building?
+A: A React web app with PostgreSQL database for user management
+
+Q: What tech stack will you use?  ← Redundant!
+A: [User has to repeat: React, PostgreSQL...]
+
+Q: What platform?  ← Also redundant!
+A: [User repeats: Web...]
+```
+
+**After v0.5.0:**
+```
+Q: What are you building?
+A: A React web app with PostgreSQL database for user management
+
+   📚 Learned: TECH STACK: 90% confidence, PLATFORM: 85% confidence
+
+⏭️  Skipping: What tech stack will you use?
+   ✓ Already have: tech stack (90% confidence)
+
+⏭️  Skipping: What platform?
+   ✓ Already have: platform (85% confidence)
+
+📊 Time saved: ~3 minutes
+```
+
+#### Core Components Added
+
+**1. Answer Analyzer (`lib/analysis/answer-analyzer.js`)**
+- Extracts 12 information types from each answer:
+  - Tech Stack, Architecture, Project Goal, Target Users
+  - Features, Platform, Constraints, Timeline
+  - Team Size, Deployment, Security, Performance
+- Dual extraction: Heuristic (fast, always works) + AI (accurate, context-aware)
+- Confidence scoring (0-100) for each extracted piece
+- Works with or without AI client (graceful degradation)
+
+**2. Knowledge Graph (`lib/analysis/knowledge-graph.js`)**
+- Tracks all extracted information across the interview
+- Maintains confidence scores and sources for each piece
+- Merges similar information automatically
+- Persists to disk (`_knowledge_graph.json`) for resume capability
+- Provides displayable summaries with icons
+
+**3. Question Mapper (`lib/analysis/question-mapper.js`)**
+- Maps each question to the information types it gathers
+- Determines which questions can be skipped based on knowledge
+- Reorders questions dynamically to prioritize missing information
+- Calculates time saved estimates
+- Priority-based question boosting (fundamental questions first)
+
+**4. Dynamic Pipeline (`lib/analysis/dynamic-pipeline.js`)**
+- Orchestrates the entire intelligent question system
+- Processes answers after each response
+- Checks skip eligibility before each question
+- Displays knowledge summaries periodically
+- Final statistics showing questions asked/skipped and time saved
+
+#### Integration with Interviewer
+
+**Modified Files:**
+- `lib/frameworks/interviewer.js`:
+  - Initialize DynamicPipeline with AI client
+  - Process each answer for information extraction
+  - Check shouldSkipQuestion() before asking
+  - Display knowledge summary every 2 blocks
+  - Show final stats at interview completion
+
+#### User Experience Enhancements
+
+**During Interview:**
+- Real-time learning display after each answer
+- Clear skip messages with reasoning and confidence
+- Block summaries showing answered vs skipped questions
+- Periodic knowledge summaries (every 2 blocks)
+
+**Final Statistics:**
+```
+📊 Intelligent Question System Stats:
+
+   Questions asked: 12
+   Questions skipped: 8
+   Information pieces extracted: 24
+   High-confidence knowledge: 18
+   Estimated time saved: ~12 minutes
+```
+
+#### Benefits
+
+- **Reduced user pain:** No more answering the same question multiple times
+- **Time savings:** 40-60% reduction in redundant questions for comprehensive answers
+- **Better UX:** System learns as you type, adapts in real-time
+- **Intelligent adaptation:** Questions reordered based on what's missing
+- **Full transparency:** See what was learned and why questions were skipped
+
+#### Testing
+
+- **New Test Suites:** 4 comprehensive test files added
+  - `tests/answer-analyzer.test.js` (58 tests)
+  - `tests/knowledge-graph.test.js` (45 tests)
+  - `tests/question-mapper.test.js` (47 tests)
+  - `tests/dynamic-pipeline.test.js` (50 tests)
+- **Total Tests:** 200 passing (was 120)
+- **Coverage:** All new modules fully tested
+
+#### Technical Details
+
+**Information Extraction Patterns:**
+- Heuristic: Regex patterns + keyword matching (fast)
+- AI: Context-aware analysis with reasoning (accurate)
+- Merged results: Highest confidence wins
+
+**Skip Decision Logic:**
+```javascript
+canSkip = ALL required info types satisfied
+       AND confidence >= threshold (default 75%)
+```
+
+**Question Reordering:**
+```
+Score = 100 if no knowledge exists
+      = 0 if all knowledge exists
+      = partial % if some knowledge exists
+
+Score *= priority boost (1.3x for fundamental questions)
+Sort by score descending
+```
+
+#### Configuration Options
+
+```javascript
+new DynamicPipeline(sessionPath, aiClient, {
+  enabled: true,              // Enable/disable system
+  minSkipConfidence: 75,      // Minimum confidence to skip
+  showAnalysis: true,         // Show what was learned
+  verbose: false              // Debug output
+})
+```
+
+#### Backward Compatibility
+
+- ✅ Fully backward compatible
+- ✅ Works with or without AI client
+- ✅ Can be disabled if needed
+- ✅ Graceful degradation on errors
+- ✅ All existing tests still pass
+
+---
+
+## [0.4.36] - 2025-10-04
+
+### ✨ Multi-IDE Improvements + Config Command Enhancement
+
+**1. Added IDE Deployment to `adf config`**
+- New category: "IDE Deployment"
+- Deploy to multiple IDEs without re-running `adf init`
+- Shows which IDEs are already deployed
+- Pre-selects already deployed IDEs in checkbox
+- Allows quick re-deployment or deployment to new IDEs
+
+**New Config Menu:**
+```
+⚙️  ADF Configuration
+
+? Select configuration category:
+> AI Provider Setup - ✓ Configured (Openai)
+  IDE Deployment - ✓ Deployed (Windsurf, Cursor)
+  Learning System - ✓ Active (5 sessions, 12 patterns)
+```
+
+**Usage:**
+```bash
+adf config
+# Select "IDE Deployment"
+# Choose IDEs to deploy to
+# Done!
+```
+
+**2. Improved Cursor Generator**
+- Added `loadSessionAnswers()` - reads actual session data
+- Added `extractTechStackFromAnswers()` - detects tech in answers
+- Added `extractWhatBuildingFromAnswers()` - finds project goals
+- Falls back to session answers when PRP sections empty
+- Better content instead of "See PRP for details"
+
+**3. Improved VSCode/Copilot Generator**
+- Same answer extraction improvements as Cursor
+- Better Copilot instructions with real content
+- Falls back to session answers
+- Improved tech stack detection
+
+**Code Changes:**
+- config.js:18-27 - Added IDE_DEPLOYMENT category
+- config.js:221-331 - IDE deployment configuration logic
+- cursor-generator.js:41-51 - Made generateRules async
+- cursor-generator.js:53-129 - Enhanced generateRulesPRP with answer extraction
+- cursor-generator.js:373-424 - Added helper methods
+- vscode-generator.js:40-50 - Made generateCopilotInstructions async
+- vscode-generator.js:52-124 - Enhanced generateCopilotPRP with answer extraction
+- vscode-generator.js:402-451 - Added helper methods
+
+**Impact:**
+- ✅ `adf config` now lets you deploy to IDEs
+- ✅ Cursor files now have real content
+- ✅ VSCode Copilot instructions have real content
+- ✅ All generators use session answers as fallback
+- ✅ No more "See PRP for details" placeholders
+
+---
+
 ## [0.4.35] - 2025-10-04
 
 ### 🔧 MAJOR FIX: Windsurf Configuration - Activation Modes & Content Generation

package/lib/analysis/answer-analyzer.js

@@ -0,0 +1,304 @@
+const chalk = require('chalk');
+
+/**
+ * AI-Powered Answer Analyzer
+ *
+ * Analyzes user answers to extract multiple pieces of information:
+ * - Tech stack (frameworks, languages, databases)
+ * - Architecture patterns (frontend/backend, microservices, etc.)
+ * - Project goals and purpose
+ * - User personas and target audience
+ * - Features and functionality
+ * - Constraints and requirements
+ * - Timeline and team information
+ *
+ * Each extracted piece has a confidence score (0-100)
+ */
+class AnswerAnalyzer {
+  constructor(aiClient) {
+    this.aiClient = aiClient;
+
+    // Information types we can extract from answers
+    this.informationTypes = {
+      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'
+    };
+  }
+
+  /**
+   * Analyze an answer for multiple information types
+   *
+   * @param {string} questionText - The question that was asked
+   * @param {string} answer - User's answer
+   * @param {string} questionId - Question ID for context
+   * @returns {Promise<Array<{type: string, content: string, confidence: number, source: string}>>}
+   */
+  async analyzeAnswer(questionText, answer, questionId) {
+    const extracted = [];
+
+    // First, try heuristic extraction (fast, always works)
+    const heuristicResults = this.heuristicExtraction(answer, questionId);
+    extracted.push(...heuristicResults);
+
+    // Then, if AI is available, use AI for deeper analysis
+    if (this.aiClient) {
+      try {
+        const aiResults = await this.aiExtraction(questionText, answer, questionId);
+
+        // Merge AI results with heuristic results
+        // If AI found something with higher confidence, use that
+        aiResults.forEach(aiResult => {
+          const existingIndex = extracted.findIndex(e => e.type === aiResult.type);
+
+          if (existingIndex >= 0) {
+            // Compare confidence scores
+            if (aiResult.confidence > extracted[existingIndex].confidence) {
+              extracted[existingIndex] = aiResult;
+            }
+          } else {
+            extracted.push(aiResult);
+          }
+        });
+      } catch (error) {
+        // AI failed, heuristic results are still valid
+        console.log(chalk.gray('   (Using heuristic analysis only)'));
+      }
+    }
+
+    return extracted;
+  }
+
+  /**
+   * Heuristic-based extraction (pattern matching)
+   * Fast, works without AI, decent accuracy
+   */
+  heuristicExtraction(answer, questionId) {
+    const extracted = [];
+    const lower = answer.toLowerCase();
+
+    // Tech Stack Detection
+    const techPatterns = {
+      frameworks: ['react', 'vue', 'angular', 'svelte', 'next.js', 'nuxt', 'gatsby'],
+      backend: ['node', 'express', 'django', 'flask', 'fastapi', 'spring', 'rails', 'laravel', '.net'],
+      databases: ['postgres', 'postgresql', 'mysql', 'mongodb', 'mongo', 'redis', 'sqlite', 'dynamodb'],
+      languages: ['javascript', 'typescript', 'python', 'java', 'c#', 'go', 'rust', 'php', 'ruby'],
+      cloud: ['aws', 'azure', 'gcp', 'google cloud', 'heroku', 'vercel', 'netlify', 'digital ocean']
+    };
+
+    const foundTech = [];
+    Object.entries(techPatterns).forEach(([category, patterns]) => {
+      patterns.forEach(pattern => {
+        if (lower.includes(pattern)) {
+          foundTech.push(pattern);
+        }
+      });
+    });
+
+    if (foundTech.length > 0) {
+      extracted.push({
+        type: this.informationTypes.TECH_STACK,
+        content: answer,
+        confidence: Math.min(85, 50 + (foundTech.length * 10)), // More mentions = higher confidence
+        source: questionId,
+        extractedTerms: foundTech
+      });
+    }
+
+    // Architecture Pattern Detection
+    const archPatterns = [
+      { pattern: /frontend.*backend|backend.*frontend|separate.*backend|api.*frontend/i, value: 'frontend-backend-separation', confidence: 80 },
+      { pattern: /microservice/i, value: 'microservices', confidence: 90 },
+      { pattern: /monolith/i, value: 'monolithic', confidence: 90 },
+      { pattern: /serverless|lambda/i, value: 'serverless', confidence: 85 },
+      { pattern: /spa|single.*page.*application/i, value: 'spa', confidence: 75 },
+      { pattern: /ssr|server.*side.*rendering/i, value: 'ssr', confidence: 75 },
+      { pattern: /rest.*api|restful/i, value: 'rest-api', confidence: 70 },
+      { pattern: /graphql/i, value: 'graphql', confidence: 90 }
+    ];
+
+    archPatterns.forEach(({ pattern, value, confidence }) => {
+      if (pattern.test(answer)) {
+        extracted.push({
+          type: this.informationTypes.ARCHITECTURE,
+          content: answer,
+          confidence,
+          source: questionId,
+          pattern: value
+        });
+      }
+    });
+
+    // Platform Detection
+    const platformPatterns = [
+      { pattern: /\bweb\b/i, value: 'web', confidence: 70 },
+      { pattern: /mobile|ios|android|react native|flutter/i, value: 'mobile', confidence: 85 },
+      { pattern: /desktop|electron/i, value: 'desktop', confidence: 85 },
+      { pattern: /\bapi\b|rest.*api/i, value: 'api', confidence: 75 },
+      { pattern: /cli|command.*line/i, value: 'cli', confidence: 80 }
+    ];
+
+    platformPatterns.forEach(({ pattern, value, confidence }) => {
+      if (pattern.test(answer)) {
+        extracted.push({
+          type: this.informationTypes.PLATFORM,
+          content: answer,
+          confidence,
+          source: questionId,
+          platform: value
+        });
+      }
+    });
+
+    // Goal/Purpose Detection (if answer is substantial)
+    if (questionId.toLowerCase().includes('goal') ||
+        questionId.toLowerCase().includes('building') ||
+        questionId.toLowerCase().includes('purpose')) {
+      if (answer.length > 20) {
+        extracted.push({
+          type: this.informationTypes.PROJECT_GOAL,
+          content: answer,
+          confidence: 95, // Direct answer to goal question = high confidence
+          source: questionId
+        });
+      }
+    }
+
+    // Target Users Detection
+    const userPatterns = ['users', 'customers', 'audience', 'developers', 'businesses', 'consumers'];
+    if (userPatterns.some(pattern => lower.includes(pattern)) && answer.length > 15) {
+      extracted.push({
+        type: this.informationTypes.TARGET_USERS,
+        content: answer,
+        confidence: 70,
+        source: questionId
+      });
+    }
+
+    // Timeline Detection
+    const timePatterns = [
+      { pattern: /\d+\s*(week|month|day)/i, confidence: 85 },
+      { pattern: /asap|urgent|immediately/i, confidence: 70 },
+      { pattern: /no.*rush|flexible|whenever/i, confidence: 65 }
+    ];
+
+    timePatterns.forEach(({ pattern, confidence }) => {
+      if (pattern.test(answer)) {
+        extracted.push({
+          type: this.informationTypes.TIMELINE,
+          content: answer,
+          confidence,
+          source: questionId
+        });
+      }
+    });
+
+    return extracted;
+  }
+
+  /**
+   * AI-powered extraction (more accurate, understands context)
+   */
+  async aiExtraction(questionText, answer, questionId) {
+    if (!this.aiClient) return [];
+
+    const prompt = `Analyze this Q&A and extract ALL pieces of information mentioned:
+
+Question: ${questionText}
+Answer: ${answer}
+
+Extract the following information types if mentioned (even if not the main topic):
+1. Tech Stack: Frameworks, languages, databases, tools
+2. Architecture: System design patterns, structure
+3. Project Goal: What they're building and why
+4. Target Users: Who will use this
+5. Features: Specific functionality mentioned
+6. Platform: Web, mobile, desktop, API, etc.
+7. Constraints: Limitations, requirements
+8. Timeline: Deadlines, timeframes
+9. Team Size: How many people
+10. Deployment: Hosting, infrastructure
+11. Security: Security requirements
+12. Performance: Performance needs
+
+For EACH piece of information found, provide:
+- type: One of the types above (lowercase with underscores)
+- content: The relevant excerpt from the answer
+- confidence: 0-100 (how sure are you this information is present and accurate)
+- reasoning: Why you extracted this
+
+Return as JSON array. Example:
+[
+  {
+    "type": "tech_stack",
+    "content": "Next.js frontend with PostgreSQL database",
+    "confidence": 95,
+    "reasoning": "Explicitly mentioned Next.js and PostgreSQL"
+  },
+  {
+    "type": "architecture",
+    "content": "separate backend API",
+    "confidence": 85,
+    "reasoning": "Implies frontend-backend separation"
+  }
+]
+
+IMPORTANT: Only extract information that is ACTUALLY PRESENT in the answer. Don't infer or assume.`;
+
+    try {
+      const response = await this.aiClient.sendMessage(prompt);
+
+      // Parse JSON response
+      const jsonMatch = response.match(/\[[\s\S]*\]/);
+      if (jsonMatch) {
+        const extracted = JSON.parse(jsonMatch[0]);
+
+        // Add source to each extraction
+        return extracted.map(item => ({
+          ...item,
+          source: questionId,
+          method: 'ai'
+        }));
+      }
+    } catch (error) {
+      // Parsing failed or AI error
+      return [];
+    }
+
+    return [];
+  }
+
+  /**
+   * Get a human-readable summary of extracted information
+   */
+  getSummary(extractedInfo) {
+    const grouped = {};
+
+    extractedInfo.forEach(item => {
+      if (!grouped[item.type]) {
+        grouped[item.type] = [];
+      }
+      grouped[item.type].push(item);
+    });
+
+    const lines = [];
+    Object.entries(grouped).forEach(([type, items]) => {
+      const highestConfidence = Math.max(...items.map(i => i.confidence));
+      const typeLabel = type.replace(/_/g, ' ').toUpperCase();
+      lines.push(`${typeLabel}: ${highestConfidence}% confidence`);
+    });
+
+    return lines;
+  }
+}
+
+module.exports = AnswerAnalyzer;