@iservu-inc/adf-cli 0.3.6 → 0.4.12

package/tests/question-filter.test.js

@@ -0,0 +1,297 @@
+const { filterQuestions, scoreQuestionRelevance } = require('../lib/filters/question-filter');
+const { PROJECT_TYPES } = require('../lib/analyzers/project-analyzer');
+
+describe('Question Filter', () => {
+  const sampleQuestions = [
+    {
+      id: 'q1',
+      text: 'What is the user interface design approach?',
+      guidance: 'Describe your UI design',
+      category: 'frontend',
+      phase: 'design'
+    },
+    {
+      id: 'q2',
+      text: 'What API endpoints will you need?',
+      guidance: 'List your REST/GraphQL endpoints',
+      category: 'api',
+      phase: 'architecture'
+    },
+    {
+      id: 'q3',
+      text: 'What command-line arguments will your CLI accept?',
+      guidance: 'Define CLI interface',
+      category: 'cli',
+      phase: 'design'
+    },
+    {
+      id: 'q4',
+      text: 'What database will you use?',
+      guidance: 'Choose your database',
+      category: 'backend',
+      phase: 'architecture'
+    }
+  ];
+
+  describe('filterQuestions', () => {
+    test('should skip UI questions for CLI tools', () => {
+      const projectContext = {
+        type: PROJECT_TYPES.CLI_TOOL,
+        frameworks: [],
+        languages: ['JavaScript/TypeScript'],
+        confidence: 80
+      };
+
+      const result = filterQuestions(sampleQuestions, projectContext, {
+        enableSmartFiltering: true,
+        minRelevanceScore: 50
+      });
+
+      // UI question should be skipped
+      const uiQuestion = result.questions.find(q => q.id === 'q1');
+      expect(uiQuestion).toBeUndefined();
+
+      // CLI question should be kept
+      const cliQuestion = result.questions.find(q => q.id === 'q3');
+      expect(cliQuestion).toBeDefined();
+
+      expect(result.summary.skipped).toBeGreaterThan(0);
+    });
+
+    test('should skip frontend questions for API servers', () => {
+      const projectContext = {
+        type: PROJECT_TYPES.API_SERVER,
+        frameworks: ['Express'],
+        languages: ['JavaScript/TypeScript'],
+        confidence: 85
+      };
+
+      const result = filterQuestions(sampleQuestions, projectContext, {
+        enableSmartFiltering: true,
+        minRelevanceScore: 50
+      });
+
+      // UI question should be skipped
+      const uiQuestion = result.questions.find(q => q.id === 'q1');
+      expect(uiQuestion).toBeUndefined();
+
+      // API question should be kept
+      const apiQuestion = result.questions.find(q => q.id === 'q2');
+      expect(apiQuestion).toBeDefined();
+    });
+
+    test('should keep all questions when smart filtering disabled', () => {
+      const projectContext = {
+        type: PROJECT_TYPES.CLI_TOOL,
+        frameworks: [],
+        languages: ['JavaScript/TypeScript'],
+        confidence: 80
+      };
+
+      const result = filterQuestions(sampleQuestions, projectContext, {
+        enableSmartFiltering: false
+      });
+
+      expect(result.questions.length).toBe(sampleQuestions.length);
+      expect(result.summary.skipped).toBe(0);
+    });
+
+    test('should estimate time saved correctly', () => {
+      const projectContext = {
+        type: PROJECT_TYPES.CLI_TOOL,
+        frameworks: [],
+        languages: ['JavaScript/TypeScript'],
+        confidence: 80
+      };
+
+      const result = filterQuestions(sampleQuestions, projectContext, {
+        enableSmartFiltering: true,
+        minRelevanceScore: 50
+      });
+
+      expect(result.summary.timeSaved).toBeGreaterThan(0);
+      // 2 minutes per skipped question
+      expect(result.summary.timeSaved).toBe(result.summary.skipped * 2);
+    });
+  });
+
+  describe('scoreQuestionRelevance', () => {
+    test('should score UI question low for CLI projects', () => {
+      const question = {
+        text: 'What is your responsive design approach?',
+        guidance: 'Describe mobile/desktop layouts'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.CLI_TOOL,
+        frameworks: [],
+        languages: ['JavaScript/TypeScript']
+      };
+
+      const relevance = scoreQuestionRelevance(question, projectContext);
+
+      expect(relevance.score).toBeLessThan(70);
+      expect(relevance.skipReason).toBeTruthy();
+    });
+
+    test('should score API question high for API servers', () => {
+      const question = {
+        text: 'What REST API endpoints will you need?',
+        guidance: 'Define your API routes'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.API_SERVER,
+        frameworks: ['Express'],
+        languages: ['JavaScript/TypeScript']
+      };
+
+      const relevance = scoreQuestionRelevance(question, projectContext);
+
+      expect(relevance.score).toBeGreaterThanOrEqual(50);
+    });
+
+    test('should boost relevance for framework-specific questions', () => {
+      const question = {
+        text: 'How will you structure your React components?',
+        guidance: 'Describe component architecture'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.WEB_APP,
+        frameworks: ['React'],
+        languages: ['JavaScript/TypeScript']
+      };
+
+      const relevance = scoreQuestionRelevance(question, projectContext);
+
+      expect(relevance.score).toBeGreaterThan(80);
+    });
+
+    test('should reduce relevance for competing framework questions', () => {
+      const question = {
+        text: 'How will you set up Angular modules?',
+        guidance: 'Configure Angular app'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.WEB_APP,
+        frameworks: ['React'],
+        languages: ['JavaScript/TypeScript']
+      };
+
+      const relevance = scoreQuestionRelevance(question, projectContext);
+
+      expect(relevance.score).toBeLessThanOrEqual(70);
+    });
+
+    test('should handle projects with no framework gracefully', () => {
+      const question = {
+        text: 'What is your project goal?',
+        guidance: 'Describe main objective'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.UNKNOWN,
+        frameworks: [],
+        languages: []
+      };
+
+      const relevance = scoreQuestionRelevance(question, projectContext);
+
+      expect(relevance.score).toBeGreaterThanOrEqual(0);
+      expect(relevance.score).toBeLessThanOrEqual(100);
+    });
+
+    test('should provide helpful reasons for kept questions', () => {
+      const question = {
+        text: 'What CLI commands will you support?',
+        guidance: 'Define command structure'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.CLI_TOOL,
+        frameworks: [],
+        languages: ['JavaScript/TypeScript']
+      };
+
+      const relevance = scoreQuestionRelevance(question, projectContext);
+
+      expect(relevance.reason).toBeTruthy();
+      expect(relevance.reason.toLowerCase()).toContain('cli');
+    });
+
+    test('should provide helpful reasons for skipped questions', () => {
+      const question = {
+        text: 'What browser compatibility do you need?',
+        guidance: 'List supported browsers'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.CLI_TOOL,
+        frameworks: [],
+        languages: ['JavaScript/TypeScript']
+      };
+
+      const relevance = scoreQuestionRelevance(question, projectContext);
+
+      if (relevance.score < 50) {
+        expect(relevance.skipReason).toBeTruthy();
+      }
+    });
+  });
+
+  describe('Edge cases', () => {
+    test('should handle empty question list', () => {
+      const projectContext = {
+        type: PROJECT_TYPES.WEB_APP,
+        frameworks: ['React'],
+        languages: ['JavaScript/TypeScript'],
+        confidence: 80
+      };
+
+      const result = filterQuestions([], projectContext);
+
+      expect(result.questions).toEqual([]);
+      expect(result.summary.total).toBe(0);
+      expect(result.summary.skipped).toBe(0);
+    });
+
+    test('should handle unknown project type gracefully', () => {
+      const projectContext = {
+        type: PROJECT_TYPES.UNKNOWN,
+        frameworks: [],
+        languages: [],
+        confidence: 20
+      };
+
+      const result = filterQuestions(sampleQuestions, projectContext, {
+        enableSmartFiltering: true,
+        minRelevanceScore: 50
+      });
+
+      // Should keep most questions when uncertain
+      expect(result.questions.length).toBeGreaterThan(0);
+    });
+
+    test('should handle missing category in question', () => {
+      const questionWithoutCategory = {
+        id: 'q5',
+        text: 'General question',
+        guidance: 'Answer this'
+      };
+
+      const projectContext = {
+        type: PROJECT_TYPES.WEB_APP,
+        frameworks: [],
+        languages: [],
+        confidence: 80
+      };
+
+      const relevance = scoreQuestionRelevance(questionWithoutCategory, projectContext);
+
+      expect(relevance.score).toBeGreaterThanOrEqual(0);
+      expect(relevance.score).toBeLessThanOrEqual(100);
+    });
+  });
+});

