@iservu-inc/adf-cli 0.2.0 → 0.3.6

package/lib/commands/deploy.js

@@ -2,6 +2,12 @@ const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
+const {
+  generateAgentsMd,
+  generateWindsurf,
+  generateCursor,
+  generateVSCode
+} = require('../generators');
 
 const TOOLS = {
   windsurf: { name: 'Windsurf', configFile: '.windsurfrules' },
@@ -15,6 +21,60 @@ const TOOLS = {
   'codex-cli': { name: 'Codex CLI', configFile: '.codex/config.json' }
 };
 
+/**
+ * Find the latest completed session
+ */
+async function findLatestSession(cwd) {
+  const sessionsDir = path.join(cwd, '.adf', 'sessions');
+
+  if (!await fs.pathExists(sessionsDir)) {
+    return null;
+  }
+
+  const sessions = await fs.readdir(sessionsDir);
+  if (sessions.length === 0) {
+    return null;
+  }
+
+  // Find most recent session with outputs
+  let latestSession = null;
+  let latestTime = 0;
+
+  for (const sessionId of sessions) {
+    const sessionPath = path.join(sessionsDir, sessionId);
+    const outputsPath = path.join(sessionPath, 'outputs');
+
+    if (await fs.pathExists(outputsPath)) {
+      const stats = await fs.stat(sessionPath);
+      if (stats.mtimeMs > latestTime) {
+        latestTime = stats.mtimeMs;
+        latestSession = sessionPath;
+      }
+    }
+  }
+
+  return latestSession;
+}
+
+/**
+ * Get framework type from session metadata
+ */
+async function getFrameworkFromSession(sessionPath) {
+  const metadataPath = path.join(sessionPath, '_metadata.json');
+  if (await fs.pathExists(metadataPath)) {
+    const metadata = await fs.readJson(metadataPath);
+    return metadata.framework;
+  }
+
+  const progressPath = path.join(sessionPath, '_progress.json');
+  if (await fs.pathExists(progressPath)) {
+    const progress = await fs.readJson(progressPath);
+    return progress.framework;
+  }
+
+  return 'balanced'; // Default fallback
+}
+
 async function deployToTool(tool, options = {}) {
   const cwd = process.cwd();
   const adfDir = path.join(cwd, '.adf');
@@ -26,22 +86,80 @@ async function deployToTool(tool, options = {}) {
     process.exit(1);
   }
 
-  // Read context to get workflow
+  // Find latest session
+  const sessionPath = await findLatestSession(cwd);
+  if (!sessionPath) {
+    console.error(chalk.red('\n❌ Error: No completed sessions found.'));
+    console.log(chalk.yellow('Run "adf init" to create requirements first.\n'));
+    process.exit(1);
+  }
+
+  const framework = await getFrameworkFromSession(sessionPath);
+
+  // Read context to get workflow (legacy support)
   const contextPath = path.join(adfDir, 'context.json');
   let context = {};
   if (await fs.pathExists(contextPath)) {
     context = await fs.readJson(contextPath);
   }
 
-  const workflow = context.workflow || 'balanced';
+  const workflow = framework || context.workflow || 'balanced';
 
-  // Deploy logic (simplified - will be implemented based on actual deploy script)
   const spinner = options.silent ? null : ora(`Deploying to ${TOOLS[tool]?.name || tool}...`).start();
 
   try {
+    // Generate AGENTS.md (universal standard)
+    if (!options.silent) {
+      if (spinner) spinner.text = 'Generating AGENTS.md...';
+    }
+
+    try {
+      await generateAgentsMd(sessionPath, cwd, framework);
+      if (!options.silent && !spinner) {
+        console.log(chalk.green('✓ Generated AGENTS.md'));
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate AGENTS.md: ${error.message}`));
+    }
+
+    // Generate tool-specific configurations
+    if (spinner) spinner.text = `Generating ${TOOLS[tool]?.name || tool} configurations...`;
+
+    try {
+      let generatedFiles = {};
+
+      if (tool === 'windsurf') {
+        generatedFiles = await generateWindsurf(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Windsurf configurations'));
+          console.log(chalk.gray(`  - .windsurfrules (legacy)`));
+          console.log(chalk.gray(`  - .windsurf/rules/*.md (${generatedFiles.rules?.length || 0} files)`));
+          console.log(chalk.gray(`  - .windsurf/workflows/*.md (${generatedFiles.workflows?.length || 0} files)`));
+        }
+      } else if (tool === 'cursor') {
+        generatedFiles = await generateCursor(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Cursor configurations'));
+          console.log(chalk.gray(`  - .cursor/rules`));
+          console.log(chalk.gray(`  - .cursorrules (deprecation notice)`));
+        }
+      } else if (tool === 'vscode' || tool === 'vscode-insider') {
+        generatedFiles = await generateVSCode(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated VS Code configurations'));
+          console.log(chalk.gray(`  - .github/copilot-instructions.md`));
+          console.log(chalk.gray(`  - .vscode/settings.json (custom chat modes)`));
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate ${TOOLS[tool]?.name || tool} configurations: ${error.message}`));
+    }
+
     // Get agents based on workflow
     const agentsList = getAgentsForWorkflow(workflow);
 
+    if (spinner) spinner.text = `Deploying to ${TOOLS[tool]?.name || tool}...`;
+
     // Copy agents
     const agentsDir = path.join(cwd, '.framework', 'agents');
     await fs.ensureDir(agentsDir);
@@ -82,6 +200,7 @@ async function deployToTool(tool, options = {}) {
     }
 
     if (!options.silent) {
+      console.log(chalk.gray(`  Generated: AGENTS.md (universal AI agent config)`));
       console.log(chalk.gray(`  Agents: ${agentsList.join(', ')}`));
       console.log(chalk.gray(`  Config: ${toolConfig?.configFile || 'N/A'}\n`));
     }

package/lib/commands/init.js

@@ -10,6 +10,7 @@ const {
 const Interviewer = require('../frameworks/interviewer');
 const SessionManager = require('../frameworks/session-manager');
 const { deployToTool } = require('./deploy');
+const { configureAIProvider, loadEnvIntoProcess, getEnvFilePath } = require('../ai/ai-config');
 
 async function init(options) {
   console.log(chalk.cyan.bold('\n🚀 AgentDevFramework - Software Development Requirements\n'));
@@ -17,13 +18,41 @@ async function init(options) {
   const cwd = process.cwd();
   const adfDir = path.join(cwd, '.adf');
 
+  // Load .env file if it exists (for API keys)
+  const envPath = getEnvFilePath(cwd);
+  if (await fs.pathExists(envPath)) {
+    loadEnvIntoProcess(envPath);
+  }
+
   // 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);
+    // Check if session has AI config (from resumed session)
+    let aiConfig = existingSession.progress.aiConfig;
+
+    if (aiConfig) {
+      // We have AI config from session, but need to verify API key exists
+      const apiKey = process.env[aiConfig.envVar];
+      if (!apiKey) {
+        console.log(chalk.yellow(`\n⚠️  Previous session used ${aiConfig.providerName}`));
+        console.log(chalk.yellow(`Please configure API key to resume...\n`));
+        aiConfig = await configureAIProvider(cwd);
+      } else {
+        // Add API key to config (it's not stored in session for security)
+        aiConfig.apiKey = apiKey;
+        console.log(chalk.green(`\n✓ Resuming with ${aiConfig.providerName} (${aiConfig.model})\n`));
+      }
+    } else {
+      // Old session without AI config, configure now
+      console.log(chalk.yellow('\n⚠️  This session was created before AI provider integration.'));
+      console.log(chalk.yellow('Please configure AI provider to continue...\n'));
+      aiConfig = await configureAIProvider(cwd);
+    }
+
+    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'));
@@ -76,17 +105,34 @@ async function init(options) {
   // Create .adf directory
   await fs.ensureDir(adfDir);
 
-  // Start AI-guided interview
+  // Configure AI Provider (OPTIONAL - can be done later with 'adf config')
+  let aiConfig = null;
+
+  const { configureAI } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'configureAI',
+      message: 'Configure AI provider now? (Enables intelligent follow-up questions)',
+      default: true
+    }
+  ]);
+
+  if (configureAI) {
+    aiConfig = await configureAIProvider(cwd);
+  } else {
+    console.log(chalk.yellow('\n💡 You can configure AI later by running: adf config\n'));
+  }
+
+  // Start interview (with or without AI)
   console.log(chalk.gray('\n' + '━'.repeat(60)) + '\n');
 
-  const interviewer = new Interviewer(workflow, cwd);
+  const interviewer = new Interviewer(workflow, cwd, null, aiConfig);
   const sessionPath = await interviewer.start();
 
-  // 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`));
+  // Show completion message
+  console.log(chalk.cyan('📋 Requirements Complete!\n'));
+  console.log(chalk.gray(`  ✓ Files saved to: ${sessionPath}/outputs/`));
+  console.log(chalk.gray(`  ✓ You can review your requirements anytime\n`));
 
   // Optional: Deploy to tool
   if (options.tool) {
@@ -97,8 +143,8 @@ async function init(options) {
       {
         type: 'confirm',
         name: 'deployNow',
-        message: 'Deploy framework to a development tool?',
-        default: false
+        message: 'Automatically deploy to your IDE? (I\'ll configure everything for you)',
+        default: true
       }
     ]);
 

package/lib/frameworks/interviewer.js

@@ -13,9 +13,10 @@ const AnswerQualityAnalyzer = require('./answer-quality-analyzer');
  */
 
 class Interviewer {
-  constructor(framework, projectPath, existingSession = null) {
+  constructor(framework, projectPath, existingSession = null, aiConfig = null) {
     this.framework = framework;
     this.projectPath = projectPath;
+    this.aiConfig = aiConfig;  // Store AI configuration
 
     if (existingSession) {
       // Resuming existing session
@@ -24,6 +25,8 @@ class Interviewer {
       this.answers = existingSession.progress.answers || {};
       this.transcript = existingSession.progress.transcript || [];
       this.isResuming = true;
+      // Use stored AI config from session if available
+      this.aiConfig = existingSession.progress.aiConfig || aiConfig;
     } else {
       // New session
       this.sessionId = this.generateSessionId();
@@ -34,6 +37,7 @@ class Interviewer {
     }
 
     this.progressTracker = null;
+    this.aiClient = null;  // Will be initialized in start()
   }
 
   generateSessionId() {
@@ -48,6 +52,16 @@ class Interviewer {
     console.log(chalk.gray(`Session: ${this.sessionId}`));
     console.log(chalk.gray(`Files will be saved to: .adf/sessions/${this.sessionId}/\n`));
 
+    // Initialize AI Client
+    if (!this.aiClient && this.aiConfig) {
+      const AIClient = require('../ai/ai-client');
+      this.aiClient = new AIClient(this.aiConfig);
+      console.log(chalk.green(`✓ AI Provider: ${this.aiConfig.providerName} (${this.aiConfig.model})\n`));
+    } else if (!this.aiConfig) {
+      console.log(chalk.red('\n✖ Error: No AI configuration provided. Cannot start interview.\n'));
+      process.exit(1);
+    }
+
     // Create session directory
     await fs.ensureDir(this.sessionPath);
     await fs.ensureDir(path.join(this.sessionPath, 'qa-responses'));
@@ -60,7 +74,7 @@ class Interviewer {
     const questionBlocks = this.groupQuestionsIntoBlocks(questions);
 
     // Initialize progress tracker
-    this.progressTracker = new ProgressTracker(this.sessionPath, questionBlocks.length, this.framework);
+    this.progressTracker = new ProgressTracker(this.sessionPath, questionBlocks.length, this.framework, this.aiConfig);
     const isResumable = await this.progressTracker.initialize();
 
     if (isResumable && this.isResuming) {
@@ -250,7 +264,8 @@ class Interviewer {
     // Show guidance
     console.log(chalk.gray(`💡 ${question.guidance}`));
     console.log(chalk.green(`   ✓ Good: ${question.goodExample}`));
-    console.log(chalk.red(`   ✗ Bad: ${question.badExample}\n`));
+    console.log(chalk.red(`   ✗ Bad: ${question.badExample}`));
+    console.log(chalk.gray(`   (Type "skip" to skip remaining questions in this block)\n`));
 
     // Get answer
     const { answer } = await inquirer.prompt([
@@ -260,7 +275,7 @@ class Interviewer {
         message: 'Your answer:',
         validate: (input) => {
           if (!input || input.trim().length === 0) {
-            return 'Please provide an answer or type "skip" to skip remaining questions in this block';
+            return 'Please provide an answer or type "skip"';
           }
           return true;
         }
@@ -271,13 +286,41 @@ class Interviewer {
       return null; // Signal to skip remaining questions
     }
 
-    // Analyze answer quality
-    const qualityMetrics = AnswerQualityAnalyzer.analyze(answer, question);
+    // Analyze answer quality (use AI if available, fallback to heuristic)
+    let qualityMetrics;
+    try {
+      if (this.aiClient) {
+        const aiAnalysis = await this.aiClient.analyzeAnswerQuality(question.text, answer);
+        qualityMetrics = {
+          wordCount: answer.trim().split(/\s+/).length,
+          qualityScore: aiAnalysis.score,
+          isComprehensive: aiAnalysis.score >= 70,
+          canSkipFollowUps: aiAnalysis.score >= 85,
+          issues: aiAnalysis.issues,
+          suggestions: aiAnalysis.suggestions,
+          missingElements: aiAnalysis.missingElements
+        };
+      } else {
+        // Fallback to heuristic analysis
+        qualityMetrics = AnswerQualityAnalyzer.analyze(answer, question);
+      }
+    } catch (error) {
+      // If AI analysis fails, use heuristic
+      console.log(chalk.yellow(`⚠️  AI analysis failed, using fallback method`));
+      qualityMetrics = AnswerQualityAnalyzer.analyze(answer, question);
+    }
 
     // Show quality feedback
-    const feedback = AnswerQualityAnalyzer.getFeedback(qualityMetrics);
-    if (feedback) {
-      console.log(chalk.cyan(`${feedback}`));
+    if (qualityMetrics.issues && qualityMetrics.issues.length > 0 && qualityMetrics.qualityScore < 70) {
+      console.log(chalk.yellow(`\n💡 Quality: ${qualityMetrics.qualityScore}/100`));
+      if (qualityMetrics.suggestions && qualityMetrics.suggestions.length > 0) {
+        console.log(chalk.gray(`   Suggestion: ${qualityMetrics.suggestions[0]}`));
+      }
+    } else {
+      const feedback = AnswerQualityAnalyzer.getFeedback(qualityMetrics);
+      if (feedback) {
+        console.log(chalk.cyan(`${feedback}`));
+      }
     }
 
     // Track answer with quality metrics
@@ -290,7 +333,26 @@ class Interviewer {
     }
 
     // Check if answer needs follow-up
-    const followUp = this.determineFollowUp(question, answer);
+    let followUp = null;
+
+    // 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);
+      }
+    } else {
+      // Use heuristic follow-up
+      followUp = this.determineFollowUp(question, answer);
+    }
 
     if (followUp) {
       console.log(chalk.yellow(`\n🤖 ${followUp.message}\n`));
@@ -308,7 +370,23 @@ class Interviewer {
         const combined = `${answer} | Follow-up: ${followUpAnswer}`;
 
         // Re-analyze combined answer
-        const combinedMetrics = AnswerQualityAnalyzer.analyze(combined, question);
+        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'));

package/lib/frameworks/progress-tracker.js

@@ -8,7 +8,7 @@ const chalk = require('chalk');
  */
 
 class ProgressTracker {
-  constructor(sessionPath, totalBlocks, framework = null) {
+  constructor(sessionPath, totalBlocks, framework = null, aiConfig = null) {
     this.sessionPath = sessionPath;
     this.progressFile = path.join(sessionPath, '_progress.json');
     this.progressBackupFile = path.join(sessionPath, '_progress.backup.json');
@@ -17,6 +17,13 @@ class ProgressTracker {
     this.progress = {
       sessionId: path.basename(sessionPath),
       framework: framework, // Store framework for resume
+      aiConfig: aiConfig ? {
+        provider: aiConfig.provider,
+        providerName: aiConfig.providerName,
+        model: aiConfig.model,
+        envVar: aiConfig.envVar
+        // Note: We don't store the API key for security
+      } : null,
       status: 'in-progress',
       startedAt: new Date().toISOString(),
       lastUpdated: new Date().toISOString(),