create-byan-agent 2.0.1 → 2.1.0

package/__tests__/byan-v2/context/session-state.test.js

@@ -0,0 +1,322 @@
+const SessionState = require('../../../src/byan-v2/context/session-state');
+
+describe('SessionState Manager', () => {
+  let sessionState;
+
+  beforeEach(() => {
+    sessionState = new SessionState();
+  });
+
+  describe('AC1: Class SessionState with properties', () => {
+    test('should create instance with required properties', () => {
+      expect(sessionState).toHaveProperty('sessionId');
+      expect(sessionState).toHaveProperty('currentState');
+      expect(sessionState).toHaveProperty('questionHistory');
+      expect(sessionState).toHaveProperty('userResponses');
+      expect(sessionState).toHaveProperty('analysisResults');
+      expect(sessionState).toHaveProperty('agentProfileDraft');
+    });
+
+    test('should initialize with valid UUID sessionId', () => {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      expect(sessionState.sessionId).toMatch(uuidRegex);
+    });
+
+    test('should start in INTERVIEW state', () => {
+      expect(sessionState.currentState).toBe('INTERVIEW');
+    });
+
+    test('should initialize arrays as empty', () => {
+      expect(sessionState.questionHistory).toEqual([]);
+      expect(sessionState.userResponses).toEqual([]);
+    });
+
+    test('should initialize objects as empty', () => {
+      expect(sessionState.analysisResults).toEqual({});
+      expect(sessionState.agentProfileDraft).toEqual({});
+    });
+  });
+
+  describe('AC2: CRUD Methods', () => {
+    describe('addQuestion()', () => {
+      test('should add question to history with timestamp', () => {
+        const question = 'What is your project name?';
+        const beforeTime = Date.now();
+        
+        sessionState.addQuestion(question);
+        
+        const afterTime = Date.now();
+        expect(sessionState.questionHistory).toHaveLength(1);
+        expect(sessionState.questionHistory[0].question).toBe(question);
+        expect(sessionState.questionHistory[0].timestamp).toBeGreaterThanOrEqual(beforeTime);
+        expect(sessionState.questionHistory[0].timestamp).toBeLessThanOrEqual(afterTime);
+      });
+
+      test('should handle multiple questions', () => {
+        sessionState.addQuestion('Question 1');
+        sessionState.addQuestion('Question 2');
+        sessionState.addQuestion('Question 3');
+        
+        expect(sessionState.questionHistory).toHaveLength(3);
+        expect(sessionState.questionHistory[0].question).toBe('Question 1');
+        expect(sessionState.questionHistory[2].question).toBe('Question 3');
+      });
+    });
+
+    describe('addResponse()', () => {
+      test('should record user response with timestamp', () => {
+        const questionId = 'q1';
+        const response = 'My project is BYAN';
+        const beforeTime = Date.now();
+        
+        sessionState.addResponse(questionId, response);
+        
+        const afterTime = Date.now();
+        expect(sessionState.userResponses).toHaveLength(1);
+        expect(sessionState.userResponses[0].questionId).toBe(questionId);
+        expect(sessionState.userResponses[0].response).toBe(response);
+        expect(sessionState.userResponses[0].timestamp).toBeGreaterThanOrEqual(beforeTime);
+        expect(sessionState.userResponses[0].timestamp).toBeLessThanOrEqual(afterTime);
+      });
+
+      test('should handle multiple responses', () => {
+        sessionState.addResponse('q1', 'Answer 1');
+        sessionState.addResponse('q2', 'Answer 2');
+        
+        expect(sessionState.userResponses).toHaveLength(2);
+      });
+    });
+
+    describe('setAnalysisResults()', () => {
+      test('should store analysis results', () => {
+        const results = {
+          agentType: 'specialist',
+          complexity: 'medium',
+          estimatedTime: '4h'
+        };
+        
+        sessionState.setAnalysisResults(results);
+        
+        expect(sessionState.analysisResults).toEqual(results);
+      });
+
+      test('should overwrite previous analysis results', () => {
+        sessionState.setAnalysisResults({ version: 1 });
+        sessionState.setAnalysisResults({ version: 2 });
+        
+        expect(sessionState.analysisResults).toEqual({ version: 2 });
+      });
+    });
+
+    describe('getCurrentState()', () => {
+      test('should return current state', () => {
+        expect(sessionState.getCurrentState()).toBe('INTERVIEW');
+      });
+    });
+
+    describe('transitionTo()', () => {
+      test('should change state with valid transition', () => {
+        // Prepare: add 5 responses for valid transition
+        for (let i = 1; i <= 5; i++) {
+          sessionState.addResponse(`q${i}`, `Answer ${i}`);
+        }
+        
+        sessionState.transitionTo('ANALYSIS');
+        
+        expect(sessionState.getCurrentState()).toBe('ANALYSIS');
+      });
+    });
+  });
+
+  describe('AC3: Transition Validation', () => {
+    test('INTERVIEW -> ANALYSIS: valid with >= 5 responses', () => {
+      for (let i = 1; i <= 5; i++) {
+        sessionState.addResponse(`q${i}`, `Answer ${i}`);
+      }
+      
+      expect(() => {
+        sessionState.transitionTo('ANALYSIS');
+      }).not.toThrow();
+      
+      expect(sessionState.getCurrentState()).toBe('ANALYSIS');
+    });
+
+    test('INTERVIEW -> ANALYSIS: invalid with < 5 responses', () => {
+      sessionState.addResponse('q1', 'Answer 1');
+      sessionState.addResponse('q2', 'Answer 2');
+      
+      expect(() => {
+        sessionState.transitionTo('ANALYSIS');
+      }).toThrow('Cannot transition from INTERVIEW to ANALYSIS: requires at least 5 responses');
+    });
+
+    test('ANALYSIS -> GENERATION: valid with non-empty analysisResults', () => {
+      // Setup: move to ANALYSIS state first
+      for (let i = 1; i <= 5; i++) {
+        sessionState.addResponse(`q${i}`, `Answer ${i}`);
+      }
+      sessionState.transitionTo('ANALYSIS');
+      
+      sessionState.setAnalysisResults({ agentType: 'specialist' });
+      
+      expect(() => {
+        sessionState.transitionTo('GENERATION');
+      }).not.toThrow();
+      
+      expect(sessionState.getCurrentState()).toBe('GENERATION');
+    });
+
+    test('ANALYSIS -> GENERATION: invalid with empty analysisResults', () => {
+      // Setup: move to ANALYSIS state first
+      for (let i = 1; i <= 5; i++) {
+        sessionState.addResponse(`q${i}`, `Answer ${i}`);
+      }
+      sessionState.transitionTo('ANALYSIS');
+      
+      expect(() => {
+        sessionState.transitionTo('GENERATION');
+      }).toThrow('Cannot transition from ANALYSIS to GENERATION: analysisResults cannot be empty');
+    });
+
+    test('should throw error on invalid transition INTERVIEW -> GENERATION', () => {
+      expect(() => {
+        sessionState.transitionTo('GENERATION');
+      }).toThrow('Invalid state transition from INTERVIEW to GENERATION');
+    });
+
+    test('should throw error on invalid transition GENERATION -> INTERVIEW', () => {
+      // Setup: get to GENERATION state
+      for (let i = 1; i <= 5; i++) {
+        sessionState.addResponse(`q${i}`, `Answer ${i}`);
+      }
+      sessionState.transitionTo('ANALYSIS');
+      sessionState.setAnalysisResults({ data: 'test' });
+      sessionState.transitionTo('GENERATION');
+      
+      expect(() => {
+        sessionState.transitionTo('INTERVIEW');
+      }).toThrow('Invalid state transition from GENERATION to INTERVIEW');
+    });
+
+    test('should throw error on invalid transition ANALYSIS -> INTERVIEW', () => {
+      // Setup: get to ANALYSIS state
+      for (let i = 1; i <= 5; i++) {
+        sessionState.addResponse(`q${i}`, `Answer ${i}`);
+      }
+      sessionState.transitionTo('ANALYSIS');
+      
+      expect(() => {
+        sessionState.transitionTo('INTERVIEW');
+      }).toThrow('Invalid state transition from ANALYSIS to INTERVIEW');
+    });
+
+    test('should throw error on unknown state', () => {
+      expect(() => {
+        sessionState.transitionTo('INVALID_STATE');
+      }).toThrow();
+    });
+  });
+
+  describe('AC4: Serialization', () => {
+    test('toJSON() should serialize all properties', () => {
+      sessionState.addQuestion('Q1');
+      sessionState.addResponse('q1', 'A1');
+      
+      const json = sessionState.toJSON();
+      
+      expect(json).toHaveProperty('sessionId');
+      expect(json).toHaveProperty('currentState', 'INTERVIEW');
+      expect(json).toHaveProperty('questionHistory');
+      expect(json).toHaveProperty('userResponses');
+      expect(json).toHaveProperty('analysisResults');
+      expect(json).toHaveProperty('agentProfileDraft');
+      expect(json.questionHistory).toHaveLength(1);
+      expect(json.userResponses).toHaveLength(1);
+    });
+
+    test('toJSON() should return plain object, not instance', () => {
+      const json = sessionState.toJSON();
+      
+      expect(json).not.toBeInstanceOf(SessionState);
+      expect(typeof json).toBe('object');
+    });
+
+    test('fromJSON() should restore state from JSON', () => {
+      sessionState.addQuestion('Original Question');
+      sessionState.addResponse('q1', 'Original Response');
+      for (let i = 2; i <= 5; i++) {
+        sessionState.addResponse(`q${i}`, `Response ${i}`);
+      }
+      sessionState.transitionTo('ANALYSIS');
+      sessionState.setAnalysisResults({ test: 'data' });
+      
+      const json = sessionState.toJSON();
+      const restored = SessionState.fromJSON(json);
+      
+      expect(restored.sessionId).toBe(sessionState.sessionId);
+      expect(restored.currentState).toBe('ANALYSIS');
+      expect(restored.questionHistory).toEqual(sessionState.questionHistory);
+      expect(restored.userResponses).toEqual(sessionState.userResponses);
+      expect(restored.analysisResults).toEqual({ test: 'data' });
+    });
+
+    test('fromJSON() should return SessionState instance', () => {
+      const json = sessionState.toJSON();
+      const restored = SessionState.fromJSON(json);
+      
+      expect(restored).toBeInstanceOf(SessionState);
+      expect(typeof restored.addQuestion).toBe('function');
+      expect(typeof restored.transitionTo).toBe('function');
+    });
+
+    test('fromJSON() should handle empty data', () => {
+      const json = {
+        sessionId: '12345678-1234-4234-8234-123456789012',
+        currentState: 'INTERVIEW',
+        questionHistory: [],
+        userResponses: [],
+        analysisResults: {},
+        agentProfileDraft: {}
+      };
+      
+      const restored = SessionState.fromJSON(json);
+      
+      expect(restored.sessionId).toBe(json.sessionId);
+      expect(restored.currentState).toBe('INTERVIEW');
+    });
+  });
+
+  describe('AC5: Edge Cases & Validation', () => {
+    test('should handle empty question string', () => {
+      sessionState.addQuestion('');
+      
+      expect(sessionState.questionHistory).toHaveLength(1);
+      expect(sessionState.questionHistory[0].question).toBe('');
+    });
+
+    test('should handle null analysis results', () => {
+      sessionState.setAnalysisResults(null);
+      
+      expect(sessionState.analysisResults).toBeNull();
+    });
+
+    test('should preserve order of questions and responses', () => {
+      sessionState.addQuestion('Q1');
+      sessionState.addQuestion('Q2');
+      sessionState.addResponse('q1', 'A1');
+      sessionState.addResponse('q2', 'A2');
+      
+      expect(sessionState.questionHistory[0].question).toBe('Q1');
+      expect(sessionState.questionHistory[1].question).toBe('Q2');
+      expect(sessionState.userResponses[0].response).toBe('A1');
+      expect(sessionState.userResponses[1].response).toBe('A2');
+    });
+
+    test('should generate unique sessionId for each instance', () => {
+      const state1 = new SessionState();
+      const state2 = new SessionState();
+      
+      expect(state1.sessionId).not.toBe(state2.sessionId);
+    });
+  });
+});

