@iservu-inc/adf-cli 0.4.36 → 0.5.1

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/init.js

@@ -67,21 +67,108 @@ async function init(options) {
     const hasContent = await hasMeaningfulContent(adfDir);
 
     if (hasContent) {
-      const { overwrite } = await inquirer.prompt([
+      // Show what exists
+      const existingContent = await getExistingContent(adfDir);
+      console.log(chalk.cyan('\n📦 Existing ADF Project Detected\n'));
+
+      if (existingContent.sessions > 0) {
+        console.log(chalk.gray(`   Sessions: ${existingContent.sessions} session(s)`));
+      }
+      if (existingContent.outputs > 0) {
+        console.log(chalk.gray(`   Outputs: ${existingContent.outputs} file(s)`));
+      }
+      if (existingContent.learning) {
+        console.log(chalk.gray(`   Learning data: Present`));
+      }
+      console.log('');
+
+      const { action } = await inquirer.prompt([
         {
-          type: 'confirm',
-          name: 'overwrite',
-          message: chalk.yellow('.adf directory already exists with sessions. Overwrite?'),
-          default: false
+          type: 'list',
+          name: 'action',
+          message: 'What would you like to do?',
+          choices: [
+            {
+              name: 'Continue with Existing Project',
+              value: 'continue',
+              short: 'Continue'
+            },
+            {
+              name: 'Reset this Project (delete all data)',
+              value: 'reset',
+              short: 'Reset'
+            },
+            new inquirer.Separator(),
+            {
+              name: chalk.gray('← Don\'t change & Exit'),
+              value: 'exit',
+              short: 'Exit'
+            }
+          ],
+          default: 'continue'
         }
       ]);
 
-      if (!overwrite) {
-        console.log(chalk.yellow('\n✋ Initialization cancelled.\n'));
+      if (action === 'exit') {
+        console.log(chalk.gray('\n← Exited without changes.\n'));
         return;
       }
 
-      await fs.remove(adfDir);
+      if (action === 'reset') {
+        // Confirm deletion
+        const { confirmReset } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirmReset',
+            message: chalk.red('⚠️  This will permanently delete all sessions and data. Continue?'),
+            default: false
+          }
+        ]);
+
+        if (!confirmReset) {
+          console.log(chalk.gray('\n← Reset cancelled. Exited without changes.\n'));
+          return;
+        }
+
+        await fs.remove(adfDir);
+        console.log(chalk.yellow('\n✓ Project reset. Starting fresh...\n'));
+      } else if (action === 'continue') {
+        // Continue with existing project - show sessions and prompt to resume
+        console.log(chalk.green('\n✓ Continuing with existing project...\n'));
+
+        // The SessionManager.promptToResume() was already called above (line 29)
+        // But it returned null (no resumable sessions), so let them see what exists
+        // and choose to start a new session or view existing outputs
+
+        const { continueAction } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'continueAction',
+            message: 'What would you like to do?',
+            choices: [
+              {
+                name: 'Start a new session (keeps existing data)',
+                value: 'new-session',
+                short: 'New Session'
+              },
+              {
+                name: chalk.gray('← Exit'),
+                value: 'exit',
+                short: 'Exit'
+              }
+            ],
+            default: 'new-session'
+          }
+        ]);
+
+        if (continueAction === 'exit') {
+          console.log(chalk.gray('\n← Exited.\n'));
+          return;
+        }
+
+        // Continue to start a new session below (fall through)
+        console.log('');
+      }
     } else {
       // Only .env file exists - safe to continue without prompting
       console.log(chalk.gray('✓ Using existing .adf directory\n'));
@@ -218,4 +305,46 @@ async function hasMeaningfulContent(adfDir) {
   }
 }
 
+/**
+ * Get detailed information about existing ADF content
+ * Returns object with counts and details
+ */
+async function getExistingContent(adfDir) {
+  const result = {
+    sessions: 0,
+    outputs: 0,
+    learning: false,
+    details: []
+  };
+
+  try {
+    const contents = await fs.readdir(adfDir);
+
+    for (const item of contents) {
+      const itemPath = path.join(adfDir, item);
+      const stats = await fs.stat(itemPath);
+
+      if (stats.isDirectory()) {
+        if (item === 'sessions') {
+          // Count session directories
+          const sessions = await fs.readdir(itemPath);
+          result.sessions = sessions.filter(s => !s.startsWith('.')).length;
+        } else if (item === 'outputs') {
+          // Count output files
+          const outputs = await fs.readdir(itemPath);
+          result.outputs = outputs.filter(o => !o.startsWith('.')).length;
+        } else if (item === 'learning') {
+          // Check for learning data
+          const learningFiles = await fs.readdir(itemPath);
+          result.learning = learningFiles.length > 0;
+        }
+      }
+    }
+
+    return result;
+  } catch (error) {
+    return result;
+  }
+}
+
 module.exports = init;

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.1",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework with multi-provider AI support",
   "main": "index.js",
   "bin": {