package/tests/skip-tracker.test.js

@@ -0,0 +1,198 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { SkipTracker, analyzeSkipPatterns } = require('../lib/learning/skip-tracker');
+
+describe('Skip Tracker', () => {
+  const tempDir = path.join(__dirname, 'temp-skip-tracker-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('SkipTracker', () => {
+    test('should initialize with project metadata', () => {
+      const tracker = new SkipTracker(tempDir, {
+        projectType: 'cli-tool',
+        frameworks: ['commander'],
+        languages: ['JavaScript']
+      });
+
+      expect(tracker.projectPath).toBe(tempDir);
+      expect(tracker.sessionData.projectType).toBe('cli-tool');
+      expect(tracker.sessionData.frameworks).toContain('commander');
+      expect(tracker.sessionId).toBeTruthy();
+    });
+
+    test('should record skip events', () => {
+      const tracker = new SkipTracker(tempDir, { projectType: 'web-app' });
+
+      const question = {
+        id: 'q1',
+        text: 'What is your deployment strategy?',
+        category: 'deployment',
+        phase: 'architecture'
+      };
+
+      tracker.recordSkip(question, 'manual');
+
+      expect(tracker.sessionData.skips.length).toBe(1);
+      expect(tracker.sessionData.skips[0].questionId).toBe('q1');
+      expect(tracker.sessionData.skips[0].reason).toBe('manual');
+      expect(tracker.sessionData.skips[0].category).toBe('deployment');
+    });
+
+    test('should record answer events', () => {
+      const tracker = new SkipTracker(tempDir, { projectType: 'api-server' });
+
+      const question = {
+        id: 'q1',
+        text: 'What database will you use?',
+        category: 'backend'
+      };
+
+      tracker.recordAnswer(question, 'PostgreSQL with TypeORM', {
+        qualityScore: 85,
+        richness: 'comprehensive'
+      });
+
+      expect(tracker.sessionData.answers.length).toBe(1);
+      expect(tracker.sessionData.answers[0].questionId).toBe('q1');
+      expect(tracker.sessionData.answers[0].wordCount).toBe(3);
+      expect(tracker.sessionData.answers[0].qualityScore).toBe(85);
+    });
+
+    test('should track time spent on questions', async () => {
+      const tracker = new SkipTracker(tempDir, { projectType: 'web-app' });
+
+      const question = { id: 'q1', text: 'Test question' };
+
+      tracker.startQuestion('q1');
+      await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100ms
+      const timeSpent = tracker.getTimeSpent('q1');
+
+      expect(timeSpent).toBeGreaterThan(0);
+      expect(timeSpent).toBeLessThan(1); // Should be fraction of a second
+    });
+
+    test('should record filtered questions in bulk', () => {
+      const tracker = new SkipTracker(tempDir, { projectType: 'cli-tool' });
+
+      const filteredQuestions = [
+        { id: 'q1', text: 'Question 1', category: 'frontend' },
+        { id: 'q2', text: 'Question 2', category: 'ui' }
+      ];
+
+      tracker.recordFilteredQuestions(filteredQuestions);
+
+      expect(tracker.sessionData.skips.length).toBe(2);
+      expect(tracker.sessionData.skips.every(s => s.reason === 'filtered')).toBe(true);
+    });
+
+    test('should generate session summary', () => {
+      const tracker = new SkipTracker(tempDir, { projectType: 'web-app' });
+
+      tracker.recordSkip({ id: 'q1', text: 'Q1' }, 'manual');
+      tracker.recordSkip({ id: 'q2', text: 'Q2' }, 'filtered');
+      tracker.recordAnswer({ id: 'q3', text: 'Q3' }, 'Answer', {});
+
+      const summary = tracker.getSessionSummary();
+
+      expect(summary.totalSkips).toBe(2);
+      expect(summary.manualSkips).toBe(1);
+      expect(summary.filteredSkips).toBe(1);
+      expect(summary.totalAnswers).toBe(1);
+    });
+
+    test('should save session data', async () => {
+      const tracker = new SkipTracker(tempDir, { projectType: 'cli-tool' });
+
+      tracker.recordSkip({ id: 'q1', text: 'Test question' }, 'manual');
+      const result = await tracker.saveSession();
+
+      expect(result).toBe(true);
+
+      // Verify data was saved
+      const skipHistoryPath = path.join(tempDir, '.adf', 'learning', 'skip-history.json');
+      const exists = await fs.pathExists(skipHistoryPath);
+      expect(exists).toBe(true);
+
+      const data = await fs.readJSON(skipHistoryPath);
+      expect(data.sessions.length).toBe(1);
+      expect(data.sessions[0].skips.length).toBe(1);
+    });
+  });
+
+  describe('analyzeSkipPatterns', () => {
+    test('should return empty analysis for no history', async () => {
+      const analysis = await analyzeSkipPatterns(tempDir);
+
+      expect(analysis.totalSessions).toBe(0);
+      expect(analysis.totalSkips).toBe(0);
+      expect(analysis.mostSkippedQuestions).toEqual([]);
+    });
+
+    test('should analyze skip patterns from history', async () => {
+      // Create mock history
+      const history = {
+        version: '1.0',
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', text: 'Q1', category: 'deployment', reason: 'manual' },
+              { questionId: 'q2', text: 'Q2', category: 'testing', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's2',
+            skips: [
+              { questionId: 'q1', text: 'Q1', category: 'deployment', reason: 'manual' },
+              { questionId: 'q3', text: 'Q3', category: 'deployment', reason: 'filtered' }
+            ]
+          }
+        ]
+      };
+
+      await fs.ensureDir(path.join(tempDir, '.adf', 'learning'));
+      await fs.writeJSON(path.join(tempDir, '.adf', 'learning', 'skip-history.json'), history);
+
+      const analysis = await analyzeSkipPatterns(tempDir);
+
+      expect(analysis.totalSessions).toBe(2);
+      expect(analysis.manualSkips).toBe(3);
+      expect(analysis.filteredSkips).toBe(1);
+      expect(analysis.mostSkippedQuestions.length).toBeGreaterThan(0);
+      expect(analysis.mostSkippedQuestions[0].questionId).toBe('q1'); // Most skipped
+      expect(analysis.mostSkippedQuestions[0].count).toBe(2);
+    });
+
+    test('should identify most skipped categories', async () => {
+      const history = {
+        version: '1.0',
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', text: 'Q1', category: 'deployment', reason: 'manual' },
+              { questionId: 'q2', text: 'Q2', category: 'deployment', reason: 'manual' },
+              { questionId: 'q3', text: 'Q3', category: 'testing', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      await fs.ensureDir(path.join(tempDir, '.adf', 'learning'));
+      await fs.writeJSON(path.join(tempDir, '.adf', 'learning', 'skip-history.json'), history);
+
+      const analysis = await analyzeSkipPatterns(tempDir);
+
+      expect(analysis.mostSkippedCategories.length).toBeGreaterThan(0);
+      expect(analysis.mostSkippedCategories[0].category).toBe('deployment');
+      expect(analysis.mostSkippedCategories[0].count).toBe(2);
+    });
+  });
+});