@iservu-inc/adf-cli 0.4.36 → 0.5.1

package/tests/knowledge-graph.test.js

@@ -0,0 +1,322 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const KnowledgeGraph = require('../lib/analysis/knowledge-graph');
+
+describe('KnowledgeGraph', () => {
+  let tempDir;
+  let kg;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'kg-test-'));
+    kg = new KnowledgeGraph(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('add', () => {
+    it('should add new information', () => {
+      const extractedInfo = [
+        {
+          type: 'tech_stack',
+          content: 'React and Node.js',
+          confidence: 90,
+          source: 'tech-question'
+        }
+      ];
+
+      kg.add(extractedInfo);
+
+      expect(kg.has('tech_stack', 70)).toBe(true);
+      expect(kg.getConfidence('tech_stack')).toBe(90);
+    });
+
+    it('should update existing information with higher confidence', () => {
+      const info1 = [
+        { type: 'tech_stack', content: 'React for frontend development', confidence: 70, source: 'q1' }
+      ];
+      const info2 = [
+        { type: 'tech_stack', content: 'React for the frontend', confidence: 90, source: 'q2' }
+      ];
+
+      kg.add(info1);
+      kg.add(info2);
+
+      expect(kg.getConfidence('tech_stack')).toBe(90);
+      const items = kg.get('tech_stack');
+      // Should have merged or both sources tracked
+      const allSources = items.flatMap(i => i.sources);
+      expect(allSources).toContain('q1');
+      expect(allSources).toContain('q2');
+    });
+
+    it('should not replace existing information with lower confidence', () => {
+      const info1 = [
+        { type: 'tech_stack', content: 'React and Node', confidence: 90, source: 'q1' }
+      ];
+      const info2 = [
+        { type: 'tech_stack', content: 'React', confidence: 70, source: 'q2' }
+      ];
+
+      kg.add(info1);
+      kg.add(info2);
+
+      expect(kg.getConfidence('tech_stack')).toBe(90);
+      const items = kg.get('tech_stack');
+      expect(items[0].content).toContain('Node');
+    });
+
+    it('should add dissimilar information as separate items', () => {
+      const info1 = [
+        { type: 'features', content: 'User authentication', confidence: 85, source: 'q1' }
+      ];
+      const info2 = [
+        { type: 'features', content: 'Data export to CSV', confidence: 80, source: 'q2' }
+      ];
+
+      kg.add(info1);
+      kg.add(info2);
+
+      const items = kg.get('features');
+      expect(items).toHaveLength(2);
+    });
+
+    it('should merge similar information', () => {
+      const info1 = [
+        { type: 'tech_stack', content: 'React for frontend', confidence: 85, source: 'q1' }
+      ];
+      const info2 = [
+        { type: 'tech_stack', content: 'React for the frontend', confidence: 80, source: 'q2' }
+      ];
+
+      kg.add(info1);
+      kg.add(info2);
+
+      const items = kg.get('tech_stack');
+      // Should merge because very similar
+      expect(items.length).toBeLessThanOrEqual(2);
+    });
+  });
+
+  describe('has', () => {
+    it('should return true if information exists with sufficient confidence', () => {
+      const info = [
+        { type: 'project_goal', content: 'Build a CRM', confidence: 85, source: 'q1' }
+      ];
+
+      kg.add(info);
+
+      expect(kg.has('project_goal', 80)).toBe(true);
+      expect(kg.has('project_goal', 90)).toBe(false);
+    });
+
+    it('should return false for missing information types', () => {
+      expect(kg.has('tech_stack')).toBe(false);
+    });
+
+    it('should use default minConfidence of 70', () => {
+      const info = [
+        { type: 'platform', content: 'Web', confidence: 75, source: 'q1' }
+      ];
+
+      kg.add(info);
+
+      expect(kg.has('platform')).toBe(true);
+    });
+  });
+
+  describe('get', () => {
+    it('should return all items of a type', () => {
+      const info = [
+        { type: 'features', content: 'Auth', confidence: 85, source: 'q1' },
+        { type: 'features', content: 'Export', confidence: 80, source: 'q2' }
+      ];
+
+      kg.add(info);
+
+      const items = kg.get('features');
+      expect(items).toHaveLength(2);
+    });
+
+    it('should return empty array for non-existent type', () => {
+      const items = kg.get('nonexistent');
+      expect(items).toEqual([]);
+    });
+  });
+
+  describe('getConfidence', () => {
+    it('should return highest confidence for a type', () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 80, source: 'q1' },
+        { type: 'tech_stack', content: 'Node', confidence: 90, source: 'q2' }
+      ];
+
+      kg.add(info);
+
+      expect(kg.getConfidence('tech_stack')).toBe(90);
+    });
+
+    it('should return 0 for non-existent type', () => {
+      expect(kg.getConfidence('nonexistent')).toBe(0);
+    });
+  });
+
+  describe('getSummary', () => {
+    it('should return summary of all knowledge', () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' },
+        { type: 'architecture', content: 'SPA', confidence: 85, source: 'q2' },
+        { type: 'platform', content: 'Web', confidence: 80, source: 'q3' }
+      ];
+
+      kg.add(info);
+
+      const summary = kg.getSummary();
+
+      expect(summary.tech_stack.maxConfidence).toBe(90);
+      expect(summary.architecture.maxConfidence).toBe(85);
+      expect(summary.platform.maxConfidence).toBe(80);
+      expect(summary.tech_stack.sources).toContain('q1');
+    });
+  });
+
+  describe('getDisplaySummary', () => {
+    it('should return displayable summary with icons', () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' },
+        { type: 'project_goal', content: 'Build CRM', confidence: 95, source: 'q2' }
+      ];
+
+      kg.add(info);
+
+      const display = kg.getDisplaySummary();
+
+      expect(display.length).toBe(2);
+      expect(display[0].confidence).toBe(95); // Sorted by confidence
+      expect(display[0].icon).toBe('🎯');
+      expect(display[1].icon).toBe('🔧');
+    });
+
+    it('should filter out low confidence items', () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' },
+        { type: 'timeline', content: 'Soon', confidence: 50, source: 'q2' }
+      ];
+
+      kg.add(info);
+
+      const display = kg.getDisplaySummary();
+
+      // Should only include tech_stack (90% > 60%)
+      expect(display).toHaveLength(1);
+      expect(display[0].type).toBe('tech stack');
+    });
+  });
+
+  describe('calculateSimilarity', () => {
+    it('should calculate high similarity for similar texts', () => {
+      const similarity = kg.calculateSimilarity(
+        'React for frontend development',
+        'React for the frontend'
+      );
+
+      expect(similarity).toBeGreaterThan(0.5);
+    });
+
+    it('should calculate low similarity for different texts', () => {
+      const similarity = kg.calculateSimilarity(
+        'React for frontend',
+        'PostgreSQL database'
+      );
+
+      expect(similarity).toBeLessThan(0.5);
+    });
+
+    it('should return 1 for identical texts', () => {
+      const similarity = kg.calculateSimilarity(
+        'same text',
+        'same text'
+      );
+
+      expect(similarity).toBe(1);
+    });
+  });
+
+  describe('save and load', () => {
+    it('should save knowledge graph to disk', async () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' }
+      ];
+
+      kg.add(info);
+      await kg.save();
+
+      const filePath = path.join(tempDir, '_knowledge_graph.json');
+      expect(await fs.pathExists(filePath)).toBe(true);
+
+      const data = await fs.readJson(filePath);
+      expect(data.knowledge).toBeDefined();
+      expect(data.knowledge.length).toBeGreaterThan(0);
+    });
+
+    it('should load knowledge graph from disk', async () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' },
+        { type: 'platform', content: 'Web', confidence: 85, source: 'q2' }
+      ];
+
+      kg.add(info);
+      await kg.save();
+
+      // Create new instance and load
+      const kg2 = new KnowledgeGraph(tempDir);
+      const loaded = await kg2.load();
+
+      expect(loaded).toBe(true);
+      expect(kg2.has('tech_stack')).toBe(true);
+      expect(kg2.has('platform')).toBe(true);
+      expect(kg2.getConfidence('tech_stack')).toBe(90);
+    });
+
+    it('should return false when loading from non-existent file', async () => {
+      const loaded = await kg.load();
+      expect(loaded).toBe(false);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return statistics about knowledge graph', () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' },
+        { type: 'tech_stack', content: 'Node', confidence: 85, source: 'q2' },
+        { type: 'platform', content: 'Web', confidence: 75, source: 'q3' },
+        { type: 'architecture', content: 'SPA', confidence: 80, source: 'q4' }
+      ];
+
+      kg.add(info);
+
+      const stats = kg.getStats();
+
+      expect(stats.totalItems).toBe(4);
+      expect(stats.highConfidenceItems).toBe(3); // 90, 85, 80 are >= 80
+      expect(stats.types).toBe(3); // tech_stack, platform, architecture
+      expect(stats.typeList).toContain('tech_stack');
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all knowledge', () => {
+      const info = [
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'q1' }
+      ];
+
+      kg.add(info);
+      expect(kg.has('tech_stack')).toBe(true);
+
+      kg.clear();
+      expect(kg.has('tech_stack')).toBe(false);
+    });
+  });
+});

