@iservu-inc/adf-cli 0.4.36 → 0.5.1

package/lib/analysis/dynamic-pipeline.js

@@ -0,0 +1,262 @@
+const chalk = require('chalk');
+const AnswerAnalyzer = require('./answer-analyzer');
+const KnowledgeGraph = require('./knowledge-graph');
+const QuestionMapper = require('./question-mapper');
+
+/**
+ * Dynamic Question Pipeline Manager
+ *
+ * Orchestrates the intelligent question system:
+ * 1. Analyzes each answer for multiple information types
+ * 2. Builds knowledge graph of what we know
+ * 3. Dynamically skips/reorders questions based on knowledge
+ * 4. Reduces user pain by avoiding redundant questions
+ *
+ * Integration point for the interviewer.
+ */
+class DynamicPipeline {
+  constructor(sessionPath, aiClient, options = {}) {
+    this.sessionPath = sessionPath;
+    this.aiClient = aiClient;
+    this.options = {
+      enabled: options.enabled !== false, // Enabled by default
+      minSkipConfidence: options.minSkipConfidence || 75,
+      showAnalysis: options.showAnalysis !== false,
+      verbose: options.verbose || false
+    };
+
+    // Initialize components
+    this.analyzer = new AnswerAnalyzer(aiClient);
+    this.knowledgeGraph = new KnowledgeGraph(sessionPath);
+    this.mapper = new QuestionMapper();
+
+    // Stats
+    this.stats = {
+      questionsAsked: 0,
+      questionsSkipped: 0,
+      informationExtracted: 0,
+      timeSaved: 0
+    };
+  }
+
+  /**
+   * Initialize the pipeline (load existing knowledge graph if resuming)
+   */
+  async initialize() {
+    const loaded = await this.knowledgeGraph.load();
+
+    if (loaded && this.options.verbose) {
+      const stats = this.knowledgeGraph.getStats();
+      console.log(chalk.cyan(`\n📊 Resuming with ${stats.totalItems} pieces of knowledge\n`));
+    }
+
+    return loaded;
+  }
+
+  /**
+   * Process an answer after the user provides it
+   * Extracts information and updates knowledge graph
+   *
+   * @param {string} questionId - Question ID
+   * @param {string} questionText - The question text
+   * @param {string} answer - User's answer
+   * @returns {Promise<Object>} - { extracted: [], summary: [] }
+   */
+  async processAnswer(questionId, questionText, answer) {
+    if (!this.options.enabled) {
+      return { extracted: [], summary: [] };
+    }
+
+    try {
+      // Analyze answer for multiple information types
+      const extracted = await this.analyzer.analyzeAnswer(questionText, answer, questionId);
+
+      // Update knowledge graph
+      if (extracted.length > 0) {
+        this.knowledgeGraph.add(extracted);
+        this.stats.informationExtracted += extracted.length;
+
+        // Save knowledge graph
+        await this.knowledgeGraph.save();
+
+        // Get summary for display
+        const summary = this.analyzer.getSummary(extracted);
+
+        if (this.options.showAnalysis && extracted.length > 0) {
+          console.log(chalk.gray(`\n   📚 Learned: ${summary.slice(0, 2).join(', ')}`));
+        }
+
+        return { extracted, summary };
+      }
+
+      return { extracted: [], summary: [] };
+    } catch (error) {
+      // Don't fail the interview if analysis fails
+      if (this.options.verbose) {
+        console.log(chalk.yellow(`⚠️  Analysis failed: ${error.message}`));
+      }
+      return { extracted: [], summary: [] };
+    }
+  }
+
+  /**
+   * Check if a question should be skipped based on knowledge graph
+   *
+   * @param {Object} question - Question object
+   * @returns {Object} - { shouldSkip: boolean, reason: string, confidence: number }
+   */
+  shouldSkipQuestion(question) {
+    if (!this.options.enabled) {
+      return { shouldSkip: false, reason: '', confidence: 0 };
+    }
+
+    const skipInfo = this.mapper.canSkipQuestion(
+      question,
+      this.knowledgeGraph,
+      this.options.minSkipConfidence
+    );
+
+    if (skipInfo.canSkip) {
+      this.stats.questionsSkipped++;
+      this.stats.timeSaved += 1.5; // Assume 1.5 min per question
+    } else {
+      this.stats.questionsAsked++;
+    }
+
+    return {
+      shouldSkip: skipInfo.canSkip,
+      reason: skipInfo.reason,
+      confidence: skipInfo.satisfiedTypes.length > 0
+        ? Math.round(
+            skipInfo.satisfiedTypes.reduce((sum, t) => sum + t.confidence, 0) /
+            skipInfo.satisfiedTypes.length
+          )
+        : 0,
+      partial: skipInfo.satisfiedTypes.length > 0 && !skipInfo.canSkip
+    };
+  }
+
+  /**
+   * Reorder remaining questions based on knowledge graph
+   *
+   * @param {Array} questions - Array of question objects
+   * @returns {Array} - Reordered questions with metadata
+   */
+  reorderQuestions(questions) {
+    if (!this.options.enabled) {
+      return questions.map(q => ({ question: q, relevanceScore: 100, skipInfo: null }));
+    }
+
+    return this.mapper.reorderQuestions(questions, this.knowledgeGraph);
+  }
+
+  /**
+   * Get filtering summary before interview starts
+   *
+   * @param {Array} questions - All questions
+   * @returns {Object} - Summary statistics
+   */
+  getFilteringSummary(questions) {
+    if (!this.options.enabled) {
+      return {
+        total: questions.length,
+        canSkip: 0,
+        partial: 0,
+        needed: questions.length,
+        estimatedTimeSaved: 0
+      };
+    }
+
+    return this.mapper.getStats(questions, this.knowledgeGraph);
+  }
+
+  /**
+   * Get current knowledge summary for display
+   *
+   * @returns {Array} - Array of knowledge items with icons and confidence
+   */
+  getKnowledgeSummary() {
+    return this.knowledgeGraph.getDisplaySummary();
+  }
+
+  /**
+   * Show knowledge summary to user
+   */
+  displayKnowledgeSummary() {
+    const summary = this.getKnowledgeSummary();
+
+    if (summary.length > 0) {
+      console.log(chalk.cyan('\n📚 What I\'ve learned so far:\n'));
+
+      summary.slice(0, 5).forEach(item => {
+        const confidenceColor = item.confidence >= 85 ? chalk.green :
+                                item.confidence >= 70 ? chalk.cyan :
+                                chalk.yellow;
+
+        console.log(
+          `   ${item.icon} ${chalk.white(item.type)}: ` +
+          confidenceColor(`${item.confidence}% confidence`)
+        );
+      });
+
+      if (summary.length > 5) {
+        console.log(chalk.gray(`   ...and ${summary.length - 5} more\n`));
+      } else {
+        console.log('');
+      }
+    }
+  }
+
+  /**
+   * Get final statistics
+   */
+  getStats() {
+    const knowledgeStats = this.knowledgeGraph.getStats();
+
+    return {
+      ...this.stats,
+      knowledgeItems: knowledgeStats.totalItems,
+      highConfidenceItems: knowledgeStats.highConfidenceItems,
+      informationTypes: knowledgeStats.types
+    };
+  }
+
+  /**
+   * Display final statistics
+   */
+  displayFinalStats() {
+    if (!this.options.enabled) return;
+
+    const stats = this.getStats();
+
+    console.log(chalk.cyan('\n📊 Intelligent Question System Stats:\n'));
+    console.log(chalk.white(`   Questions asked: ${stats.questionsAsked}`));
+    console.log(chalk.green(`   Questions skipped: ${stats.questionsSkipped}`));
+    console.log(chalk.blue(`   Information pieces extracted: ${stats.informationExtracted}`));
+    console.log(chalk.magenta(`   High-confidence knowledge: ${stats.highConfidenceItems}`));
+    console.log(chalk.yellow(`   Estimated time saved: ~${Math.round(stats.timeSaved)} minutes\n`));
+  }
+
+  /**
+   * Save final state
+   */
+  async save() {
+    await this.knowledgeGraph.save();
+  }
+
+  /**
+   * Enable/disable the pipeline
+   */
+  setEnabled(enabled) {
+    this.options.enabled = enabled;
+  }
+
+  /**
+   * Check if enabled
+   */
+  isEnabled() {
+    return this.options.enabled;
+  }
+}
+
+module.exports = DynamicPipeline;

