@iservu-inc/adf-cli 0.1.6 → 0.2.0

package/lib/commands/init.js

@@ -5,18 +5,33 @@ const chalk = require('chalk');
 const ora = require('ora');
 const {
   detectProjectType,
-  getWorkflowRecommendation,
-  generateContextFile
+  getWorkflowRecommendation
 } = require('../utils/project-detector');
-const { copyTemplates } = require('../utils/copy-templates');
+const Interviewer = require('../frameworks/interviewer');
+const SessionManager = require('../frameworks/session-manager');
 const { deployToTool } = require('./deploy');
 
 async function init(options) {
-  console.log(chalk.cyan.bold('\n🚀 AgentDevFramework Initialization\n'));
+  console.log(chalk.cyan.bold('\n🚀 AgentDevFramework - Software Development Requirements\n'));
 
   const cwd = process.cwd();
   const adfDir = path.join(cwd, '.adf');
 
+  // Check for resumable sessions FIRST (before asking to overwrite)
+  const sessionManager = new SessionManager(cwd);
+  const existingSession = await sessionManager.promptToResume();
+
+  if (existingSession) {
+    // Resume existing session
+    const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession);
+    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;
+  }
+
   // Check if already initialized
   if (await fs.pathExists(adfDir)) {
     const { overwrite } = await inquirer.prompt([
@@ -41,132 +56,59 @@ async function init(options) {
   const projectType = await detectProjectType(cwd);
   spinner.succeed(`Project type: ${chalk.green(projectType.type)}`);
 
-  // Determine workflow
+  // Determine workflow/framework
   let workflow;
 
   if (options.rapid) {
     workflow = 'rapid';
-    console.log(chalk.blue('Using Level 1 (Rapid Development) - from --rapid flag'));
+    console.log(chalk.blue('\nUsing: PRP Framework (Rapid Development) - from --rapid flag'));
   } else if (options.balanced) {
     workflow = 'balanced';
-    console.log(chalk.blue('Using Level 2 (Balanced) - from --balanced flag'));
+    console.log(chalk.blue('\nUsing: PRP + Spec-Kit (Balanced) - from --balanced flag'));
   } else if (options.comprehensive) {
     workflow = 'comprehensive';
-    console.log(chalk.blue('Using Level 3 (Comprehensive) - from --comprehensive flag'));
+    console.log(chalk.blue('\nUsing: BMAD Framework (Comprehensive) - from --comprehensive flag'));
   } else {
     // Interactive workflow selection
     workflow = await getWorkflowRecommendation(projectType);
   }
 
-  // Gather documentation URLs (optional)
-  const { hasDocs } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'hasDocs',
-      message: 'Do you have documentation URLs to include?',
-      default: false
-    }
-  ]);
-
-  let documentationUrls = [];
-  if (hasDocs) {
-    const { urls } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'urls',
-        message: 'Enter documentation URLs (comma-separated):',
-        filter: (input) => input.split(',').map(url => url.trim()).filter(Boolean)
-      }
-    ]);
-    documentationUrls = urls;
-  }
-
-  // Gather local documentation files (optional)
-  const { hasLocalDocs } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'hasLocalDocs',
-      message: 'Do you have local documentation files to include? (use "." as the project root folder & add like so "./docs/")',
-      default: false
-    }
-  ]);
+  // Create .adf directory
+  await fs.ensureDir(adfDir);
 
-  let documentationFiles = [];
-  if (hasLocalDocs) {
-    const { files } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'files',
-        message: 'Enter local documentation paths (comma-separated, e.g., ./docs/, ./README.md):',
-        filter: (input) => input.split(',').map(file => file.trim()).filter(Boolean)
-      }
-    ]);
-    documentationFiles = files;
-  }
+  // Start AI-guided interview
+  console.log(chalk.gray('\n' + '━'.repeat(60)) + '\n');
 
