@iservu-inc/adf-cli 0.14.6 → 0.17.0

package/lib/commands/init.js

@@ -159,10 +159,14 @@ async function init(options) {
     const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession, aiConfig);
     const sessionPath = await interviewer.start();
 
-    console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
-    console.log(chalk.cyan(`📁 Session saved to: ${sessionPath}\n`));
-
-    return;
+    if (sessionPath === 'back') {
+      // User requested to go back to main menu
+      // Fall through to existing content check
+    } else {
+      console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
+      console.log(chalk.cyan(`📁 Session saved to: ${sessionPath}\n`));
+      return;
+    }
   }
 
   // Check if already initialized with actual content
@@ -318,6 +322,15 @@ async function init(options) {
   console.log(chalk.gray(`  ✓ Files saved to: ${sessionPath}/outputs/`));
   console.log(chalk.gray(`  ✓ You can review your requirements anytime\n`));
 
+  // Generate A2A agent cards
+  try {
+    const { generateA2A } = require('../generators');
+    await generateA2A(sessionPath, cwd, workflow);
+    console.log(chalk.gray('  ✓ A2A agent cards generated'));
+  } catch (error) {
+    console.warn(chalk.yellow(`  ⚠ Could not generate A2A cards: ${error.message}`));
+  }
+
   // Optional: Deploy to tool
   if (options.tool) {
     console.log('');

package/lib/frameworks/interviewer.js

@@ -344,6 +344,14 @@ class Interviewer {
       const resumeInfo = this.progressTracker.getResumeInfo();
       console.log(chalk.gray(`Last updated: ${new Date(resumeInfo.lastUpdated).toLocaleString()}`));
       console.log(chalk.gray(`Progress: ${resumeInfo.completedBlocks}/${resumeInfo.totalBlocks} blocks | ${resumeInfo.totalQuestionsAnswered} questions\n`));
+
+      // Offer to review existing answers
+      const reviewAction = await this.reviewProgress();
+      if (reviewAction === 'back') {
+        return 'back';
+      } else if (reviewAction === 'exit') {
+        process.exit(0);
+      }
     }
 
     console.log(chalk.cyan(`\nℹ️  Total question blocks: ${questionBlocks.length}\n`));
@@ -436,6 +444,158 @@ class Interviewer {
     return this.sessionPath;
   }
 
+  async reviewProgress() {
+    const answeredIds = Object.keys(this.answers);
+    if (answeredIds.length === 0) return 'continue';
+
+    const { shouldReview } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldReview',
+        message: `Review ${answeredIds.length} previously answered questions?`,
+        default: true
+      }
+    ]);
+
+    if (!shouldReview) return 'continue';
+
+    // Collect and format Q/A pairs
+    const questions = this.customQuestions || getQuestionsForFramework(this.framework);
+    const pairs = [];
+    
+    for (const id of answeredIds) {
+      const q = questions.find(q => q.id === id);
+      if (q) {
+        const answerText = typeof this.answers[id] === 'string' ? this.answers[id] : this.answers[id].text;
+        pairs.push({
+          id: id,
+          question: q.text,
+          answer: answerText
+        });
+      }
+    }
+
+    // Pagination logic
+    const terminalHeight = process.stdout.rows || 24;
+    const availableHeight = terminalHeight - 6; // Reserve lines for instructions
+    
+    let currentIndex = 0;
+    
+    while (currentIndex < pairs.length) {
+      console.clear();
+      console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+      console.log(chalk.cyan.bold('Previously Answered Questions'));
+      console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+      let linesUsed = 0;
+      let displayedCount = 0;
+
+      // Calculate how many pairs fit
+      for (let i = currentIndex; i < pairs.length; i++) {
+        const pair = pairs[i];
+        const qNum = (i + 1).toString().padStart(2, '0');
+        
+        // Estimate lines: Question (2) + Answer lines + Spacing (2)
+        const answerLines = Math.ceil(pair.answer.length / (process.stdout.columns || 80));
+        const pairHeight = 2 + answerLines + 2;
+
+        if (linesUsed + pairHeight > availableHeight && displayedCount > 0) {
+          break;
+        }
+
+        console.log(chalk.white.bold(`Q-${qNum}: ${pair.question}`));
+        console.log(chalk.green(`A-${qNum}: ${pair.answer}`));
+        console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+        
+        linesUsed += pairHeight;
+        displayedCount++;
+      }
+
+      const nextIndex = currentIndex + displayedCount;
+      const isEnd = nextIndex >= pairs.length;
+
+      console.log('');
+      if (isEnd) {
+        console.log(chalk.yellow('End of review.'));
+      } else {
+        console.log(chalk.gray(`... ${pairs.length - nextIndex} more items ...`));
+      }
+
+      // Navigation prompt
+      const { action } = await inquirer.prompt([
+        {
+          type: 'expand',
+          name: 'action',
+          message: 'Navigation:',
+          choices: [
+            { key: ' ', name: 'Next page', value: 'next' },
+            { key: 'e', name: 'Edit an answer', value: 'edit' },
+            { key: 'c', name: 'Continue interview', value: 'continue' },
+            { key: 'q', name: 'Quit review (Back to menu)', value: 'back' },
+            { key: 'x', name: 'Exit CLI', value: 'exit' }
+          ],
+          default: isEnd ? 1 : 0 // Default to Continue if end, else Next
+        }
+      ]);
+
+      if (action === 'next') {
+        if (isEnd) return 'continue'; // 'Next' at end means continue
+        currentIndex = nextIndex;
+      } else if (action === 'continue') {
+        return 'continue';
+      } else if (action === 'back') {
+        return 'back';
+      } else if (action === 'exit') {
+        return 'exit';
+      } else if (action === 'edit') {
+        // Show list of currently visible questions to edit
+        const pagePairs = pairs.slice(currentIndex, nextIndex);
+        const { questionToEdit } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'questionToEdit',
+            message: 'Select a question to edit:',
+            choices: [
+              ...pagePairs.map((p, idx) => ({
+                name: p.question.length > 60 ? p.question.substring(0, 57) + '...' : p.question,
+                value: currentIndex + idx
+              })),
+              { name: '← Cancel', value: -1 }
+            ]
+          }
+        ]);
+
+        if (questionToEdit !== -1) {
+          const targetPair = pairs[questionToEdit];
+          
+          const { newAnswer } = await inquirer.prompt([
+            {
+              type: 'editor',
+              name: 'newAnswer',
+              message: 'Edit your answer:',
+              default: targetPair.answer
+            }
+          ]);
+
+          if (newAnswer && newAnswer.trim()) {
+            const trimmedAnswer = newAnswer.trim();
+            // Update local state
+            this.answers[targetPair.id] = trimmedAnswer;
+            pairs[questionToEdit].answer = trimmedAnswer;
+            
+            // Save progress
+            await this.progressTracker.updateAnswer(targetPair.id, trimmedAnswer);
+            
+            console.log(chalk.green('✓ Answer updated'));
+            await new Promise(r => setTimeout(r, 1000));
+          }
+        }
+      }
+    }
+
+    return 'continue';
+  }
+
   async promptAIConfiguration() {
     console.log(chalk.cyan.bold('━'.repeat(60)));
     console.log(chalk.cyan.bold('\n🤖 AI Provider Configuration (Pre-Interview)\n'));
@@ -557,11 +717,14 @@ class Interviewer {
           ? this.answers[question.id]
           : this.answers[question.id].text;
 
-        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.green(`\n✓ Already answered: ${question.text}`));
-        console.log(chalk.gray(`   Answer: ${answerText.substring(0, 80)}${answerText.length > 80 ? '...' : ''}\n`));
-        console.log(chalk.gray('━'.repeat(60)) + '\n');
+        const qNum = (i + 1).toString().padStart(2, '0');
+        
+        console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(chalk.cyan.bold('Previously Answered Questions'));
+        console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+        console.log(chalk.white.bold(`Q-${qNum}: ${question.text}`));
+        console.log(chalk.green(`A-${qNum}: ${answerText}`));
+        console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
 
         questionsAnswered++;
         continue;
@@ -640,13 +803,15 @@ class Interviewer {
     console.log(chalk.gray('─'.repeat(60)));
     console.log(chalk.yellow('💡 Type "skip" to skip • Type "exit" or press Ctrl+C to save & exit (resume with: adf init)'));
     console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.cyan('Your answer:'));
 
     const { answer } = await inquirer.prompt([
       {
         type: 'input',
         name: 'answer',
-        message: 'Your answer:',
-        prefix: ''
+        message: ' ',
+        prefix: '',
+        transformer: (input) => input
       }
     ]);
 
@@ -724,103 +889,130 @@ class Interviewer {
       });
     }
 
