@iservu-inc/adf-cli 0.3.6 → 0.4.12

package/tests/learning-storage.test.js

@@ -0,0 +1,184 @@
+const fs = require('fs-extra');
+const path = require('path');
+const storage = require('../lib/learning/storage');
+
+describe('Learning Storage', () => {
+  const tempDir = path.join(__dirname, 'temp-learning-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('ensureLearningDirectory', () => {
+    test('should create learning directory if it does not exist', async () => {
+      await storage.ensureLearningDirectory(tempDir);
+
+      const learningPath = path.join(tempDir, '.adf', 'learning');
+      const exists = await fs.pathExists(learningPath);
+
+      expect(exists).toBe(true);
+    });
+  });
+
+  describe('writeLearningData and readLearningData', () => {
+    test('should write and read learning data', async () => {
+      const data = {
+        version: '1.0',
+        sessions: [
+          { sessionId: 'test-1', skips: [] }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'test-data.json', data);
+      const retrieved = await storage.readLearningData(tempDir, 'test-data.json');
+
+      expect(retrieved).toEqual(data);
+    });
+
+    test('should return null for non-existent file', async () => {
+      const retrieved = await storage.readLearningData(tempDir, 'non-existent.json');
+      expect(retrieved).toBeNull();
+    });
+
+    test('should handle corrupted JSON gracefully', async () => {
+      const learningPath = path.join(tempDir, '.adf', 'learning');
+      await fs.ensureDir(learningPath);
+      await fs.writeFile(path.join(learningPath, 'corrupted.json'), 'invalid json {]');
+
+      const retrieved = await storage.readLearningData(tempDir, 'corrupted.json');
+      expect(retrieved).toBeNull();
+    });
+  });
+
+  describe('appendToLearningHistory', () => {
+    test('should append to existing history', async () => {
+      const initial = {
+        version: '1.0',
+        sessions: [{ sessionId: 'session-1' }]
+      };
+
+      await storage.writeLearningData(tempDir, 'history.json', initial);
+      await storage.appendToLearningHistory(tempDir, 'history.json', { sessionId: 'session-2' }, 'sessions');
+
+      const retrieved = await storage.readLearningData(tempDir, 'history.json');
+      expect(retrieved.sessions.length).toBe(2);
+      expect(retrieved.sessions[1].sessionId).toBe('session-2');
+    });
+
+    test('should create new file if it does not exist', async () => {
+      await storage.appendToLearningHistory(tempDir, 'new-history.json', { sessionId: 'session-1' }, 'sessions');
+
+      const retrieved = await storage.readLearningData(tempDir, 'new-history.json');
+      expect(retrieved.sessions.length).toBe(1);
+      expect(retrieved.sessions[0].sessionId).toBe('session-1');
+    });
+  });
+
+  describe('getSkipHistory', () => {
+    test('should return empty history if file does not exist', async () => {
+      const history = await storage.getSkipHistory(tempDir);
+      expect(history).toEqual({ version: '1.0', sessions: [] });
+    });
+
+    test('should return existing skip history', async () => {
+      const data = {
+        version: '1.0',
+        sessions: [
+          { sessionId: 'test', skips: [{ questionId: 'q1' }] }
+        ]
+      };
+
+      await storage.writeLearningData(tempDir, 'skip-history.json', data);
+      const history = await storage.getSkipHistory(tempDir);
+
+      expect(history.sessions.length).toBe(1);
+      expect(history.sessions[0].skips.length).toBe(1);
+    });
+  });
+
+  describe('getLearningConfig', () => {
+    test('should return default config if file does not exist', async () => {
+      const config = await storage.getLearningConfig(tempDir);
+
+      expect(config.enabled).toBe(true);
+      expect(config.trackSkips).toBe(true);
+      expect(config.minSessionsForPattern).toBe(3);
+      expect(config.minConfidenceForAutoFilter).toBe(75);
+    });
+
+    test('should return existing config', async () => {
+      const customConfig = {
+        version: '1.0',
+        enabled: false,
+        minSessionsForPattern: 5
+      };
+
+      await storage.writeLearningData(tempDir, 'config.json', customConfig);
+      const config = await storage.getLearningConfig(tempDir);
+
+      expect(config.enabled).toBe(false);
+      expect(config.minSessionsForPattern).toBe(5);
+    });
+  });
+
+  describe('clearLearningData', () => {
+    test('should remove all JSON files from learning directory', async () => {
+      await storage.writeLearningData(tempDir, 'file1.json', { test: 1 });
+      await storage.writeLearningData(tempDir, 'file2.json', { test: 2 });
+
+      await storage.clearLearningData(tempDir);
+
+      const file1 = await storage.readLearningData(tempDir, 'file1.json');
+      const file2 = await storage.readLearningData(tempDir, 'file2.json');
+
+      expect(file1).toBeNull();
+      expect(file2).toBeNull();
+    });
+
+    test('should not fail if learning directory does not exist', async () => {
+      await expect(storage.clearLearningData(tempDir)).resolves.not.toThrow();
+    });
+  });
+
+  describe('getLearningDataSize', () => {
+    test('should return 0 if no learning data exists', async () => {
+      const size = await storage.getLearningDataSize(tempDir);
+      expect(size).toBe(0);
+    });
+
+    test('should return total size of all JSON files', async () => {
+      await storage.writeLearningData(tempDir, 'file1.json', { test: 'data1' });
+      await storage.writeLearningData(tempDir, 'file2.json', { test: 'data2' });
+
+      const size = await storage.getLearningDataSize(tempDir);
+      expect(size).toBeGreaterThan(0);
+    });
+  });
+
+  describe('updateLearningStats', () => {
+    test('should update statistics', async () => {
+      await storage.updateLearningStats(tempDir, {
+        totalSessions: 5,
+        totalSkips: 20
+      });
+
+      const stats = await storage.getLearningStats(tempDir);
+      expect(stats.totalSessions).toBe(5);
+      expect(stats.totalSkips).toBe(20);
+      expect(stats.lastUpdated).toBeTruthy();
+    });
+
+    test('should preserve existing stats when updating', async () => {
+      await storage.updateLearningStats(tempDir, { totalSessions: 5 });
+      await storage.updateLearningStats(tempDir, { totalSkips: 20 });
+
+      const stats = await storage.getLearningStats(tempDir);
+      expect(stats.totalSessions).toBe(5);
+      expect(stats.totalSkips).toBe(20);
+    });
+  });
+});

