@iservu-inc/adf-cli 0.4.36 → 0.5.1

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');
+    });
+  });
+});

package/tests/dynamic-pipeline.test.js

@@ -0,0 +1,332 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const DynamicPipeline = require('../lib/analysis/dynamic-pipeline');
+
+describe('DynamicPipeline', () => {
+  let tempDir;
+  let pipeline;
+  let mockAIClient;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dp-test-'));
+
+    mockAIClient = {
+      sendMessage: jest.fn().mockResolvedValue(JSON.stringify([
+        {
+          type: 'tech_stack',
+          content: 'React and Node.js',
+          confidence: 90,
+          reasoning: 'Explicitly mentioned'
+        }
+      ]))
+    };
+
+    pipeline = new DynamicPipeline(tempDir, mockAIClient, {
+      enabled: true,
+      minSkipConfidence: 75,
+      showAnalysis: false,
+      verbose: false
+    });
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('initialize', () => {
+    it('should initialize without errors', async () => {
+      const loaded = await pipeline.initialize();
+      expect(loaded).toBe(false); // No existing data
+    });
+
+    it('should load existing knowledge graph', async () => {
+      // Create existing knowledge graph
+      const kgPath = path.join(tempDir, '_knowledge_graph.json');
+      await fs.writeJson(kgPath, {
+        savedAt: new Date().toISOString(),
+        knowledge: [
+          {
+            type: 'tech_stack',
+            items: [
+              {
+                type: 'tech_stack',
+                content: 'React',
+                confidence: 90,
+                sources: ['prev-q'],
+                addedAt: new Date().toISOString()
+              }
+            ]
+          }
+        ]
+      });
+
+      const loaded = await pipeline.initialize();
+      expect(loaded).toBe(true);
+    });
+  });
+
+  describe('processAnswer', () => {
+    it('should extract information from answer', async () => {
+      const result = await pipeline.processAnswer(
+        'tech-stack',
+        'What tech stack?',
+        'I will use React for frontend and Node.js for backend'
+      );
+
+      expect(result.extracted.length).toBeGreaterThan(0);
+      expect(result.summary.length).toBeGreaterThan(0);
+    });
+
+    it('should update knowledge graph', async () => {
+      await pipeline.processAnswer(
+        'tech-stack',
+        'What tech stack?',
+        'React and PostgreSQL'
+      );
+
+      const summary = pipeline.getKnowledgeSummary();
+      expect(summary.length).toBeGreaterThan(0);
+    });
+
+    it('should increment stats', async () => {
+      await pipeline.processAnswer(
+        'q1',
+        'Question 1?',
+        'React and Node.js'
+      );
+
+      const stats = pipeline.getStats();
+      expect(stats.informationExtracted).toBeGreaterThan(0);
+    });
+
+    it('should handle errors gracefully', async () => {
+      mockAIClient.sendMessage.mockRejectedValue(new Error('AI error'));
+
+      const result = await pipeline.processAnswer(
+        'q1',
+        'Question?',
+        'Answer'
+      );
+
+      // Should not throw, should return empty
+      expect(result.extracted).toBeDefined();
+    });
+
+    it('should work when disabled', async () => {
+      pipeline.setEnabled(false);
+
+      const result = await pipeline.processAnswer(
+        'q1',
+        'Question?',
+        'Answer with React'
+      );
+
+      expect(result.extracted).toEqual([]);
+      expect(result.summary).toEqual([]);
+    });
+  });
+
+  describe('shouldSkipQuestion', () => {
+    it('should recommend skipping when knowledge exists', async () => {
+      // Add knowledge first
+      await pipeline.processAnswer(
+        'tech-q',
+        'What tech?',
+        'React and Node.js and PostgreSQL'
+      );
+
+      // Check if we should skip tech stack question
+      const result = pipeline.shouldSkipQuestion({
+        id: 'tech-stack',
+        text: 'What tech stack will you use?'
+      });
+
+      expect(result.shouldSkip).toBe(true);
+      expect(result.reason).toBeTruthy();
+      expect(result.confidence).toBeGreaterThan(0);
+    });
+
+    it('should not skip when knowledge is missing', () => {
+      const result = pipeline.shouldSkipQuestion({
+        id: 'tech-stack',
+        text: 'What tech stack?'
+      });
+
+      expect(result.shouldSkip).toBe(false);
+    });
+
+    it('should increment stats correctly', async () => {
+      await pipeline.processAnswer('q1', 'Tech?', 'React');
+
+      pipeline.shouldSkipQuestion({ id: 'tech-stack', text: 'Tech stack?' }); // Skip
+      pipeline.shouldSkipQuestion({ id: 'timeline', text: 'Timeline?' }); // Don't skip
+
+      const stats = pipeline.getStats();
+      expect(stats.questionsSkipped).toBe(1);
+      expect(stats.questionsAsked).toBe(1);
+      expect(stats.timeSaved).toBeGreaterThan(0);
+    });
+
+    it('should work when disabled', () => {
+      pipeline.setEnabled(false);
+
+      const result = pipeline.shouldSkipQuestion({
+        id: 'q1',
+        text: 'Question?'
+      });
+
+      expect(result.shouldSkip).toBe(false);
+      expect(result.confidence).toBe(0);
+    });
+  });
+
+  describe('reorderQuestions', () => {
+    it('should reorder questions based on knowledge', async () => {
+      await pipeline.processAnswer('q1', 'Tech?', 'React and Node.js');
+
+      const questions = [
+        { id: 'tech-stack', text: 'What tech stack?' },
+        { id: 'timeline', text: 'Timeline?' },
+        { id: 'users', text: 'Who are users?' }
+      ];
+
+      const reordered = pipeline.reorderQuestions(questions);
+
+      expect(reordered).toHaveLength(3);
+      expect(reordered[0].question).toBeDefined();
+      expect(reordered[0].relevanceScore).toBeDefined();
+
+      // Tech stack should have lowest score (can skip)
+      const techItem = reordered.find(r => r.question.id === 'tech-stack');
+      expect(techItem.relevanceScore).toBeLessThan(50);
+    });
+
+    it('should work when disabled', () => {
+      pipeline.setEnabled(false);
+
+      const questions = [
+        { id: 'q1', text: 'Q1?' },
+        { id: 'q2', text: 'Q2?' }
+      ];
+
+      const reordered = pipeline.reorderQuestions(questions);
+
+      // Should return all with max score
+      expect(reordered.every(r => r.relevanceScore === 100)).toBe(true);
+    });
+  });
+
+  describe('getFilteringSummary', () => {
+    it('should return summary statistics', async () => {
+      await pipeline.processAnswer('q1', 'Tech?', 'React');
+
+      const questions = [
+        { id: 'tech-stack', text: 'Tech stack?' },
+        { id: 'timeline', text: 'Timeline?' }
+      ];
+
+      const summary = pipeline.getFilteringSummary(questions);
+
+      expect(summary.total).toBe(2);
+      expect(summary.canSkip).toBeGreaterThanOrEqual(0);
+      expect(summary.needed).toBeGreaterThanOrEqual(0);
+      expect(summary.estimatedTimeSaved).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should work when disabled', () => {
+      pipeline.setEnabled(false);
+
+      const questions = [{ id: 'q1', text: 'Q1?' }];
+      const summary = pipeline.getFilteringSummary(questions);
+
+      expect(summary.total).toBe(1);
+      expect(summary.canSkip).toBe(0);
+      expect(summary.needed).toBe(1);
+    });
+  });
+
+  describe('getKnowledgeSummary', () => {
+    it('should return displayable knowledge summary', async () => {
+      await pipeline.processAnswer('q1', 'Tech?', 'React and Node.js');
+      await pipeline.processAnswer('q2', 'Platform?', 'Web application');
+
+      const summary = pipeline.getKnowledgeSummary();
+
+      expect(Array.isArray(summary)).toBe(true);
+      if (summary.length > 0) {
+        expect(summary[0]).toHaveProperty('type');
+        expect(summary[0]).toHaveProperty('icon');
+        expect(summary[0]).toHaveProperty('confidence');
+      }
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return comprehensive statistics', async () => {
+      await pipeline.processAnswer('q1', 'Tech?', 'React');
+      pipeline.shouldSkipQuestion({ id: 'tech', text: 'Tech?' }); // Skip
+      pipeline.shouldSkipQuestion({ id: 'timeline', text: 'Timeline?' }); // Ask
+
+      const stats = pipeline.getStats();
+
+      expect(stats).toHaveProperty('questionsAsked');
+      expect(stats).toHaveProperty('questionsSkipped');
+      expect(stats).toHaveProperty('informationExtracted');
+      expect(stats).toHaveProperty('knowledgeItems');
+      expect(stats).toHaveProperty('timeSaved');
+
+      expect(stats.questionsSkipped).toBe(1);
+      expect(stats.questionsAsked).toBe(1);
+    });
+  });
+
+  describe('save', () => {
+    it('should save knowledge graph to disk', async () => {
+      await pipeline.processAnswer('q1', 'Tech?', 'React');
+      await pipeline.save();
+
+      const kgPath = path.join(tempDir, '_knowledge_graph.json');
+      expect(await fs.pathExists(kgPath)).toBe(true);
+    });
+  });
+
+  describe('enabled/disabled', () => {
+    it('should check if enabled', () => {
+      expect(pipeline.isEnabled()).toBe(true);
+
+      pipeline.setEnabled(false);
+      expect(pipeline.isEnabled()).toBe(false);
+    });
+
+    it('should respect enabled flag', async () => {
+      pipeline.setEnabled(false);
+
+      // All operations should be no-ops
+      const result = await pipeline.processAnswer('q1', 'Tech?', 'React');
+      expect(result.extracted).toEqual([]);
+
+      const skipResult = pipeline.shouldSkipQuestion({ id: 'q1', text: 'Q?' });
+      expect(skipResult.shouldSkip).toBe(false);
+    });
+  });
+
+  describe('without AI client', () => {
+    it('should work without AI client using heuristics', async () => {
+      const pipelineWithoutAI = new DynamicPipeline(tempDir, null, {
+        enabled: true
+      });
+
+      await pipelineWithoutAI.initialize();
+
+      const result = await pipelineWithoutAI.processAnswer(
+        'tech',
+        'What tech?',
+        'React and Node.js and PostgreSQL'
+      );
+
+      // Should still extract information using heuristics
+      expect(result.extracted.length).toBeGreaterThan(0);
+    });
+  });
+});