-  // Copy framework templates
-  const copySpinner = ora('Copying framework files...').start();
-  await copyTemplates(cwd);
-  copySpinner.succeed('Framework files copied to .adf/');
-
-  // Generate context file
-  const context = generateContextFile({
-    workflow,
-    projectType: projectType.type,
-    documentationUrls,
-    documentationFiles,
-    timestamp: new Date().toISOString()
-  });
-
-  await fs.writeJson(path.join(adfDir, 'context.json'), context, { spaces: 2 });
-  console.log(chalk.green('✓ Created .adf/context.json'));
-
-  // Copy .env.template to project root
-  const envTemplateSrc = path.join(__dirname, '../templates/.env.template');
-  const envTemplateDest = path.join(cwd, '.env.template');
-
-  if (await fs.pathExists(envTemplateSrc)) {
-    await fs.copy(envTemplateSrc, envTemplateDest);
-    console.log(chalk.green('✓ Created .env.template'));
-  }
+  const interviewer = new Interviewer(workflow, cwd);
+  const sessionPath = await interviewer.start();
 
-  // Deploy to tool if specified
-  let deployNow = false;
+  // Show next steps
+  console.log(chalk.cyan('📋 Next Steps:\n'));
+  console.log(chalk.gray(`  1. Review your requirements: ${sessionPath}/outputs/`));
+  console.log(chalk.gray(`  2. Share the output files with your AI coding assistant`));
+  console.log(chalk.gray(`  3. Start building based on the detailed requirements\n`));
 
