create-byan-agent 2.1.0 → 2.1.1

package/__tests__/byan-v2/dispatcher/task-router.test.js

@@ -1,265 +0,0 @@
-/**
- * TaskRouter Tests - TDD
- * AC: Intègre ComplexityScorer + TaskToolInterface
- * Thresholds: <30 → task-tool, 30-60 → task-tool+fallback, >60 → local
- */
-
-const TaskRouter = require('../../../src/byan-v2/dispatcher/task-router');
-
-describe('TaskRouter', () => {
-  let router;
-
-  beforeEach(() => {
-    router = new TaskRouter();
-  });
-
-  describe('AC1: Instanciation et Configuration', () => {
-    test('should initialize with default thresholds', () => {
-      expect(router).toBeDefined();
-      expect(router.thresholds).toEqual({
-        taskToolOnly: 30,
-        taskToolWithFallback: 60
-      });
-    });
-
-    test('should accept custom thresholds', () => {
-      const customRouter = new TaskRouter({
-        taskToolOnly: 25,
-        taskToolWithFallback: 55
-      });
-      expect(customRouter.thresholds.taskToolOnly).toBe(25);
-      expect(customRouter.thresholds.taskToolWithFallback).toBe(55);
-    });
-  });
-
-  describe('AC2: Route Simple Task (complexity < 30)', () => {
-    test('should route simple task to task-tool only', () => {
-      const task = {
-        type: 'explore',
-        prompt: 'Find login component',
-        metadata: { priority: 'low' }
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result).toMatchObject({
-        executor: 'task-tool',
-        canFallback: false,
-        complexity: expect.any(Number)
-      });
-      expect(result.complexity).toBeLessThan(30);
-    });
-
-    test('should include task and reasoning in result', () => {
-      const task = {
-        type: 'explore',
-        prompt: 'List files'
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result.task).toEqual(task);
-      expect(result.reasoning).toContain('complexity');
-      expect(result.reasoning).toContain('task-tool');
-    });
-  });
-
-  describe('AC3: Route Medium Task (30 <= complexity <= 60)', () => {
-    test('should route medium task to task-tool with fallback', () => {
-      const task = {
-        type: 'task',
-        prompt: 'Run tests and analyze failures with detailed error messages',
-        metadata: { 
-          requiresContext: true,
-          estimatedDuration: 'medium'
-        }
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result).toMatchObject({
-        executor: 'task-tool',
-        canFallback: true,
-        complexity: expect.any(Number)
-      });
-      expect(result.complexity).toBeGreaterThanOrEqual(30);
-      expect(result.complexity).toBeLessThanOrEqual(60);
-    });
-
-    test('should explain fallback capability in reasoning', () => {
-      const task = {
-        type: 'task',
-        prompt: 'Install dependencies and run build with error handling',
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result.canFallback).toBe(true);
-      expect(result.reasoning).toContain('fallback');
-    });
-  });
-
-  describe('AC4: Route Complex Task (complexity > 60)', () => {
-    test('should route complex task to local execution', () => {
-      const task = {
-        type: 'general-purpose',
-        prompt: 'Refactor authentication system across multiple modules with comprehensive testing and documentation updates',
-        metadata: {
-          requiresMultipleSteps: true,
-          requiresContext: true,
-          requiresReasoning: true
-        }
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result).toMatchObject({
-        executor: 'local',
-        canFallback: false,
-        complexity: expect.any(Number)
-      });
-      expect(result.complexity).toBeGreaterThan(60);
-    });
-
-    test('should explain local execution in reasoning', () => {
-      const task = {
-        type: 'general-purpose',
-        prompt: 'Design and implement complete feature with architecture decisions, multiple components, tests, and documentation'
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result.executor).toBe('local');
-      expect(result.reasoning).toContain('local');
-      expect(result.reasoning).toContain('complex');
-    });
-  });
-
-  describe('AC5: Edge Cases', () => {
-    test('should handle task at exact threshold boundaries', () => {
-      const router = new TaskRouter({
-        taskToolOnly: 30,
-        taskToolWithFallback: 60
-      });
-
-      // Test routing logic with known complexity values
-      // Just verify that routing decisions are consistent
-      const lowTask = {
-        type: 'explore',
-        prompt: 'Find'
-      };
-      
-      const mediumTask = {
-        type: 'task',
-        prompt: 'Run tests and analyze failures',
-        metadata: { requiresContext: true }
-      };
-      
-      const highTask = {
-        type: 'general-purpose',
-        prompt: 'Complete refactoring',
-        metadata: { requiresMultipleSteps: true, requiresReasoning: true }
-      };
-      
-      const lowResult = router.routeTask(lowTask);
-      const mediumResult = router.routeTask(mediumTask);
-      const highResult = router.routeTask(highTask);
-      
-      // Verify progression
-      expect(lowResult.complexity).toBeLessThan(mediumResult.complexity);
-      expect(mediumResult.complexity).toBeLessThan(highResult.complexity);
-      
-      // Verify appropriate routing
-      expect(['task-tool']).toContain(lowResult.executor);
-      expect(['task-tool', 'local']).toContain(mediumResult.executor);
-      expect(['local']).toContain(highResult.executor);
-    });
-
-    test('should handle missing task properties gracefully', () => {
-      const task = {
-        type: 'explore'
-        // No prompt
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result).toBeDefined();
-      expect(result.executor).toBeDefined();
-      expect(result.complexity).toBeGreaterThanOrEqual(0);
-    });
-
-    test('should handle null or undefined task', () => {
-      expect(() => router.routeTask(null)).toThrow();
-      expect(() => router.routeTask(undefined)).toThrow();
-    });
-
-    test('should validate task is an object', () => {
-      expect(() => router.routeTask('string')).toThrow();
-      expect(() => router.routeTask(123)).toThrow();
-    });
-  });
-
-  describe('AC6: Complexity Calculation Integration', () => {
-    test('should use ComplexityScorer for complexity calculation', () => {
-      const task = {
-        type: 'explore',
-        prompt: 'Simple search'
-      };
-
-      const result = router.routeTask(task);
-
-      // Verify complexity is calculated (not just a default value)
-      expect(typeof result.complexity).toBe('number');
-      expect(result.complexity).toBeGreaterThanOrEqual(0);
-      expect(result.complexity).toBeLessThanOrEqual(100);
-    });
-
-    test('should calculate different complexity for different tasks', () => {
-      const simpleTask = {
-        type: 'explore',
-        prompt: 'Find file'
-      };
-
-      const complexTask = {
-        type: 'general-purpose',
-        prompt: 'Refactor entire authentication system with migration scripts and comprehensive testing across all modules'
-      };
-
-      const simpleResult = router.routeTask(simpleTask);
-      const complexResult = router.routeTask(complexTask);
-
-      expect(complexResult.complexity).toBeGreaterThan(simpleResult.complexity);
-    });
-  });
-
-  describe('AC7: Result Format', () => {
-    test('should return complete result object with all required fields', () => {
-      const task = {
-        type: 'explore',
-        prompt: 'Test task'
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result).toHaveProperty('executor');
-      expect(result).toHaveProperty('canFallback');
-      expect(result).toHaveProperty('complexity');
-      expect(result).toHaveProperty('task');
-      expect(result).toHaveProperty('reasoning');
-      expect(result).toHaveProperty('timestamp');
-    });
-
-    test('should include valid timestamp', () => {
-      const task = {
-        type: 'explore',
-        prompt: 'Test'
-      };
-
-      const result = router.routeTask(task);
-
-      expect(result.timestamp).toBeDefined();
-      const timestamp = new Date(result.timestamp);
-      expect(timestamp.toString()).not.toBe('Invalid Date');
-    });
-  });
-});