-    // Process answer with Dynamic Pipeline (Phase 4.4)
-    if (this.dynamicPipeline) {
-      await this.dynamicPipeline.processAnswer(question.id, question.text, answer);
-    }
+    const spinner = ora('Processing reply...').start();
+    const startTime = Date.now();
 
-    // Check if answer is comprehensive enough to skip follow-ups
-    if (qualityMetrics.canSkipFollowUps) {
-      console.log(chalk.green('\n✓ Saved\n'));
-      return answer;
-    }
+    try {
+      // Process answer with Dynamic Pipeline (Phase 4.4)
+      if (this.dynamicPipeline) {
+        await this.dynamicPipeline.processAnswer(question.id, question.text, answer);
+      }
 
-    // Check if answer needs follow-up (only if follow-up questions are enabled)
-    let followUp = null;
-
-    if (this.analysisConfig.features.followUpQuestions) {
-      // Try AI-generated follow-up first
-      if (this.aiClient && qualityMetrics.issues && qualityMetrics.issues.length > 0 && qualityMetrics.qualityScore < 70) {
-        try {
-          const aiFollowUp = await this.aiClient.generateFollowUp(question.text, answer, qualityMetrics.issues);
-          if (aiFollowUp) {
-            followUp = {
-              message: "Let me ask a more specific question:",
-              question: aiFollowUp
-            };
+      // Check if answer is comprehensive enough to skip follow-ups
+      if (qualityMetrics.canSkipFollowUps) {
+        // Ensure minimum 1s duration for UX consistency
+        const elapsed = Date.now() - startTime;
+        if (elapsed < 1000) {
+          await new Promise(resolve => setTimeout(resolve, 1000 - elapsed));
+        }
+        
+        spinner.succeed(chalk.green('Saved'));
+        console.log('');
+        return answer;
+      }
+
+      // Check if answer needs follow-up (only if follow-up questions are enabled)
+      let followUp = null;
+
+      if (this.analysisConfig.features.followUpQuestions) {
+        // Try AI-generated follow-up first
+        if (this.aiClient && qualityMetrics.issues && qualityMetrics.issues.length > 0 && qualityMetrics.qualityScore < 70) {
+          try {
+            const aiFollowUp = await this.aiClient.generateFollowUp(question.text, answer, qualityMetrics.issues);
+            if (aiFollowUp) {
+              followUp = {
+                message: "Let me ask a more specific question:",
+                question: aiFollowUp
+              };
+            }
+          } catch (error) {
+            // If AI fails, use heuristic fallback
+            followUp = this.determineFollowUp(question, answer);
           }
-        } catch (error) {
-          // If AI fails, use heuristic fallback
+        } else {
+          // Use heuristic follow-up
           followUp = this.determineFollowUp(question, answer);
         }
-      } else {
-        // Use heuristic follow-up
-        followUp = this.determineFollowUp(question, answer);
       }
-    }
 
-    if (followUp) {
-      console.log(chalk.yellow(`\n🤖 ${followUp.message}`));
-      console.log(chalk.yellow(`   ${followUp.question}\n`));
+      // Ensure minimum 1s duration for UX consistency
+      const elapsed = Date.now() - startTime;
+      if (elapsed < 1000) {
+        await new Promise(resolve => setTimeout(resolve, 1000 - elapsed));
+      }
 
-      console.log(chalk.gray('─'.repeat(60)));
-      console.log(chalk.yellow('💡 Type "exit" or press Ctrl+C to save & exit (resume with: adf init)'));
-      console.log(chalk.gray('─'.repeat(60)));
+      spinner.stop();
 
-      const { followUpAnswer } = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'followUpAnswer',
-          message: 'Follow-up answer:',
-          prefix: ''
-        }
-      ]);
+      if (followUp) {
+        console.log(chalk.yellow(`\n🤖 ${followUp.message}`));
+        console.log(chalk.yellow(`   ${followUp.question}\n`));
 
-      // Handle "exit" keyword - save progress and exit gracefully
-      if (followUpAnswer && followUpAnswer.toLowerCase().trim() === 'exit') {
-        console.log(chalk.yellow('\n💾 Saving progress and exiting...'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.yellow('💡 Type "exit" or press Ctrl+C to save & exit (resume with: adf init)'));
+        console.log(chalk.gray('─'.repeat(60)));
 
-        // Ensure progress is saved
-        if (this.progressTracker) {
-          await this.progressTracker.save();
-        }
+        console.log(chalk.cyan('Follow-up answer:'));
+        const { followUpAnswer } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'followUpAnswer',
+            message: ' ',
+            prefix: '',
+            transformer: (input) => input
+          }
+        ]);
 
-        console.log(chalk.green('✓ Progress saved!'));
-        console.log(chalk.cyan('Resume anytime with: adf init\n'));
-        process.exit(0);
-      }
+        // Handle "exit" keyword - save progress and exit gracefully
+        if (followUpAnswer && followUpAnswer.toLowerCase().trim() === 'exit') {
+          console.log(chalk.yellow('\n💾 Saving progress and exiting...'));
 
-      if (followUpAnswer && followUpAnswer.trim()) {
-        // Combine answers
-        const combined = `${answer} | Follow-up: ${followUpAnswer}`;
-
-        // Re-analyze combined answer
-        let combinedMetrics;
-        try {
-          if (this.aiClient) {
-            const aiAnalysis = await this.aiClient.analyzeAnswerQuality(question.text, combined);
-            combinedMetrics = {
-              wordCount: combined.trim().split(/\s+/).length,
-              qualityScore: aiAnalysis.score,
-              isComprehensive: aiAnalysis.score >= 70,
-              canSkipFollowUps: aiAnalysis.score >= 85
-            };
-          } else {
-            combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+          // Ensure progress is saved
+          if (this.progressTracker) {
+            await this.progressTracker.save();
           }
-        } catch {
-          combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+
+          console.log(chalk.green('✓ Progress saved!'));
+          console.log(chalk.cyan('Resume anytime with: adf init\n'));
+          process.exit(0);
         }
 
-        await this.progressTracker.answerQuestion(question.id, question.text, combined, combinedMetrics);
+        if (followUpAnswer && followUpAnswer.trim()) {
+          // Combine answers
+          const combined = `${answer} | Follow-up: ${followUpAnswer}`;
+
+          // Re-analyze combined answer
+          let combinedMetrics;
+          try {
+            if (this.aiClient) {
+              const aiAnalysis = await this.aiClient.analyzeAnswerQuality(question.text, combined);
+              combinedMetrics = {
+                wordCount: combined.trim().split(/\s+/).length,
+                qualityScore: aiAnalysis.score,
+                isComprehensive: aiAnalysis.score >= 70,
+                canSkipFollowUps: aiAnalysis.score >= 85
+              };
+            } else {
+              combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+            }
+          } catch {
+            combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+          }
+
+          await this.progressTracker.answerQuestion(question.id, question.text, combined, combinedMetrics);
 
-        console.log(chalk.green('\n✓ Saved\n'));
-        return combined;
+          console.log(chalk.green('\n✓ Saved\n'));
+          return combined;
+        }
       }
-    }
 
-    console.log(chalk.green('\n✓ Saved\n'));
-    return answer;
+      console.log(chalk.green('\n✓ Saved\n'));
+      return answer;
+
+    } catch (err) {
+      spinner.fail('Error processing reply');
+      console.error(err);
+      return answer; // Return original answer on error
+    }
   }
 
   determineFollowUp(question, answer) {

package/lib/frameworks/progress-tracker.js

@@ -147,6 +147,24 @@ class ProgressTracker {
     await this.saveWithBackup();
   }
 
+  async updateAnswer(questionId, newText) {
+    if (this.progress.answers[questionId]) {
+      // Update word count stats
+      const oldWordCount = this.progress.answers[questionId].quality.wordCount || 0;
+      const newWordCount = newText.trim().split(/\s+/).length;
+      this.progress.totalWordCount = this.progress.totalWordCount - oldWordCount + newWordCount;
+
+      this.progress.answers[questionId].text = newText;
+      this.progress.answers[questionId].timestamp = new Date().toISOString();
+      
+      // Update word count in quality metrics
+      this.progress.answers[questionId].quality.wordCount = newWordCount;
+      
+      this.progress.lastUpdated = new Date().toISOString();
+      await this.saveWithBackup();
+    }
+  }
+
   async saveWithBackup() {
     try {
       // Save 1: Main progress file