@iservu-inc/adf-cli 0.17.1 → 0.18.0

package/tests/tool-recommender.test.js

@@ -0,0 +1,218 @@
+const ToolRecommender = require('../lib/utils/tool-recommender');
+
+describe('ToolRecommender', () => {
+  function makeRecommender(overrides = {}) {
+    return new ToolRecommender({
+      workflow: 'balanced',
+      projectType: 'existing',
+      workflowContext: { teamSize: 'small', complexity: 'moderate', stage: 'active' },
+      installedTools: new Map(),
+      ...overrides
+    });
+  }
+
+  describe('scoreTool', () => {
+    test('should return scores for a valid tool', () => {
+      const rec = makeRecommender();
+      const result = rec.scoreTool('windsurf');
+      expect(result).not.toBeNull();
+      expect(result.toolId).toBe('windsurf');
+      expect(result.name).toBe('Windsurf');
+      expect(typeof result.totalScore).toBe('number');
+      expect(result.totalScore).toBeGreaterThan(0);
+      expect(result.totalScore).toBeLessThanOrEqual(110); // max possible with bonuses
+    });
+
+    test('should return null for unknown tool', () => {
+      const rec = makeRecommender();
+      expect(rec.scoreTool('nonexistent')).toBeNull();
+    });
+
+    test('all tools should have scores in valid range', () => {
+      const rec = makeRecommender();
+      const toolIds = ['antigravity', 'zed', 'claude-code', 'gemini-cli', 'opencode',
+        'deepagent', 'windsurf', 'cursor', 'vscode', 'codex-cli', 'kiro', 'trae'];
+      for (const id of toolIds) {
+        const result = rec.scoreTool(id);
+        expect(result).not.toBeNull();
+        expect(result.totalScore).toBeGreaterThan(0);
+        expect(result.totalScore).toBeLessThanOrEqual(110);
+      }
+    });
+
+    test('should have six scoring dimensions', () => {
+      const rec = makeRecommender();
+      const result = rec.scoreTool('windsurf');
+      expect(result.scores).toHaveProperty('automation');
+      expect(result.scores).toHaveProperty('skillIntegration');
+      expect(result.scores).toHaveProperty('orchestration');
+      expect(result.scores).toHaveProperty('generatorMaturity');
+      expect(result.scores).toHaveProperty('workflowAlignment');
+      expect(result.scores).toHaveProperty('modelStratification');
+    });
+  });
+
+  describe('workflow alignment', () => {
+    test('comprehensive workflow should favor agent-first tools (tier 1)', () => {
+      const rec = makeRecommender({ workflow: 'comprehensive' });
+      const antigravity = rec.scoreTool('antigravity');
+      const trae = rec.scoreTool('trae');
+      // Antigravity (tier 1) should get higher workflow alignment than Trae (tier 3)
+      expect(antigravity.scores.workflowAlignment).toBeGreaterThan(trae.scores.workflowAlignment);
+    });
+
+    test('rapid workflow should favor CLI tools', () => {
+      const rec = makeRecommender({ workflow: 'rapid' });
+      const claudeCode = rec.scoreTool('claude-code');
+      const windsurf = rec.scoreTool('windsurf');
+      // CLI tool should get higher workflow alignment for rapid
+      expect(claudeCode.scores.workflowAlignment).toBeGreaterThan(windsurf.scores.workflowAlignment);
+    });
+
+    test('balanced workflow should favor established IDEs', () => {
+      const rec = makeRecommender({ workflow: 'balanced' });
+      const windsurf = rec.scoreTool('windsurf');
+      const codexCli = rec.scoreTool('codex-cli');
+      // Windsurf (tier 3 IDE) should get higher workflow alignment for balanced
+      expect(windsurf.scores.workflowAlignment).toBeGreaterThan(codexCli.scores.workflowAlignment);
+    });
+  });
+
+  describe('installation bonus', () => {
+    test('should add bonus for installed tools', () => {
+      const installed = new Map([['windsurf', { installed: true, method: 'binary', path: '/usr/bin/windsurf' }]]);
+      const recInstalled = makeRecommender({ installedTools: installed });
+      const recNotInstalled = makeRecommender();
+
+      const withBonus = recInstalled.scoreTool('windsurf');
+      const withoutBonus = recNotInstalled.scoreTool('windsurf');
+
+      expect(withBonus.totalScore).toBe(withoutBonus.totalScore + 5);
+      expect(withBonus.installed).toBe(true);
+      expect(withoutBonus.installed).toBe(false);
+    });
+  });
+
+  describe('context modifier', () => {
+    test('large team should boost IDE tools', () => {
+      const recLarge = makeRecommender({
+        workflowContext: { teamSize: 'large', complexity: 'moderate', stage: 'active' }
+      });
+      const recSolo = makeRecommender({
+        workflowContext: { teamSize: 'solo', complexity: 'moderate', stage: 'active' }
+      });
+
+      const largeWindsurf = recLarge.scoreTool('windsurf');
+      const soloWindsurf = recSolo.scoreTool('windsurf');
+      expect(largeWindsurf.contextMod).toBeGreaterThan(soloWindsurf.contextMod);
+    });
+
+    test('complex projects should boost low-tier tools', () => {
+      const recComplex = makeRecommender({
+        workflowContext: { teamSize: 'small', complexity: 'very-complex', stage: 'active' }
+      });
+      const recSimple = makeRecommender({
+        workflowContext: { teamSize: 'small', complexity: 'simple', stage: 'active' }
+      });
+
+      const complexClaude = recComplex.scoreTool('claude-code');
+      const simpleClaude = recSimple.scoreTool('claude-code');
+      expect(complexClaude.contextMod).toBeGreaterThan(simpleClaude.contextMod);
+    });
+  });
+
+  describe('recommend', () => {
+    test('should return primary, complementary, ranked, and pairings', () => {
+      const rec = makeRecommender();
+      const result = rec.recommend();
+
+      expect(result).toHaveProperty('primary');
+      expect(result).toHaveProperty('complementary');
+      expect(result).toHaveProperty('ranked');
+      expect(result).toHaveProperty('pairings');
+
+      expect(result.primary).not.toBeNull();
+      expect(result.primary.recommended).toBe(true);
+      expect(result.primary.reason).toBeTruthy();
+    });
+
+    test('complementary tools should be from different category than primary', () => {
+      const rec = makeRecommender();
+      const result = rec.recommend();
+
+      if (result.complementary.length > 0) {
+        const ToolFeatureRegistry = require('../lib/utils/tool-feature-registry');
+        const primaryConfig = ToolFeatureRegistry.getDetectionConfig(result.primary.toolId);
+        for (const comp of result.complementary) {
+          const compConfig = ToolFeatureRegistry.getDetectionConfig(comp.toolId);
+          expect(compConfig.category).not.toBe(primaryConfig.category);
+        }
+      }
+    });
+
+    test('ranked list should be sorted by totalScore descending', () => {
+      const rec = makeRecommender();
+      const result = rec.recommend();
+
+      for (let i = 1; i < result.ranked.length; i++) {
+        expect(result.ranked[i - 1].totalScore).toBeGreaterThanOrEqual(result.ranked[i].totalScore);
+      }
+    });
+
+    test('ranked list should include all scored tools', () => {
+      const rec = makeRecommender();
+      const result = rec.recommend();
+      expect(result.ranked.length).toBe(12); // 12 tools with base scores
+    });
+
+    test('complementary should have max 2 entries', () => {
+      const rec = makeRecommender();
+      const result = rec.recommend();
+      expect(result.complementary.length).toBeLessThanOrEqual(2);
+    });
+
+    test('pairings should have max 3 entries', () => {
+      const rec = makeRecommender();
+      const result = rec.recommend();
+      expect(result.pairings.length).toBeLessThanOrEqual(3);
+    });
+  });
+
+  describe('formatForDisplay', () => {
+    test('should produce formatted string output', () => {
+      const rec = makeRecommender();
+      const result = rec.recommend();
+      const display = ToolRecommender.formatForDisplay(result);
+
+      expect(typeof display).toBe('string');
+      expect(display.length).toBeGreaterThan(0);
+      // Should contain the primary tool name
+      expect(display).toContain(result.primary.name);
+    });
+
+    test('should handle null recommendation', () => {
+      const display = ToolRecommender.formatForDisplay(null);
+      expect(display).toContain('No tool recommendations');
+    });
+
+    test('should handle recommendation with no primary', () => {
+      const display = ToolRecommender.formatForDisplay({ primary: null, complementary: [], ranked: [], pairings: [] });
+      expect(display).toContain('No tool recommendations');
+    });
+
+    test('should show install status indicators', () => {
+      // Mark the primary recommended tool as installed so [Installed] appears in the Primary line
+      const rec = makeRecommender();
+      const preResult = rec.recommend();
+      const primaryId = preResult.primary.toolId;
+
+      const installed = new Map([[primaryId, { installed: true, method: 'binary', path: '/usr/bin/test' }]]);
+      const rec2 = makeRecommender({ installedTools: installed });
+      const result = rec2.recommend();
+      const display = ToolRecommender.formatForDisplay(result);
+
+      // Primary line should show [Installed]
+      expect(display).toContain('Installed');
+    });
+  });
+});