+  // Optional: Deploy to tool
   if (options.tool) {
     console.log('');
     await deployToTool(options.tool, { silent: false });
-    deployNow = true;
   } else {
-    // Ask if they want to deploy now
-    const response = await inquirer.prompt([
+    const { deployNow } = await inquirer.prompt([
       {
         type: 'confirm',
         name: 'deployNow',
-        message: 'Deploy to a development tool now?',
-        default: true
+        message: 'Deploy framework to a development tool?',
+        default: false
       }
     ]);
 
-    deployNow = response.deployNow;
-
     if (deployNow) {
       const { tool } = await inquirer.prompt([
         {
           type: 'list',
           name: 'tool',
-          message: 'Select deployment tool:',
-          choices: [
-            'windsurf',
-            'cursor',
-            'vscode',
-            'vscode-insider',
-            'kiro',
-            'trae',
-            'claude-code',
-            'gemini-cli',
-            'codex-cli'
-          ]
+          message: 'Select tool:',
+          choices: ['windsurf', 'cursor', 'vscode', 'claude-code', 'gemini-cli']
         }
       ]);
 
@@ -175,21 +117,7 @@ async function init(options) {
     }
   }
 
-  // Success message
-  console.log(chalk.green.bold('\n✨ Initialization complete!\n'));
-
-  console.log(chalk.cyan('Next steps:'));
-  console.log(chalk.gray('  1. Review .adf/context.json'));
-  console.log(chalk.gray('  2. Copy .env.template to .env and configure'));
-  if (!deployNow) {
-    console.log(chalk.gray('  3. Run "adf deploy <tool>" to deploy to your editor'));
-    console.log(chalk.gray('  4. Check documentation: .adf/shared/templates/\n'));
-  } else {
-    console.log(chalk.gray('  3. Check documentation: .adf/shared/templates/\n'));
-  }
-
-  console.log(chalk.blue(`Workflow: ${workflow === 'rapid' ? 'Level 1 (Rapid)' : workflow === 'balanced' ? 'Level 2 (Balanced)' : 'Level 3 (Comprehensive)'}`));
-  console.log(chalk.gray('Run "adf deploy --list" to see available tools\n'));
+  console.log(chalk.green.bold('\n✅ All done! Happy coding! 🚀\n'));
 }
 
 module.exports = init;

package/lib/frameworks/answer-quality-analyzer.js

@@ -0,0 +1,216 @@
+/**
+ * Answer Quality Analyzer
+ * Evaluates answer richness and completeness to determine if follow-ups are needed
+ */
+
+class AnswerQualityAnalyzer {
+  /**
+   * Analyze answer quality and richness
+   * @param {string} answer - User's answer
+   * @param {object} question - Question metadata
+   * @returns {object} Quality metrics
+   */
+  static analyze(answer, question) {
+    const metrics = {
+      wordCount: this.getWordCount(answer),
+      hasKeywords: this.checkKeywords(answer, question.keywords || []),
+      hasRequiredElements: this.checkRequiredElements(answer, question.requiredElements || []),
+      isDetailed: this.checkDetailLevel(answer),
+      hasTechnicalDepth: this.checkTechnicalDepth(answer),
+      qualityScore: 0,
+      isComprehensive: false,
+      canSkipFollowUps: false
+    };
+
+    // Calculate quality score (0-100)
+    let score = 0;
+
+    // Word count scoring (up to 30 points)
+    if (metrics.wordCount >= 50) score += 30;
+    else if (metrics.wordCount >= 30) score += 20;
+    else if (metrics.wordCount >= 15) score += 10;
+
+    // Keyword presence (up to 20 points)
+    score += metrics.hasKeywords.score;
+
+    // Required elements (up to 25 points)
+    score += metrics.hasRequiredElements.score;
+
+    // Detail level (up to 15 points)
+    if (metrics.isDetailed.hasBulletPoints) score += 5;
+    if (metrics.isDetailed.hasMultipleSentences) score += 5;
+    if (metrics.isDetailed.hasExamples) score += 5;
+
+    // Technical depth (up to 10 points)
+    if (metrics.hasTechnicalDepth.hasTechStack) score += 5;
+    if (metrics.hasTechnicalDepth.hasVersions) score += 5;
+
+    metrics.qualityScore = Math.min(score, 100);
+
+    // Determine if answer is comprehensive enough
+    metrics.isComprehensive = metrics.qualityScore >= 70;
+    metrics.canSkipFollowUps = metrics.qualityScore >= 85;
+
+    return metrics;
+  }
+
+  static getWordCount(answer) {
+    return answer.trim().split(/\s+/).length;
+  }
+
+  static checkKeywords(answer, keywords) {
+    const lowerAnswer = answer.toLowerCase();
+    const matchedKeywords = keywords.filter(kw => lowerAnswer.includes(kw.toLowerCase()));
+
+    return {
+      matched: matchedKeywords,
+      count: matchedKeywords.length,
+      total: keywords.length,
+      score: keywords.length > 0 ? Math.round((matchedKeywords.length / keywords.length) * 20) : 0
+    };
+  }
+
+  static checkRequiredElements(answer, requiredElements) {
+    const lowerAnswer = answer.toLowerCase();
+    const detectedElements = [];
+
+    // Platform detection
+    if (requiredElements.includes('platform')) {
+      const platforms = ['web', 'mobile', 'desktop', 'api', 'backend', 'frontend', 'fullstack', 'cli', 'ios', 'android'];
+      if (platforms.some(p => lowerAnswer.includes(p))) {
+        detectedElements.push('platform');
+      }
+    }
+
+    // Technology detection
+    if (requiredElements.includes('technology')) {
+      const techs = ['react', 'vue', 'angular', 'node', 'python', 'java', 'typescript', 'javascript', 'next', 'django', 'rails', 'express', 'fastapi', 'spring', 'laravel', '.net', 'go', 'rust'];
+      if (techs.some(t => lowerAnswer.includes(t))) {
+        detectedElements.push('technology');
+      }
+    }
+
+    // User interaction detection
+    if (requiredElements.includes('user-interaction')) {
+      const actions = ['click', 'submit', 'add', 'create', 'update', 'delete', 'view', 'search', 'filter', 'upload', 'download', 'form', 'button'];
+      if (actions.some(a => lowerAnswer.includes(a))) {
+        detectedElements.push('user-interaction');
+      }
+    }
+
+    // Problem statement detection
+    if (requiredElements.includes('problem-statement')) {
+      const problemWords = ['problem', 'issue', 'challenge', 'pain', 'difficult', 'struggle', 'frustrat', 'miss', 'lose', 'lack'];
+      if (problemWords.some(p => lowerAnswer.includes(p))) {
+        detectedElements.push('problem-statement');
+      }
+    }
+
+    // Measurable outcome detection
+    if (requiredElements.includes('measurable-outcome')) {
+      const metrics = ['%', 'percent', 'increase', 'decrease', 'reduce', 'save', 'improve', 'time', 'hour', 'day', 'week', 'user', 'metric', 'kpi', 'measure'];
+      if (metrics.some(m => lowerAnswer.includes(m))) {
+        detectedElements.push('measurable-outcome');
+      }
+    }
+
+    // File paths detection
+    if (requiredElements.includes('file-paths')) {
+      const pathPatterns = [/[./]\w+\/\w+/, /src\//, /app\//, /components\//, /\.ts/, /\.js/, /\.jsx/, /\.tsx/, /\.py/];
+      if (pathPatterns.some(p => p.test(answer))) {
+        detectedElements.push('file-paths');
+      }
+    }
+
+    // Data structure detection
+    if (requiredElements.includes('data-structure')) {
+      const dataWords = ['table', 'schema', 'entity', 'model', 'field', 'column', 'database', 'collection', 'document', 'id', 'foreign key'];
+      if (dataWords.some(d => lowerAnswer.includes(d))) {
+        detectedElements.push('data-structure');
+      }
+    }
+
+    // API endpoints detection
+    if (requiredElements.includes('api-endpoints')) {
+      const apiPatterns = [/GET|POST|PUT|PATCH|DELETE/, /\/api\//, /endpoint/, /route/, /rest/, /graphql/i];
+      if (apiPatterns.some(p => p.test(answer))) {
+        detectedElements.push('api-endpoints');
+      }
+    }
+
+    return {
+      detected: detectedElements,
+      count: detectedElements.length,
+      total: requiredElements.length,
+      score: requiredElements.length > 0 ? Math.round((detectedElements.length / requiredElements.length) * 25) : 0
+    };
+  }
+
+  static checkDetailLevel(answer) {
+    return {
+      hasBulletPoints: /[-*•]\s/.test(answer) || /\n\d+\./.test(answer),
+      hasMultipleSentences: answer.split(/[.!?]+/).filter(s => s.trim().length > 10).length >= 2,
+      hasExamples: /example|e\.g\.|such as|like|for instance/i.test(answer),
+      hasCodeReferences: /`[^`]+`|```/.test(answer),
+      hasUrls: /https?:\/\//.test(answer)
+    };
+  }
+
+  static checkTechnicalDepth(answer) {
+    return {
+      hasTechStack: /(react|vue|angular|node|python|java|typescript|next|django|rails)/i.test(answer),
+      hasVersions: /\d+\.\d+|\bv\d+/i.test(answer),
+      hasSpecificTools: /(npm|yarn|pip|maven|gradle|docker|kubernetes|aws|azure|gcp)/i.test(answer),
+      hasFileExtensions: /\.(js|ts|jsx|tsx|py|java|go|rs|rb|php)/.test(answer)
+    };
+  }
+
+  /**
+   * Determine if subsequent questions can be skipped based on answer quality
+   * @param {object} metrics - Quality metrics from analyze()
+   * @param {array} upcomingQuestions - Questions that might be skipped
+   * @returns {array} Questions that can be safely skipped
+   */
+  static determineSkippableQuestions(metrics, upcomingQuestions) {
+    if (!metrics.isComprehensive) {
+      return []; // Not comprehensive enough to skip anything
+    }
+
+    const skippable = [];
+    const detectedInfo = new Set([
+      ...metrics.hasKeywords.matched,
+      ...metrics.hasRequiredElements.detected
+    ]);
+
+    upcomingQuestions.forEach(q => {
+      // If this question asks for info we already have, it's skippable
+      if (q.requiredElements) {
+        const alreadyHave = q.requiredElements.every(elem => detectedInfo.has(elem));
+        if (alreadyHave && metrics.qualityScore >= 85) {
+          skippable.push(q.id);
+        }
+      }
+    });
+
+    return skippable;
+  }
+
+  /**
+   * Generate feedback message for user based on answer quality
+   * @param {object} metrics - Quality metrics
+   * @returns {string} Feedback message
+   */
+  static getFeedback(metrics) {
+    if (metrics.qualityScore >= 90) {
+      return '🌟 Excellent! Very comprehensive answer.';
+    } else if (metrics.qualityScore >= 70) {
+      return '✓ Great! Good level of detail.';
+    } else if (metrics.qualityScore >= 50) {
+      return '👍 Good start.';
+    } else {
+      return null; // Will trigger follow-up questions
+    }
+  }
+}
+
+module.exports = AnswerQualityAnalyzer;