package/tests/pattern-detector.test.js

@@ -0,0 +1,297 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { PatternDetector, detectPatterns, getPatternSummary } = require('../lib/learning/pattern-detector');
+
+describe('Pattern Detector', () => {
+  const tempDir = path.join(__dirname, 'temp-pattern-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('PatternDetector', () => {
+    test('should detect consistent skip patterns', () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', text: 'Deploy where?', category: 'deployment', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's2',
+            skips: [
+              { questionId: 'q1', text: 'Deploy where?', category: 'deployment', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's3',
+            skips: [
+              { questionId: 'q1', text: 'Deploy where?', category: 'deployment', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const detector = new PatternDetector(skipHistory, {}, { minSessionsForPattern: 3 });
+      const patterns = detector.detectConsistentSkips();
+
+      expect(patterns.length).toBeGreaterThan(0);
+      expect(patterns[0].questionId).toBe('q1');
+      expect(patterns[0].confidence).toBe(100); // 3/3 sessions
+      expect(patterns[0].type).toBe('consistent_skip');
+    });
+
+    test('should not detect patterns with insufficient sessions', () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', text: 'Q1', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's2',
+            skips: [
+              { questionId: 'q1', text: 'Q1', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const detector = new PatternDetector(skipHistory, {}, { minSessionsForPattern: 3 });
+      const patterns = detector.detectConsistentSkips();
+
+      expect(patterns.length).toBe(0); // Not enough sessions
+    });
+
+    test('should detect category skip patterns', () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' },
+              { questionId: 'q2', category: 'deployment', reason: 'manual' },
+              { questionId: 'q3', category: 'deployment', reason: 'manual' },
+              { questionId: 'q4', category: 'deployment', reason: 'manual' },
+              { questionId: 'q5', category: 'deployment', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const detector = new PatternDetector(skipHistory, {});
+      const patterns = detector.detectCategoryPatterns();
+
+      expect(patterns.length).toBeGreaterThan(0);
+      expect(patterns[0].category).toBe('deployment');
+      expect(patterns[0].type).toBe('category_skip');
+      expect(patterns[0].confidence).toBe(100); // 5/5 questions skipped
+    });
+
+    test('should detect framework-specific skip patterns', () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            frameworks: ['Next.js'],
+            skips: [
+              { questionId: 'q_routing', text: 'Routing setup?', category: 'frontend', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's2',
+            frameworks: ['Next.js'],
+            skips: [
+              { questionId: 'q_routing', text: 'Routing setup?', category: 'frontend', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's3',
+            frameworks: ['Next.js'],
+            skips: [
+              { questionId: 'q_routing', text: 'Routing setup?', category: 'frontend', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const detector = new PatternDetector(skipHistory, {}, { minSessionsForPattern: 3 });
+      const patterns = detector.detectFrameworkPatterns();
+
+      expect(patterns.length).toBeGreaterThan(0);
+      expect(patterns[0].framework).toBe('Next.js');
+      expect(patterns[0].questionId).toBe('q_routing');
+      expect(patterns[0].confidence).toBe(100); // 3/3 Next.js sessions
+    });
+
+    test('should detect user preference patterns', () => {
+      const skipHistory = { sessions: [] };
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            answers: [
+              { questionId: 'q1', category: 'testing', wordCount: 15 },
+              { questionId: 'q2', category: 'testing', wordCount: 18 },
+              { questionId: 'q3', category: 'testing', wordCount: 20 }
+            ]
+          }
+        ]
+      };
+
+      const detector = new PatternDetector(skipHistory, answerHistory);
+      const patterns = detector.detectUserPreferences();
+
+      expect(patterns.length).toBeGreaterThan(0);
+      expect(patterns[0].category).toBe('testing');
+      expect(patterns[0].preference).toBe('brief_answers');
+      expect(patterns[0].avgWordCount).toBeLessThan(30);
+    });
+
+    test('should detect detailed answer preferences', () => {
+      const skipHistory = { sessions: [] };
+      const answerHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            answers: [
+              { questionId: 'q1', category: 'architecture', wordCount: 120 },
+              { questionId: 'q2', category: 'architecture', wordCount: 150 },
+              { questionId: 'q3', category: 'architecture', wordCount: 110 }
+            ]
+          }
+        ]
+      };
+
+      const detector = new PatternDetector(skipHistory, answerHistory);
+      const patterns = detector.detectUserPreferences();
+
+      expect(patterns.length).toBeGreaterThan(0);
+      expect(patterns[0].category).toBe('architecture');
+      expect(patterns[0].preference).toBe('detailed_answers');
+      expect(patterns[0].avgWordCount).toBeGreaterThan(100);
+    });
+
+    test('should aggregate all pattern types', () => {
+      const skipHistory = {
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's2',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's3',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      const detector = new PatternDetector(skipHistory, {}, { minSessionsForPattern: 3 });
+      const allPatterns = detector.detectAllPatterns();
+
+      expect(allPatterns).toHaveProperty('consistentSkips');
+      expect(allPatterns).toHaveProperty('categoryPatterns');
+      expect(allPatterns).toHaveProperty('frameworkPatterns');
+      expect(allPatterns).toHaveProperty('userPreferences');
+      expect(allPatterns.consistentSkips.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('detectPatterns', () => {
+    test('should detect patterns from project files', async () => {
+      const skipHistory = {
+        version: '1.0',
+        sessions: [
+          {
+            sessionId: 's1',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's2',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' }
+            ]
+          },
+          {
+            sessionId: 's3',
+            skips: [
+              { questionId: 'q1', category: 'deployment', reason: 'manual' }
+            ]
+          }
+        ]
+      };
+
+      await fs.ensureDir(path.join(tempDir, '.adf', 'learning'));
+      await fs.writeJSON(path.join(tempDir, '.adf', 'learning', 'skip-history.json'), skipHistory);
+      await fs.writeJSON(path.join(tempDir, '.adf', 'learning', 'answer-history.json'), { version: '1.0', sessions: [] });
+      await fs.writeJSON(path.join(tempDir, '.adf', 'learning', 'config.json'), { minSessionsForPattern: 3 });
+
+      const patterns = await detectPatterns(tempDir);
+
+      expect(patterns).toHaveProperty('consistentSkips');
+      expect(patterns.consistentSkips.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getPatternSummary', () => {
+    test('should summarize patterns by confidence level', () => {
+      const patterns = {
+        consistentSkips: [
+          { confidence: 90 },
+          { confidence: 70 },
+          { confidence: 50 }
+        ],
+        categoryPatterns: [
+          { confidence: 85 }
+        ],
+        frameworkPatterns: [],
+        userPreferences: []
+      };
+
+      const summary = getPatternSummary(patterns);
+
+      expect(summary.total).toBe(4);
+      expect(summary.highConfidence).toBe(2); // 90, 85
+      expect(summary.mediumConfidence).toBe(1); // 70
+      expect(summary.lowConfidence).toBe(1); // 50
+      expect(summary.byType.consistentSkips).toBe(3);
+      expect(summary.byType.categoryPatterns).toBe(1);
+    });
+
+    test('should handle empty patterns', () => {
+      const patterns = {
+        consistentSkips: [],
+        categoryPatterns: [],
+        frameworkPatterns: [],
+        userPreferences: []
+      };
+
+      const summary = getPatternSummary(patterns);
+
+      expect(summary.total).toBe(0);
+      expect(summary.highConfidence).toBe(0);
+      expect(summary.mediumConfidence).toBe(0);
+      expect(summary.lowConfidence).toBe(0);
+    });
+  });
+});

package/tests/project-analyzer.test.js

@@ -0,0 +1,221 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { analyzeProject, getProjectSummary, PROJECT_TYPES } = require('../lib/analyzers/project-analyzer');
+
+describe('Project Analyzer', () => {
+  const tempDir = path.join(__dirname, 'temp-test-project');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  describe('analyzeProject', () => {
+    test('should detect React web app from package.json', async () => {
+      // Create package.json with React
+      const packageJson = {
+        name: 'test-app',
+        version: '1.0.0',
+        description: 'A React web application',
+        dependencies: {
+          react: '^18.0.0',
+          'react-dom': '^18.0.0'
+        }
+      };
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), packageJson);
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.type).toBe(PROJECT_TYPES.WEB_APP);
+      expect(context.frameworks).toContain('React');
+      expect(context.languages).toContain('JavaScript/TypeScript');
+      expect(context.confidence).toBeGreaterThan(50);
+    });
+
+    test('should detect CLI tool from package.json bin field', async () => {
+      const packageJson = {
+        name: 'test-cli',
+        version: '1.0.0',
+        description: 'A command-line tool',
+        bin: {
+          'test-cli': 'bin/cli.js'
+        },
+        dependencies: {
+          commander: '^9.0.0'
+        }
+      };
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), packageJson);
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.type).toBe(PROJECT_TYPES.CLI_TOOL);
+      expect(context.confidence).toBeGreaterThan(50);
+    });
+
+    test('should detect npm library from package.json main field', async () => {
+      const packageJson = {
+        name: 'test-library',
+        version: '1.0.0',
+        description: 'A utility library',
+        main: 'index.js',
+        private: false
+      };
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), packageJson);
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.type).toBe(PROJECT_TYPES.LIBRARY);
+      expect(context.confidence).toBeGreaterThan(30);
+    });
+
+    test('should detect API server from dependencies', async () => {
+      const packageJson = {
+        name: 'test-api',
+        version: '1.0.0',
+        description: 'RESTful API server',
+        dependencies: {
+          express: '^4.18.0',
+          cors: '^2.8.5'
+        }
+      };
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), packageJson);
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.type).toBe(PROJECT_TYPES.API_SERVER);
+      expect(context.frameworks).toContain('Express');
+    });
+
+    test('should detect fullstack app with React and Express', async () => {
+      const packageJson = {
+        name: 'test-fullstack',
+        version: '1.0.0',
+        dependencies: {
+          react: '^18.0.0',
+          express: '^4.18.0'
+        }
+      };
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), packageJson);
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.type).toBe(PROJECT_TYPES.FULLSTACK);
+      expect(context.frameworks).toContain('React');
+      expect(context.frameworks).toContain('Express');
+    });
+
+    test('should extract description from README', async () => {
+      const readmeContent = `# Test Project
+
+This is a test project for demonstrating the analyzer. It has a clear description.
+
+## Features
+
+- Feature 1
+- Feature 2
+`;
+
+      await fs.writeFile(path.join(tempDir, 'README.md'), readmeContent);
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.description).toBeTruthy();
+      expect(context.description).toContain('test project');
+    });
+
+    test('should detect test framework presence', async () => {
+      const packageJson = {
+        name: 'test-project',
+        devDependencies: {
+          jest: '^29.0.0'
+        }
+      };
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), packageJson);
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.hasTests).toBe(true);
+    });
+
+    test('should detect Docker presence', async () => {
+      await fs.writeFile(path.join(tempDir, 'Dockerfile'), 'FROM node:18');
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.hasDocker).toBe(true);
+    });
+
+    test('should handle project with no package.json gracefully', async () => {
+      const context = await analyzeProject(tempDir);
+
+      expect(context.type).toBe(PROJECT_TYPES.UNKNOWN);
+      expect(context.confidence).toBeLessThan(50);
+    });
+  });
+
+  describe('getProjectSummary', () => {
+    test('should return readable summary for web app', () => {
+      const context = {
+        type: PROJECT_TYPES.WEB_APP,
+        frameworks: ['React', 'Next.js'],
+        languages: ['JavaScript/TypeScript'],
+        confidence: 90
+      };
+
+      const summary = getProjectSummary(context);
+
+      expect(summary).toContain('Web Application');
+      expect(summary).toContain('React');
+      expect(summary).toContain('Next.js');
+    });
+
+    test('should return readable summary for CLI tool', () => {
+      const context = {
+        type: PROJECT_TYPES.CLI_TOOL,
+        frameworks: [],
+        languages: ['JavaScript/TypeScript'],
+        confidence: 85
+      };
+
+      const summary = getProjectSummary(context);
+
+      expect(summary).toContain('CLI Tool');
+    });
+  });
+
+  describe('Confidence scoring', () => {
+    test('should have high confidence with complete information', async () => {
+      const packageJson = {
+        name: 'complete-project',
+        version: '1.0.0',
+        description: 'A complete project with all metadata',
+        bin: { cli: 'bin/cli.js' },
+        dependencies: { commander: '^9.0.0' },
+        devDependencies: { jest: '^29.0.0' }
+      };
+
+      await fs.writeJson(path.join(tempDir, 'package.json'), packageJson);
+      await fs.writeFile(path.join(tempDir, 'README.md'), '# Project\n\nDescription here');
+      await fs.writeFile(path.join(tempDir, 'Dockerfile'), 'FROM node:18');
+
+      const context = await analyzeProject(tempDir);
+
+      expect(context.confidence).toBeGreaterThanOrEqual(75);
+    });
+
+    test('should have low confidence with minimal information', async () => {
+      const context = await analyzeProject(tempDir);
+
+      expect(context.confidence).toBeLessThan(50);
+    });
+  });
+});