package/__tests__/byan-v2/dispatcher/task-tool-interface.test.js

@@ -1,328 +0,0 @@
-const TaskToolInterface = require('../../../src/byan-v2/dispatcher/task-tool-interface');
-const MockTaskToolInterface = require('../../../src/byan-v2/dispatcher/task-tool-interface-mock');
-
-describe('TaskToolInterface', () => {
-  let taskTool;
-
-  beforeEach(() => {
-    taskTool = new TaskToolInterface();
-  });
-
-  describe('AC1: Class TaskToolInterface exists', () => {
-    test('should create instance', () => {
-      expect(taskTool).toBeInstanceOf(TaskToolInterface);
-    });
-
-    test('should have delegateTask method', () => {
-      expect(typeof taskTool.delegateTask).toBe('function');
-    });
-
-    test('delegateTask should be async', async () => {
-      // Use Mock for actual execution test
-      const mock = new MockTaskToolInterface({ delay: 10 });
-      const result = mock.delegateTask('test prompt', 'task');
-      expect(result).toBeInstanceOf(Promise);
-      await result; // Consume promise to avoid unhandled rejection
-    });
-  });
-
-  describe('AC2: Support agent types', () => {
-    test('should accept "task" agent type', async () => {
-      const mock = new MockTaskToolInterface({ delay: 10 });
-      
-      const result = await mock.delegateTask('test prompt', 'task');
-      
-      expect(result).toHaveProperty('output');
-      expect(result).toHaveProperty('metadata');
-    });
-
-    test('should accept "explore" agent type', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      const result = await mock.delegateTask('test prompt', 'explore');
-      
-      expect(result).toHaveProperty('output');
-    });
-
-    test('should accept "general-purpose" agent type', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      const result = await mock.delegateTask('test prompt', 'general-purpose');
-      
-      expect(result).toHaveProperty('output');
-    });
-
-    test('should throw error for unknown agent type', async () => {
-      await expect(taskTool.delegateTask('test', 'invalid-agent'))
-        .rejects
-        .toThrow('Invalid agent type: invalid-agent');
-    });
-
-    test('should validate agentType is provided', async () => {
-      await expect(taskTool.delegateTask('test'))
-        .rejects
-        .toThrow('agentType is required');
-    });
-  });
-
-  describe('AC3: Task Tool call construction', () => {
-    test('should construct proper call syntax', () => {
-      const syntax = TaskToolInterface.buildTaskCallSyntax('Run tests', 'task');
-      
-      expect(syntax).toContain('task');
-      expect(syntax).toContain('Run tests');
-    });
-
-    test('should handle special characters in prompt', () => {
-      const syntax = TaskToolInterface.buildTaskCallSyntax('Test "quotes" and \'apostrophes\'', 'task');
-      
-      expect(syntax).toBeDefined();
-      expect(typeof syntax).toBe('string');
-    });
-
-    test('should escape newlines in prompt', () => {
-      const syntax = TaskToolInterface.buildTaskCallSyntax('Line 1\nLine 2', 'task');
-      
-      expect(syntax).not.toContain('\n');
-    });
-
-    test('should document call syntax format', () => {
-      const doc = TaskToolInterface.getCallSyntaxDocumentation();
-      
-      expect(doc).toContain('agent_type');
-      expect(doc).toContain('prompt');
-    });
-  });
-
-  describe('AC4: Error handling', () => {
-    test('should timeout after 30 seconds', async () => {
-      const slowTask = new TaskToolInterface({ timeout: 100 });
-      
-      const startTime = Date.now();
-      
-      await expect(
-        slowTask.delegateTask('slow task', 'task')
-      ).rejects.toThrow();
-      
-      const elapsed = Date.now() - startTime;
-      expect(elapsed).toBeLessThan(150);
-    }, 10000);
-
-    test('should retry once on transient error', async () => {
-      let callCount = 0;
-      const retriableTask = new MockTaskToolInterface({
-        behavior: () => {
-          callCount++;
-          if (callCount === 1) {
-            throw new Error('ECONNRESET');
-          }
-          return { output: 'success after retry', metadata: {} };
-        }
-      });
-      
-      const result = await retriableTask.delegateTask('test', 'task');
-      
-      expect(callCount).toBe(2);
-      expect(result.output).toBe('success after retry');
-    });
-
-    test('should not retry on permanent errors', async () => {
-      let callCount = 0;
-      const nonRetriableTask = new MockTaskToolInterface({
-        behavior: () => {
-          callCount++;
-          throw new Error('Invalid syntax');
-        }
-      });
-      
-      await expect(
-        nonRetriableTask.delegateTask('test', 'task')
-      ).rejects.toThrow('Invalid syntax');
-      
-      expect(callCount).toBe(1);
-    });
-
-    test('should throw descriptive error on persistent failure', async () => {
-      const failingTask = new MockTaskToolInterface({
-        behavior: () => {
-          throw new Error('Network timeout');
-        }
-      });
-      
-      await expect(
-        failingTask.delegateTask('test', 'task')
-      ).rejects.toThrow(/Network timeout/);
-    });
-
-    test('should handle empty prompt', async () => {
-      await expect(
-        taskTool.delegateTask('', 'task')
-      ).rejects.toThrow('taskPrompt cannot be empty');
-    });
-
-    test('should handle null prompt', async () => {
-      await expect(
-        taskTool.delegateTask(null, 'task')
-      ).rejects.toThrow('taskPrompt cannot be empty');
-    });
-  });
-
-  describe('AC5: Response parsing', () => {
-    test('should return output property', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      const result = await mock.delegateTask('test', 'task');
-      
-      expect(result).toHaveProperty('output');
-      expect(typeof result.output).toBe('string');
-    });
-
-    test('should return metadata with tokens', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      const result = await mock.delegateTask('test', 'task');
-      
-      expect(result).toHaveProperty('metadata');
-      expect(result.metadata).toHaveProperty('tokens');
-      expect(typeof result.metadata.tokens).toBe('number');
-    });
-
-    test('should return metadata with duration', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      const result = await mock.delegateTask('test', 'task');
-      
-      expect(result.metadata).toHaveProperty('duration');
-      expect(typeof result.metadata.duration).toBe('number');
-    });
-
-    test('should handle missing metadata gracefully', async () => {
-      const mock = new MockTaskToolInterface({
-        behavior: () => ({ output: 'test', metadata: {} })
-      });
-      
-      const result = await mock.delegateTask('test', 'task');
-      
-      expect(result.metadata.tokens).toBeUndefined();
-      expect(result.metadata.duration).toBeUndefined();
-    });
-
-    test('should parse complex output', async () => {
-      const mock = new MockTaskToolInterface({
-        behavior: () => ({
-          output: JSON.stringify({ data: 'complex', nested: { value: 123 } }),
-          metadata: { tokens: 50, duration: 200 }
-        })
-      });
-      
-      const result = await mock.delegateTask('test', 'task');
-      
-      expect(result.output).toContain('complex');
-      expect(result.output).toContain('nested');
-    });
-  });
-
-  describe('AC6: Mock implementation', () => {
-    test('MockTaskToolInterface should exist', () => {
-      const mock = new MockTaskToolInterface();
-      expect(mock).toBeInstanceOf(MockTaskToolInterface);
-    });
-
-    test('should return predefined responses', async () => {
-      const mock = new MockTaskToolInterface({
-        responses: {
-          'test query': { output: 'predefined response', metadata: { tokens: 10 } }
-        }
-      });
-      
-      const result = await mock.delegateTask('test query', 'task');
-      
-      expect(result.output).toBe('predefined response');
-      expect(result.metadata.tokens).toBe(10);
-    });
-
-    test('should simulate delays between 100-500ms', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      const startTime = Date.now();
-      await mock.delegateTask('test', 'task');
-      const elapsed = Date.now() - startTime;
-      
-      expect(elapsed).toBeGreaterThanOrEqual(100);
-      expect(elapsed).toBeLessThan(600);
-    });
-
-    test('should support custom delay', async () => {
-      const mock = new MockTaskToolInterface({ delay: 50 });
-      
-      const startTime = Date.now();
-      await mock.delegateTask('test', 'task');
-      const elapsed = Date.now() - startTime;
-      
-      expect(elapsed).toBeGreaterThanOrEqual(50);
-      expect(elapsed).toBeLessThan(100);
-    });
-
-    test('should generate different responses for different prompts', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      const result1 = await mock.delegateTask('prompt 1', 'task');
-      const result2 = await mock.delegateTask('prompt 2', 'task');
-      
-      expect(result1.output).not.toBe(result2.output);
-    });
-
-    test('should track call history', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      await mock.delegateTask('call 1', 'task');
-      await mock.delegateTask('call 2', 'explore');
-      
-      expect(mock.getCallHistory()).toHaveLength(2);
-      expect(mock.getCallHistory()[0].prompt).toBe('call 1');
-      expect(mock.getCallHistory()[1].agentType).toBe('explore');
-    });
-
-    test('should allow clearing call history', async () => {
-      const mock = new MockTaskToolInterface();
-      
-      await mock.delegateTask('test', 'task');
-      expect(mock.getCallHistory()).toHaveLength(1);
-      
-      mock.clearHistory();
-      expect(mock.getCallHistory()).toHaveLength(0);
-    });
-  });
-
-  describe('Integration scenarios', () => {
-    test('should handle rapid sequential calls', async () => {
-      const mock = new MockTaskToolInterface({ delay: 10 });
-      
-      const promises = [
-        mock.delegateTask('task 1', 'task'),
-        mock.delegateTask('task 2', 'task'),
-        mock.delegateTask('task 3', 'task')
-      ];
-      
-      const results = await Promise.all(promises);
-      
-      expect(results).toHaveLength(3);
-      expect(results[0].output).toBeDefined();
-      expect(results[1].output).toBeDefined();
-      expect(results[2].output).toBeDefined();
-    });
-
-    test('should maintain independent state across instances', async () => {
-      const mock1 = new MockTaskToolInterface();
-      const mock2 = new MockTaskToolInterface();
-      
-      await mock1.delegateTask('test 1', 'task');
-      await mock2.delegateTask('test 2', 'task');
-      
-      expect(mock1.getCallHistory()).toHaveLength(1);
-      expect(mock2.getCallHistory()).toHaveLength(1);
-      expect(mock1.getCallHistory()[0].prompt).toBe('test 1');
-      expect(mock2.getCallHistory()[0].prompt).toBe('test 2');
-    });
-  });
-});