@iservu-inc/adf-cli 0.4.35 → 0.5.0

package/lib/generators/vscode-generator.js

@@ -41,7 +41,7 @@ class VSCodeGenerator extends ToolConfigGenerator {
     await this.ensureDir('.github');
 
     const content = this.framework === 'rapid' ?
-      this.generateCopilotPRP() :
+      await this.generateCopilotPRP() :
       this.framework === 'balanced' ?
       this.generateCopilotBalanced() :
       this.generateCopilotBMAD();
@@ -49,23 +49,41 @@ class VSCodeGenerator extends ToolConfigGenerator {
     return await this.writeToProject('.github/copilot-instructions.md', content);
   }
 
-  generateCopilotPRP() {
+  async generateCopilotPRP() {
     const projectName = this.getProjectName();
     const sections = this.outputs.sections || {};
+    const answers = await this.loadSessionAnswers();
+
+    // Extract content with fallback to answers
+    let goal = sections['1._goal_definition'] || sections['goal_definition'];
+    let techStack = this.extractTechStack(sections);
+    let blueprint = sections['4._implementation_blueprint'] || sections['implementation_blueprint'];
+    let validation = sections['5._validation'] || sections['validation'];
+
+    // Fallback to extracted answers if sections are empty
+    if (!goal || goal.length < 20) {
+      const whatBuilding = this.extractWhatBuildingFromAnswers(answers);
+      if (whatBuilding) goal = whatBuilding;
+    }
+
+    if (!techStack || techStack.includes('See framework')) {
+      const techFromAnswers = this.extractTechStackFromAnswers(answers);
+      if (techFromAnswers) techStack = techFromAnswers;
+    }
 
     return `# Copilot Instructions for ${projectName}
 
 ## Project Overview
 
-${sections['1._goal_definition'] || sections['goal_definition'] || 'Software development project'}
+${goal || 'Software development project'}
 
 ## Tech Stack
 
-${this.extractTechStack(sections)}
+${techStack || 'See PRP for tech stack'}
 
 ## Implementation Blueprint
 
-${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || 'See PRP for details'}
+${blueprint || 'See PRP for implementation details'}
 
 ## Code Style
 
@@ -91,7 +109,7 @@ ${sections['4._implementation_blueprint'] || sections['implementation_blueprint'
 
 ## Success Criteria
 
-${sections['5._validation'] || sections['validation'] || 'See PRP'}
+${validation || 'See PRP for validation criteria'}
 
 Ensure all code meets these criteria before considering it complete.
 
@@ -398,6 +416,57 @@ ${this.extractSection(prd, 'Performance') || '- Optimize critical paths\n- Monit
       return '0.3.0';
     }
   }
+
+  /**
+   * Load session answers from _progress.json
+   */
+  async loadSessionAnswers() {
+    const progressPath = path.join(this.sessionPath, '_progress.json');
+
+    try {
+      if (await fs.pathExists(progressPath)) {
+        const progress = await fs.readJson(progressPath);
+        return progress.answers || {};
+      }
+    } catch (error) {
+      // Fall back to empty if can't load
+    }
+
+    return {};
+  }
+
+  /**
+   * Extract tech stack from any answer
+   */
+  extractTechStackFromAnswers(answers) {
+    for (const [questionId, answer] of Object.entries(answers)) {
+      if (typeof answer === 'string') {
+        const lower = answer.toLowerCase();
+        if (lower.includes('react') || lower.includes('vue') || lower.includes('angular') ||
+            lower.includes('node') || lower.includes('python') || lower.includes('next') ||
+            lower.includes('postgres') || lower.includes('mongo') || lower.includes('mysql')) {
+          return answer;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Extract "what are you building" from any answer
+   */
+  extractWhatBuildingFromAnswers(answers) {
+    for (const [questionId, answer] of Object.entries(answers)) {
+      if (questionId.toLowerCase().includes('goal') ||
+          questionId.toLowerCase().includes('building') ||
+          questionId.toLowerCase().includes('project')) {
+        if (typeof answer === 'string' && answer.length > 20) {
+          return answer;
+        }
+      }
+    }
+    return null;
+  }
 }
 
 module.exports = VSCodeGenerator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.4.35",
+  "version": "0.5.0",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework with multi-provider AI support",
   "main": "index.js",
   "bin": {

package/tests/answer-analyzer.test.js

@@ -0,0 +1,262 @@
+const AnswerAnalyzer = require('../lib/analysis/answer-analyzer');
+
+describe('AnswerAnalyzer', () => {
+  let analyzer;
+  let mockAIClient;
+
+  beforeEach(() => {
+    mockAIClient = {
+      sendMessage: jest.fn()
+    };
+    analyzer = new AnswerAnalyzer(mockAIClient);
+  });
+
+  describe('heuristicExtraction', () => {
+    it('should extract tech stack from answer', () => {
+      const answer = 'I am building a React frontend with PostgreSQL database and Node.js backend';
+      const questionId = 'what-building';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack).toBeDefined();
+      expect(techStack.extractedTerms).toContain('react');
+      expect(techStack.extractedTerms).toContain('postgresql');
+      expect(techStack.extractedTerms).toContain('node');
+      expect(techStack.confidence).toBeGreaterThan(60);
+    });
+
+    it('should extract architecture patterns', () => {
+      const answer = 'I will build a frontend with a separate backend API using microservices';
+      const questionId = 'architecture';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const frontendBackend = extracted.find(e =>
+        e.type === 'architecture' && e.pattern === 'frontend-backend-separation'
+      );
+      const microservices = extracted.find(e =>
+        e.type === 'architecture' && e.pattern === 'microservices'
+      );
+
+      expect(frontendBackend).toBeDefined();
+      expect(microservices).toBeDefined();
+      expect(frontendBackend.confidence).toBeGreaterThan(70);
+    });
+
+    it('should extract platform information', () => {
+      const answer = 'This is a mobile app for iOS and Android using React Native';
+      const questionId = 'platform';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const platform = extracted.find(e => e.type === 'platform');
+      expect(platform).toBeDefined();
+      expect(platform.platform).toBe('mobile');
+      expect(platform.confidence).toBeGreaterThan(70);
+    });
+
+    it('should extract project goal from goal questions', () => {
+      const answer = 'Create a social media platform for developers to share code snippets';
+      const questionId = 'what-is-goal';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const goal = extracted.find(e => e.type === 'project_goal');
+      expect(goal).toBeDefined();
+      expect(goal.confidence).toBe(95);
+      expect(goal.content).toBe(answer);
+    });
+
+    it('should extract timeline information', () => {
+      const answer = 'I need this completed in 3 weeks for a product launch';
+      const questionId = 'timeline';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const timeline = extracted.find(e => e.type === 'timeline');
+      expect(timeline).toBeDefined();
+      expect(timeline.confidence).toBeGreaterThan(70);
+    });
+
+    it('should extract target users', () => {
+      const answer = 'The target audience is small businesses and their customers';
+      const questionId = 'users';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const users = extracted.find(e => e.type === 'target_users');
+      expect(users).toBeDefined();
+      expect(users.confidence).toBe(70);
+    });
+
+    it('should return empty array for uninformative answers', () => {
+      const answer = 'yes';
+      const questionId = 'question';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      expect(extracted).toEqual([]);
+    });
+
+    it('should handle multiple tech mentions with higher confidence', () => {
+      const answer = 'Using React, Next.js, TypeScript, PostgreSQL, Redis, and AWS';
+      const questionId = 'tech';
+
+      const extracted = analyzer.heuristicExtraction(answer, questionId);
+
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack).toBeDefined();
+      expect(techStack.extractedTerms.length).toBeGreaterThanOrEqual(5);
+      expect(techStack.confidence).toBeGreaterThan(80);
+    });
+  });
+
+  describe('aiExtraction', () => {
+    it('should extract information using AI when available', async () => {
+      const mockAIResponse = JSON.stringify([
+        {
+          type: 'tech_stack',
+          content: 'React and PostgreSQL',
+          confidence: 95,
+          reasoning: 'Explicitly mentioned'
+        },
+        {
+          type: 'architecture',
+          content: 'separate backend API',
+          confidence: 85,
+          reasoning: 'Implies frontend-backend separation'
+        }
+      ]);
+
+      mockAIClient.sendMessage.mockResolvedValue(mockAIResponse);
+
+      const extracted = await analyzer.aiExtraction(
+        'What tech stack?',
+        'React frontend with separate backend API using PostgreSQL',
+        'tech-stack'
+      );
+
+      expect(mockAIClient.sendMessage).toHaveBeenCalled();
+      expect(extracted).toHaveLength(2);
+      expect(extracted[0].type).toBe('tech_stack');
+      expect(extracted[0].method).toBe('ai');
+      expect(extracted[0].source).toBe('tech-stack');
+    });
+
+    it('should handle AI extraction errors gracefully', async () => {
+      mockAIClient.sendMessage.mockRejectedValue(new Error('AI error'));
+
+      const extracted = await analyzer.aiExtraction(
+        'What are you building?',
+        'A web app',
+        'goal'
+      );
+
+      expect(extracted).toEqual([]);
+    });
+
+    it('should handle invalid JSON from AI', async () => {
+      mockAIClient.sendMessage.mockResolvedValue('This is not JSON');
+
+      const extracted = await analyzer.aiExtraction(
+        'What tech?',
+        'React and Node',
+        'tech'
+      );
+
+      expect(extracted).toEqual([]);
+    });
+  });
+
+  describe('analyzeAnswer', () => {
+    it('should combine heuristic and AI results', async () => {
+      const mockAIResponse = JSON.stringify([
+        {
+          type: 'tech_stack',
+          content: 'React and Node.js',
+          confidence: 90,
+          reasoning: 'Explicitly stated'
+        }
+      ]);
+
+      mockAIClient.sendMessage.mockResolvedValue(mockAIResponse);
+
+      const extracted = await analyzer.analyzeAnswer(
+        'What tech stack?',
+        'I will use React for frontend and Node.js for backend',
+        'tech-stack'
+      );
+
+      expect(extracted.length).toBeGreaterThan(0);
+      // Should have at least tech_stack from both methods
+      const techStackItems = extracted.filter(e => e.type === 'tech_stack');
+      expect(techStackItems.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should use AI result if confidence is higher', async () => {
+      const mockAIResponse = JSON.stringify([
+        {
+          type: 'tech_stack',
+          content: 'Full tech stack analysis',
+          confidence: 95,
+          reasoning: 'Comprehensive analysis'
+        }
+      ]);
+
+      mockAIClient.sendMessage.mockResolvedValue(mockAIResponse);
+
+      const extracted = await analyzer.analyzeAnswer(
+        'What tech?',
+        'React and Node',
+        'tech'
+      );
+
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack.confidence).toBeGreaterThanOrEqual(85);
+    });
+
+    it('should work without AI client', async () => {
+      const analyzerWithoutAI = new AnswerAnalyzer(null);
+
+      const extracted = await analyzerWithoutAI.analyzeAnswer(
+        'What are you building?',
+        'A React web application with PostgreSQL database',
+        'goal'
+      );
+
+      expect(extracted.length).toBeGreaterThan(0);
+      const techStack = extracted.find(e => e.type === 'tech_stack');
+      expect(techStack).toBeDefined();
+    });
+  });
+
+  describe('getSummary', () => {
+    it('should generate human-readable summary', () => {
+      const extractedInfo = [
+        { type: 'tech_stack', confidence: 90 },
+        { type: 'architecture', confidence: 85 },
+        { type: 'project_goal', confidence: 95 }
+      ];
+
+      const summary = analyzer.getSummary(extractedInfo);
+
+      expect(summary).toContain('TECH STACK: 90% confidence');
+      expect(summary).toContain('ARCHITECTURE: 85% confidence');
+      expect(summary).toContain('PROJECT GOAL: 95% confidence');
+    });
+
+    it('should handle multiple items of same type', () => {
+      const extractedInfo = [
+        { type: 'tech_stack', confidence: 90 },
+        { type: 'tech_stack', confidence: 80 },
+        { type: 'architecture', confidence: 85 }
+      ];
+
+      const summary = analyzer.getSummary(extractedInfo);
+
+      // Should show highest confidence
+      expect(summary).toContain('TECH STACK: 90% confidence');
+    });
+  });
+});