package/tests/question-mapper.test.js

@@ -0,0 +1,342 @@
+const QuestionMapper = require('../lib/analysis/question-mapper');
+const KnowledgeGraph = require('../lib/analysis/knowledge-graph');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+describe('QuestionMapper', () => {
+  let mapper;
+  let kg;
+  let tempDir;
+
+  beforeEach(async () => {
+    mapper = new QuestionMapper();
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'qm-test-'));
+    kg = new KnowledgeGraph(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('mapQuestion', () => {
+    it('should map tech stack question correctly', () => {
+      const question = {
+        id: 'tech-stack',
+        text: 'What tech stack will you use?'
+      };
+
+      const mapping = mapper.mapQuestion(question);
+
+      expect(mapping.types).toContain('tech_stack');
+      expect(mapping.priority).toBeLessThanOrEqual(2); // High priority
+      expect(mapping.confidence).toBeGreaterThan(70);
+    });
+
+    it('should map goal question correctly', () => {
+      const question = {
+        id: 'project-goal',
+        text: 'What are you building?'
+      };
+
+      const mapping = mapper.mapQuestion(question);
+
+      expect(mapping.types).toContain('project_goal');
+      expect(mapping.priority).toBe(1); // Highest priority
+      expect(mapping.confidence).toBeGreaterThan(70);
+    });
+
+    it('should map user question correctly', () => {
+      const question = {
+        id: 'target-users',
+        text: 'Who are your target users?'
+      };
+
+      const mapping = mapper.mapQuestion(question);
+
+      expect(mapping.types).toContain('target_users');
+      expect(mapping.confidence).toBeGreaterThan(70);
+    });
+
+    it('should map architecture question correctly', () => {
+      const question = {
+        id: 'architecture',
+        text: 'How will you structure your application?'
+      };
+
+      const mapping = mapper.mapQuestion(question);
+
+      expect(mapping.types).toContain('architecture');
+      expect(mapping.confidence).toBeGreaterThan(70);
+    });
+
+    it('should map platform question correctly', () => {
+      const question = {
+        id: 'platform',
+        text: 'What platform will this run on?'
+      };
+
+      const mapping = mapper.mapQuestion(question);
+
+      expect(mapping.types).toContain('platform');
+      expect(mapping.confidence).toBeGreaterThan(70);
+    });
+
+    it('should return default mapping for unrecognized questions', () => {
+      const question = {
+        id: 'random',
+        text: 'Something totally unrelated?'
+      };
+
+      const mapping = mapper.mapQuestion(question);
+
+      expect(mapping.types.length).toBeGreaterThan(0); // Has some type
+      expect(mapping.confidence).toBeGreaterThan(0); // Has some confidence
+    });
+
+    it('should map multiple information types for comprehensive questions', () => {
+      const question = {
+        id: 'goal-and-tech',
+        text: 'What are you building and what technology will you use?'
+      };
+
+      const mapping = mapper.mapQuestion(question);
+
+      expect(mapping.types).toContain('project_goal');
+      expect(mapping.types).toContain('tech_stack');
+      expect(mapping.types.length).toBeGreaterThan(1);
+    });
+  });
+
+  describe('canSkipQuestion', () => {
+    it('should allow skipping when all information types are satisfied', () => {
+      const question = {
+        id: 'tech-stack',
+        text: 'What tech stack will you use?'
+      };
+
+      // Add tech stack knowledge
+      kg.add([
+        { type: 'tech_stack', content: 'React and Node.js', confidence: 90, source: 'prev-q' }
+      ]);
+
+      const result = mapper.canSkipQuestion(question, kg, 70);
+
+      expect(result.canSkip).toBe(true);
+      expect(result.reason).toContain('tech stack');
+      expect(result.satisfiedTypes).toHaveLength(1);
+      expect(result.missingTypes).toHaveLength(0);
+    });
+
+    it('should not skip when confidence is below threshold', () => {
+      const question = {
+        id: 'tech-stack',
+        text: 'What tech stack?'
+      };
+
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 60, source: 'prev-q' }
+      ]);
+
+      const result = mapper.canSkipQuestion(question, kg, 70);
+
+      expect(result.canSkip).toBe(false);
+    });
+
+    it('should not skip when information is missing', () => {
+      const question = {
+        id: 'tech-stack',
+        text: 'What tech stack will you use?'
+      };
+
+      // No knowledge added
+
+      const result = mapper.canSkipQuestion(question, kg, 70);
+
+      expect(result.canSkip).toBe(false);
+      expect(result.satisfiedTypes).toHaveLength(0);
+      expect(result.missingTypes.length).toBeGreaterThan(0);
+    });
+
+    it('should handle partial satisfaction', () => {
+      const question = {
+        id: 'goal-and-tech',
+        text: 'What are you building and what technology?'
+      };
+
+      // Only have goal, missing tech
+      kg.add([
+        { type: 'project_goal', content: 'Building a CRM', confidence: 90, source: 'prev-q' }
+      ]);
+
+      const result = mapper.canSkipQuestion(question, kg, 70);
+
+      expect(result.canSkip).toBe(false);
+      expect(result.satisfiedTypes.length).toBeGreaterThan(0);
+      expect(result.missingTypes.length).toBeGreaterThan(0);
+      expect(result.reason).toContain('Partial');
+    });
+
+    it('should respect custom minConfidence threshold', () => {
+      const question = {
+        id: 'tech-stack',
+        text: 'What tech stack?'
+      };
+
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 75, source: 'prev-q' }
+      ]);
+
+      // Should skip with 70 threshold
+      expect(mapper.canSkipQuestion(question, kg, 70).canSkip).toBe(true);
+
+      // Should not skip with 80 threshold
+      expect(mapper.canSkipQuestion(question, kg, 80).canSkip).toBe(false);
+    });
+  });
+
+  describe('reorderQuestions', () => {
+    it('should prioritize questions with missing information', () => {
+      const questions = [
+        { id: 'tech-stack', text: 'What tech stack?' },
+        { id: 'timeline', text: 'What is the timeline?' },
+        { id: 'platform', text: 'What platform?' }
+      ];
+
+      // Already have tech stack
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'prev' }
+      ]);
+
+      const reordered = mapper.reorderQuestions(questions, kg);
+
+      // Questions without satisfied info should come first
+      expect(reordered[0].question.id).not.toBe('tech-stack');
+      expect(reordered[2].question.id).toBe('tech-stack'); // Should be last
+      expect(reordered[2].relevanceScore).toBe(0); // Can skip
+    });
+
+    it('should assign high scores to unsatisfied questions', () => {
+      const questions = [
+        { id: 'tech-stack', text: 'What tech stack?' }
+      ];
+
+      const reordered = mapper.reorderQuestions(questions, kg);
+
+      expect(reordered[0].relevanceScore).toBe(100);
+    });
+
+    it('should assign zero score to fully satisfied questions', () => {
+      const questions = [
+        { id: 'tech-stack', text: 'What tech stack?' }
+      ];
+
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'prev' },
+        { type: 'architecture', content: 'SPA', confidence: 85, source: 'prev' }
+      ]);
+
+      const reordered = mapper.reorderQuestions(questions, kg);
+
+      expect(reordered[0].relevanceScore).toBe(0);
+      expect(reordered[0].skipInfo.canSkip).toBe(true);
+    });
+
+    it('should boost high-priority questions', () => {
+      const questions = [
+        { id: 'timeline', text: 'Timeline?' },  // Priority 4
+        { id: 'goal', text: 'What building?' }  // Priority 1
+      ];
+
+      // Add some knowledge so we can see priority effects
+      kg.add([
+        { type: 'timeline', content: '2 weeks', confidence: 60, source: 'prev' }
+      ]);
+
+      const reordered = mapper.reorderQuestions(questions, kg);
+
+      // Goal question should have higher score due to priority boost
+      const goalItem = reordered.find(r => r.question.id === 'goal');
+      const timelineItem = reordered.find(r => r.question.id === 'timeline');
+
+      expect(goalItem.relevanceScore).toBeGreaterThanOrEqual(timelineItem.relevanceScore);
+    });
+
+    it('should handle partially satisfied questions', () => {
+      const questions = [
+        { id: 'goal', text: 'What building?' },
+        { id: 'tech', text: 'What tech?' }
+      ];
+
+      // Partial knowledge - only have goal
+      kg.add([
+        { type: 'project_goal', content: 'CRM', confidence: 90, source: 'prev' }
+      ]);
+
+      const reordered = mapper.reorderQuestions(questions, kg);
+
+      // Tech should have full score (100), goal should be skippable (0)
+      const techItem = reordered.find(r => r.question.id === 'tech');
+      const goalItem = reordered.find(r => r.question.id === 'goal');
+
+      expect(techItem.relevanceScore).toBeGreaterThan(goalItem.relevanceScore);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should calculate statistics correctly', () => {
+      const questions = [
+        { id: 'tech-stack', text: 'What tech stack?' },
+        { id: 'platform', text: 'What platform?' },
+        { id: 'timeline', text: 'Timeline?' },
+        { id: 'users', text: 'Who are users?' }
+      ];
+
+      // Add some knowledge
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'prev' },
+        { type: 'platform', content: 'Web', confidence: 85, source: 'prev' }
+      ]);
+
+      const stats = mapper.getStats(questions, kg);
+
+      expect(stats.total).toBe(4);
+      expect(stats.canSkip).toBeGreaterThanOrEqual(2); // tech_stack and platform
+      expect(stats.needed).toBeGreaterThan(0);
+      expect(stats.estimatedTimeSaved).toBeGreaterThan(0);
+    });
+
+    it('should handle empty knowledge graph', () => {
+      const questions = [
+        { id: 'tech-stack', text: 'What tech stack?' },
+        { id: 'platform', text: 'What platform?' }
+      ];
+
+      const stats = mapper.getStats(questions, kg);
+
+      expect(stats.total).toBe(2);
+      expect(stats.canSkip).toBe(0);
+      expect(stats.needed).toBe(2);
+      expect(stats.estimatedTimeSaved).toBe(0);
+    });
+
+    it('should estimate time saved correctly', () => {
+      const questions = [
+        { id: 'tech-stack', text: 'What tech stack?' },
+        { id: 'platform', text: 'What platform?' },
+        { id: 'timeline', text: 'What is the timeline?' }
+      ];
+
+      // Can skip 2 questions
+      kg.add([
+        { type: 'tech_stack', content: 'React', confidence: 90, source: 'prev' },
+        { type: 'platform', content: 'Web', confidence: 90, source: 'prev' }
+      ]);
+
+      const stats = mapper.getStats(questions, kg);
+
+      // If 2 can be skipped, time saved should be around 3 minutes (1.5 * 2)
+      expect(stats.estimatedTimeSaved).toBeGreaterThanOrEqual(1.5);
+    });
+  });
+});