package/__tests__/byan-v2/dispatcher/complexity-scorer.test.js

@@ -0,0 +1,358 @@
+const ComplexityScorer = require('../../../src/byan-v2/dispatcher/complexity-scorer');
+
+describe('Complexity Scoring Algorithm', () => {
+  let scorer;
+
+  beforeEach(() => {
+    scorer = new ComplexityScorer();
+  });
+
+  describe('AC1: Class exists with calculateComplexity method', () => {
+    test('should create instance', () => {
+      expect(scorer).toBeInstanceOf(ComplexityScorer);
+    });
+
+    test('should have calculateComplexity method', () => {
+      expect(typeof scorer.calculateComplexity).toBe('function');
+    });
+
+    test('should return numeric score', () => {
+      const score = scorer.calculateComplexity({ prompt: 'simple task', context: {} });
+      expect(typeof score).toBe('number');
+    });
+
+    test('should return score between 0 and 100', () => {
+      const score = scorer.calculateComplexity({ prompt: 'test', context: {} });
+      expect(score).toBeGreaterThanOrEqual(0);
+      expect(score).toBeLessThanOrEqual(100);
+    });
+  });
+
+  describe('AC2: Factor 1 - Token count (max 30 points)', () => {
+    test('should score 0 for very short prompts (< 10 tokens)', () => {
+      const task = { prompt: 'test', context: {} };
+      const score = scorer.calculateComplexity(task);
+      const tokenScore = scorer._calculateTokenScore(task.prompt);
+      
+      expect(tokenScore).toBe(0);
+    });
+
+    test('should score ~6 for medium-short prompts (~30 tokens)', () => {
+      const prompt = Array(30).fill('word').join(' ');
+      const tokenScore = scorer._calculateTokenScore(prompt);
+      
+      expect(tokenScore).toBeGreaterThanOrEqual(3);
+      expect(tokenScore).toBeLessThanOrEqual(7);
+    });
+
+    test('should score 30 for very long prompts (> 200 tokens)', () => {
+      const longPrompt = Array(250).fill('word').join(' ');
+      const tokenScore = scorer._calculateTokenScore(longPrompt);
+      
+      expect(tokenScore).toBe(30);
+    });
+
+    test('should scale linearly between thresholds', () => {
+      const prompt20 = Array(20).fill('word').join(' ');
+      const prompt100 = Array(100).fill('word').join(' ');
+      
+      const score20 = scorer._calculateTokenScore(prompt20);
+      const score100 = scorer._calculateTokenScore(prompt100);
+      
+      expect(score100).toBeGreaterThan(score20);
+    });
+  });
+
+  describe('AC3: Factor 2 - Task type (max 80 points)', () => {
+    test('should score low (10-20) for simple exploration tasks', () => {
+      const task = { prompt: 'explore the codebase and list files', context: {}, type: 'exploration' };
+      const typeScore = scorer._calculateTaskTypeScore(task);
+      
+      expect(typeScore).toBeGreaterThanOrEqual(10);
+      expect(typeScore).toBeLessThanOrEqual(20);
+    });
+
+    test('should score medium (40-50) for implementation tasks', () => {
+      const task = { prompt: 'implement a new feature', context: {}, type: 'implementation' };
+      const typeScore = scorer._calculateTaskTypeScore(task);
+      
+      expect(typeScore).toBeGreaterThanOrEqual(40);
+      expect(typeScore).toBeLessThanOrEqual(50);
+    });
+
+    test('should score high (70-80) for analysis/design tasks', () => {
+      const task = { prompt: 'analyze architecture and propose design', context: {}, type: 'analysis' };
+      const typeScore = scorer._calculateTaskTypeScore(task);
+      
+      expect(typeScore).toBeGreaterThanOrEqual(70);
+      expect(typeScore).toBeLessThanOrEqual(80);
+    });
+
+    test('should infer type from keywords if not specified', () => {
+      const exploreTask = { prompt: 'search for authentication logic', context: {} };
+      const implementTask = { prompt: 'create a new API endpoint', context: {} };
+      
+      const exploreScore = scorer._calculateTaskTypeScore(exploreTask);
+      const implementScore = scorer._calculateTaskTypeScore(implementTask);
+      
+      expect(exploreScore).toBeLessThan(implementScore);
+    });
+
+    test('should recognize analysis keywords', () => {
+      const keywords = ['analyze', 'design', 'architect', 'evaluate', 'review'];
+      
+      keywords.forEach(keyword => {
+        const task = { prompt: `${keyword} the system`, context: {} };
+        const score = scorer._calculateTaskTypeScore(task);
+        expect(score).toBeGreaterThan(60);
+      });
+    });
+  });
+
+  describe('AC4: Factor 3 - Context size (max 20 points)', () => {
+    test('should score 0 for empty context', () => {
+      const task = { prompt: 'test', context: {} };
+      const contextScore = scorer._calculateContextScore(task.context);
+      
+      expect(contextScore).toBe(0);
+    });
+
+    test('should score 5-10 for small context (few properties)', () => {
+      const task = { 
+        prompt: 'test', 
+        context: { 
+          projectRoot: '/home/user/project',
+          userName: 'test'
+        } 
+      };
+      const contextScore = scorer._calculateContextScore(task.context);
+      
+      expect(contextScore).toBeGreaterThanOrEqual(5);
+      expect(contextScore).toBeLessThanOrEqual(10);
+    });
+
+    test('should score 15-20 for large context (many properties)', () => {
+      const task = { 
+        prompt: 'test', 
+        context: { 
+          projectRoot: '/home/user/project',
+          userName: 'test',
+          questionHistory: Array(10).fill({ question: 'q', answer: 'a' }),
+          userResponses: Array(5).fill({ response: 'r' }),
+          analysisResults: { data: 'complex' },
+          gitBranch: 'main',
+          workingDir: '/home/user/project',
+          previousContext: { nested: { data: 'here' } }
+        } 
+      };
+      const contextScore = scorer._calculateContextScore(task.context);
+      
+      expect(contextScore).toBeGreaterThanOrEqual(15);
+      expect(contextScore).toBeLessThanOrEqual(20);
+    });
+
+    test('should consider nested object complexity', () => {
+      const flatContext = { a: 1, b: 2, c: 3 };
+      const nestedContext = { 
+        a: { b: { c: { d: 'deep' } } },
+        x: { y: { z: 'nested' } }
+      };
+      
+      const flatScore = scorer._calculateContextScore(flatContext);
+      const nestedScore = scorer._calculateContextScore(nestedContext);
+      
+      expect(nestedScore).toBeGreaterThanOrEqual(flatScore);
+    });
+  });
+
+  describe('AC5: Factor 4 - Keywords (max 25 points)', () => {
+    test('should score 0 for no special keywords', () => {
+      const task = { prompt: 'do something normal here', context: {} };
+      const keywordScore = scorer._calculateKeywordScore(task.prompt);
+      
+      expect(keywordScore).toBe(0);
+    });
+
+    test('should score 5-10 for simple keywords', () => {
+      const simpleKeywords = ['list', 'show', 'find', 'get', 'read'];
+      
+      simpleKeywords.forEach(keyword => {
+        const task = { prompt: `${keyword} the files`, context: {} };
+        const score = scorer._calculateKeywordScore(task.prompt);
+        expect(score).toBeGreaterThanOrEqual(5);
+        expect(score).toBeLessThanOrEqual(10);
+      });
+    });
+
+    test('should score 15-20 for complex keywords', () => {
+      const complexKeywords = ['refactor', 'optimize', 'implement', 'integrate'];
+      
+      complexKeywords.forEach(keyword => {
+        const task = { prompt: `${keyword} the module`, context: {} };
+        const score = scorer._calculateKeywordScore(task.prompt);
+        expect(score).toBeGreaterThanOrEqual(15);
+        expect(score).toBeLessThanOrEqual(20);
+      });
+    });
+
+    test('should score 25 for critical keywords', () => {
+      const criticalKeywords = ['security', 'performance', 'architecture', 'scalability'];
+      
+      criticalKeywords.forEach(keyword => {
+        const task = { prompt: `review ${keyword} implications`, context: {} };
+        const score = scorer._calculateKeywordScore(task.prompt);
+        expect(score).toBe(25);
+      });
+    });
+
+    test('should accumulate scores for multiple keywords', () => {
+      const task = { prompt: 'refactor and optimize for security', context: {} };
+      const score = scorer._calculateKeywordScore(task.prompt);
+      
+      expect(score).toBeGreaterThan(20);
+      expect(score).toBeLessThanOrEqual(25);
+    });
+  });
+
+  describe('AC6: Combined scoring logic', () => {
+    test('should combine all factors correctly', () => {
+      const task = {
+        prompt: 'simple exploration',
+        context: {},
+        type: 'exploration'
+      };
+      
+      const score = scorer.calculateComplexity(task);
+      
+      expect(score).toBeGreaterThan(0);
+      expect(score).toBeLessThan(50);
+    });
+
+    test('should cap total score at 100', () => {
+      const task = {
+        prompt: Array(300).fill('critical security architecture performance scalability refactor optimize').join(' '),
+        context: {
+          massive: Array(100).fill({ nested: { data: 'complex' } }),
+          projectRoot: '/path',
+          userName: 'user',
+          questionHistory: Array(50).fill({ q: 'question' }),
+          userResponses: Array(50).fill({ r: 'response' })
+        },
+        type: 'analysis'
+      };
+      
+      const score = scorer.calculateComplexity(task);
+      
+      expect(score).toBeLessThanOrEqual(100);
+    });
+
+    test('should return consistent scores for same input', () => {
+      const task = { prompt: 'test consistent scoring', context: { a: 1 } };
+      
+      const score1 = scorer.calculateComplexity(task);
+      const score2 = scorer.calculateComplexity(task);
+      
+      expect(score1).toBe(score2);
+    });
+  });
+
+  describe('AC7: Real-world scenarios', () => {
+    test('scenario: simple file exploration (should be < 30)', () => {
+      const task = {
+        prompt: 'list all JavaScript files in src directory',
+        context: { projectRoot: '/home/user/project' }
+      };
+      
+      const score = scorer.calculateComplexity(task);
+      
+      expect(score).toBeLessThan(30);
+    });
+
+    test('scenario: medium code implementation (should be 45-70)', () => {
+      const task = {
+        prompt: 'implement a new authentication middleware that validates JWT tokens and checks user permissions',
+        context: {
+          projectRoot: '/home/user/project',
+          userName: 'yan',
+          currentFile: 'src/middleware/auth.js'
+        }
+      };
+      
+      const score = scorer.calculateComplexity(task);
+      
+      // This is implementation task (45) + moderate context (7) + implement keyword (17) = ~69
+      expect(score).toBeGreaterThanOrEqual(45);
+      expect(score).toBeLessThan(75);
+    });
+
+    test('scenario: complex architecture analysis (should be >= 60)', () => {
+      const task = {
+        prompt: 'analyze the current microservices architecture, evaluate security vulnerabilities, and propose a scalable refactoring strategy with performance optimizations',
+        context: {
+          projectRoot: '/home/user/project',
+          userName: 'yan',
+          questionHistory: Array(15).fill({ question: 'q', answer: 'a' }),
+          userResponses: Array(10).fill({ response: 'detailed' }),
+          analysisResults: { complexity: 'high', issues: ['security', 'performance'] }
+        }
+      };
+      
+      const score = scorer.calculateComplexity(task);
+      
+      expect(score).toBeGreaterThanOrEqual(60);
+    });
+
+    test('scenario: BYAN interview question (should be 70-95)', () => {
+      const task = {
+        prompt: 'Based on user response about project type, analyze whether they need a general-purpose agent or a specialist agent',
+        context: {
+          questionHistory: [
+            { question: 'What type of project?', timestamp: Date.now() },
+            { question: 'What is the main goal?', timestamp: Date.now() }
+          ],
+          userResponses: [
+            { questionId: 'q1', response: 'Web application', timestamp: Date.now() },
+            { questionId: 'q2', response: 'E-commerce platform', timestamp: Date.now() }
+          ]
+        }
+      };
+      
+      const score = scorer.calculateComplexity(task);
+      
+      // This is analysis (75) + large context (15-20) = 90-95
+      expect(score).toBeGreaterThanOrEqual(70);
+      expect(score).toBeLessThanOrEqual(100);
+    });
+  });
+
+  describe('Edge cases', () => {
+    test('should handle null prompt', () => {
+      const task = { prompt: null, context: {} };
+      
+      expect(() => scorer.calculateComplexity(task)).toThrow('prompt is required');
+    });
+
+    test('should handle undefined context', () => {
+      const task = { prompt: 'test' };
+      const score = scorer.calculateComplexity(task);
+      
+      expect(score).toBeGreaterThanOrEqual(0);
+      expect(score).toBeLessThanOrEqual(100);
+    });
+
+    test('should handle empty string prompt', () => {
+      const task = { prompt: '', context: {} };
+      
+      expect(() => scorer.calculateComplexity(task)).toThrow('prompt is required');
+    });
+
+    test('should handle circular references in context', () => {
+      const circular = { a: 1 };
+      circular.self = circular;
+      
+      const task = { prompt: 'test', context: circular };
+      
+      expect(() => scorer.calculateComplexity(task)).not.toThrow();
+    });
+  });
+});