package/lib/analysis/knowledge-graph.js

@@ -0,0 +1,227 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Knowledge Graph
+ *
+ * Tracks all information extracted from user answers.
+ * Maintains confidence scores and sources for each piece of information.
+ * Used to determine which questions can be skipped or reordered.
+ */
+class KnowledgeGraph {
+  constructor(sessionPath) {
+    this.sessionPath = sessionPath;
+    this.knowledge = new Map(); // type -> array of knowledge items
+    this.filePath = path.join(sessionPath, '_knowledge_graph.json');
+  }
+
+  /**
+   * Add extracted information to the knowledge graph
+   */
+  add(extractedInfo) {
+    extractedInfo.forEach(item => {
+      if (!this.knowledge.has(item.type)) {
+        this.knowledge.set(item.type, []);
+      }
+
+      // Check if we already have similar information
+      const existing = this.knowledge.get(item.type);
+      const similar = existing.find(e =>
+        this.calculateSimilarity(e.content, item.content) > 0.7
+      );
+
+      if (similar) {
+        // Update if new confidence is higher
+        if (item.confidence > similar.confidence) {
+          similar.confidence = item.confidence;
+          similar.content = item.content;
+          similar.sources = [...new Set([...similar.sources, item.source])];
+        } else {
+          // Just add source
+          similar.sources = [...new Set([...similar.sources, item.source])];
+        }
+      } else {
+        // New information
+        existing.push({
+          ...item,
+          sources: [item.source],
+          addedAt: new Date().toISOString()
+        });
+      }
+    });
+  }
+
+  /**
+   * Check if we have information of a specific type with sufficient confidence
+   */
+  has(informationType, minConfidence = 70) {
+    if (!this.knowledge.has(informationType)) {
+      return false;
+    }
+
+    const items = this.knowledge.get(informationType);
+    return items.some(item => item.confidence >= minConfidence);
+  }
+
+  /**
+   * Get all information of a specific type
+   */
+  get(informationType) {
+    return this.knowledge.get(informationType) || [];
+  }
+
+  /**
+   * Get the highest confidence score for a type
+   */
+  getConfidence(informationType) {
+    const items = this.get(informationType);
+    if (items.length === 0) return 0;
+
+    return Math.max(...items.map(item => item.confidence));
+  }
+
+  /**
+   * Get all information as a summary object
+   */
+  getSummary() {
+    const summary = {};
+
+    for (const [type, items] of this.knowledge.entries()) {
+      summary[type] = {
+        count: items.length,
+        maxConfidence: Math.max(...items.map(i => i.confidence)),
+        sources: [...new Set(items.flatMap(i => i.sources))]
+      };
+    }
+
+    return summary;
+  }
+
+  /**
+   * Get information to display to user
+   */
+  getDisplaySummary() {
+    const lines = [];
+
+    for (const [type, items] of this.knowledge.entries()) {
+      const maxConfidence = Math.max(...items.map(i => i.confidence));
+      if (maxConfidence >= 60) { // Only show reasonably confident items
+        const typeLabel = type.replace(/_/g, ' ');
+        const icon = this.getIconForType(type);
+        lines.push({
+          type: typeLabel,
+          icon,
+          confidence: maxConfidence,
+          count: items.length
+        });
+      }
+    }
+
+    // Sort by confidence
+    lines.sort((a, b) => b.confidence - a.confidence);
+
+    return lines;
+  }
+
+  /**
+   * Get icon for information type
+   */
+  getIconForType(type) {
+    const icons = {
+      tech_stack: '🔧',
+      architecture: '🏗️',
+      project_goal: '🎯',
+      target_users: '👥',
+      features: '✨',
+      platform: '💻',
+      constraints: '⚠️',
+      timeline: '⏰',
+      team_size: '👨‍👩‍👧‍👦',
+      deployment: '🚀',
+      security: '🔒',
+      performance: '⚡'
+    };
+    return icons[type] || '📌';
+  }
+
+  /**
+   * Calculate text similarity (simple Jaccard similarity)
+   */
+  calculateSimilarity(text1, text2) {
+    const words1 = new Set(text1.toLowerCase().split(/\s+/));
+    const words2 = new Set(text2.toLowerCase().split(/\s+/));
+
+    const intersection = new Set([...words1].filter(x => words2.has(x)));
+    const union = new Set([...words1, ...words2]);
+
+    return intersection.size / union.size;
+  }
+
+  /**
+   * Save knowledge graph to disk
+   */
+  async save() {
+    const data = {
+      savedAt: new Date().toISOString(),
+      knowledge: Array.from(this.knowledge.entries()).map(([type, items]) => ({
+        type,
+        items
+      }))
+    };
+
+    await fs.writeJson(this.filePath, data, { spaces: 2 });
+  }
+
+  /**
+   * Load knowledge graph from disk
+   */
+  async load() {
+    try {
+      if (await fs.pathExists(this.filePath)) {
+        const data = await fs.readJson(this.filePath);
+
+        this.knowledge = new Map(
+          data.knowledge.map(({ type, items }) => [type, items])
+        );
+
+        return true;
+      }
+    } catch (error) {
+      // Failed to load, start fresh
+    }
+
+    return false;
+  }
+
+  /**
+   * Get statistics about the knowledge graph
+   */
+  getStats() {
+    let totalItems = 0;
+    let highConfidenceItems = 0;
+    const types = [];
+
+    for (const [type, items] of this.knowledge.entries()) {
+      totalItems += items.length;
+      highConfidenceItems += items.filter(i => i.confidence >= 80).length;
+      types.push(type);
+    }
+
+    return {
+      totalItems,
+      highConfidenceItems,
+      types: types.length,
+      typeList: types
+    };
+  }
+
+  /**
+   * Clear all knowledge
+   */
+  clear() {
+    this.knowledge.clear();
+  }
+}
+
+module.exports = KnowledgeGraph;