calc-mcp-server 0.1.0

package/test/integration/programmer-calculate.test.ts

@@ -0,0 +1,363 @@
+import { describe, it, expect } from 'vitest';
+import { programmerCalculate } from '../../src/mcp/tools/programmer.js';
+
+describe('programmerCalculate', () => {
+  describe('Basic arithmetic operations', () => {
+    it('should add two decimal numbers', () => {
+      const result = programmerCalculate({ expression: '10 + 20' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('30');
+      }
+    });
+
+    it('should subtract two decimal numbers', () => {
+      const result = programmerCalculate({ expression: '50 - 15' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('35');
+      }
+    });
+
+    it('should multiply two numbers', () => {
+      const result = programmerCalculate({ expression: '6 * 7' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('42');
+      }
+    });
+
+    it('should divide two numbers', () => {
+      const result = programmerCalculate({ expression: '100 / 4' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('25');
+      }
+    });
+
+    it('should calculate modulo', () => {
+      const result = programmerCalculate({ expression: '17 % 5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('2');
+      }
+    });
+  });
+
+  describe('Hexadecimal operations', () => {
+    it('should add two hex numbers', () => {
+      const result = programmerCalculate({ expression: '0xA + 0x5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('15');
+      }
+    });
+
+    it('should multiply hex numbers', () => {
+      const result = programmerCalculate({ expression: '0x10 * 0x10' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('256');
+      }
+    });
+
+    it('should handle mixed hex and decimal', () => {
+      const result = programmerCalculate({ expression: '0xFF + 10' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('265');
+      }
+    });
+
+    it('should subtract hex numbers', () => {
+      const result = programmerCalculate({ expression: '0x20 - 0x10' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('16');
+      }
+    });
+  });
+
+  describe('Binary operations', () => {
+    it('should add two binary numbers', () => {
+      const result = programmerCalculate({ expression: '0b1010 + 0b0101' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('15');
+      }
+    });
+
+    it('should multiply binary numbers', () => {
+      const result = programmerCalculate({ expression: '0b1100 * 0b10' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('24');
+      }
+    });
+
+    it('should handle mixed binary and decimal', () => {
+      const result = programmerCalculate({ expression: '0b1111 + 5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('20');
+      }
+    });
+  });
+
+  describe('Octal operations', () => {
+    it('should add two octal numbers', () => {
+      const result = programmerCalculate({ expression: '0o10 + 0o7' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('15');
+      }
+    });
+
+    it('should multiply octal numbers', () => {
+      const result = programmerCalculate({ expression: '0o10 * 0o10' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('64');
+      }
+    });
+  });
+
+  describe('Bitwise operations', () => {
+    it('should perform bitwise AND', () => {
+      const result = programmerCalculate({ expression: '0b1100 & 0b1010' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('8');
+      }
+    });
+
+    it('should perform bitwise OR', () => {
+      const result = programmerCalculate({ expression: '0b1100 | 0b1010' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('14');
+      }
+    });
+
+    it('should perform bitwise XOR', () => {
+      const result = programmerCalculate({ expression: '0b1100 ^ 0b1010' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('6');
+      }
+    });
+
+    it('should perform bitwise NOT', () => {
+      const result = programmerCalculate({ expression: '~0b1010' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('-11');
+      }
+    });
+
+    it('should perform left shift', () => {
+      const result = programmerCalculate({ expression: '0b1010 << 2' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('40');
+      }
+    });
+
+    it('should perform right shift', () => {
+      const result = programmerCalculate({ expression: '0b101000 >> 2' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('10');
+      }
+    });
+
+    it('should perform unsigned right shift', () => {
+      const result = programmerCalculate({ expression: '-10 >>> 1' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        // -10 in binary is ...11110110, unsigned right shift by 1 gives a large positive number
+        expect(BigInt(result.result)).toBeGreaterThan(0n);
+      }
+    });
+  });
+
+  describe('Complex expressions', () => {
+    it('should handle mixed operations', () => {
+      const result = programmerCalculate({ expression: '(0x10 + 0b10) * 2' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('36');
+      }
+    });
+
+    it('should handle bitwise with arithmetic', () => {
+      const result = programmerCalculate({ expression: '(0xFF & 0xF0) + 10' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('250');
+      }
+    });
+
+    it('should respect operator precedence', () => {
+      const result = programmerCalculate({ expression: '0b1010 | 0b1100 & 0b1000' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        // & has higher precedence than |
+        // 0b1010 | (0b1100 & 0b1000) = 0b1010 | 0b1000 = 0b1010 = 10
+        expect(result.result).toBe('10');
+      }
+    });
+  });
+
+  describe('Character literals', () => {
+    it('should handle single character literal', () => {
+      const result = programmerCalculate({ expression: "'A'" });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('65');
+      }
+    });
+
+    it('should add character literals', () => {
+      const result = programmerCalculate({ expression: "'A' + 'B'" });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('131');
+      }
+    });
+
+    it('should handle character arithmetic', () => {
+      const result = programmerCalculate({ expression: "'a' - 'A'" });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('32');
+      }
+    });
+  });
+
+  describe('Negative numbers', () => {
+    it('should handle negative decimal numbers', () => {
+      const result = programmerCalculate({ expression: '-10 + 5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('-5');
+      }
+    });
+
+    it('should handle bitwise NOT of positive', () => {
+      const result = programmerCalculate({ expression: '~5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('-6');
+      }
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should return error for empty expression', () => {
+      const result = programmerCalculate({ expression: '' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+      }
+    });
+
+    it('should return error for division by zero', () => {
+      const result = programmerCalculate({ expression: '10 / 0' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('DivisionByZero');
+      }
+    });
+
+    it('should return error for floating point numbers', () => {
+      const result = programmerCalculate({ expression: '3.14 * 2' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('Floating point');
+      }
+    });
+
+    it('should return error for unmatched parenthesis', () => {
+      const result = programmerCalculate({ expression: '(0x10 + 0x20' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('SyntaxError');
+      }
+    });
+  });
+
+  describe('Large numbers', () => {
+    it('should handle very large hex numbers', () => {
+      const result = programmerCalculate({ expression: '0xFFFFFFFF + 1' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('4294967296');
+      }
+    });
+
+    it('should handle bitwise operations on large numbers', () => {
+      const result = programmerCalculate({ expression: '0xFFFFFFFF & 0xFFFF' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('65535');
+      }
+    });
+  });
+
+  describe('Precedence and grouping', () => {
+    it('should handle (5 + 3) * (10 - 2)', () => {
+      const result = programmerCalculate({ expression: '(5 + 3) * (10 - 2)' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('64');
+      }
+    });
+
+    it('should handle nested parentheses', () => {
+      const result = programmerCalculate({ expression: '((0x10 + 0x10) * 2) - 10' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('54');
+      }
+    });
+  });
+});

package/test/unit/decimal-engine.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import { DecimalEngine } from '../../src/engines/decimal.js';
+import { Lexer } from '../../src/parser/lexer.js';
+import { Parser } from '../../src/parser/parser.js';
+
+describe('DecimalEngine', () => {
+  const lexer = new Lexer();
+  const parser = new Parser();
+  const engine = new DecimalEngine();
+
+  describe('Basic operations', () => {
+    it('should add two numbers', () => {
+      const tokens = lexer.tokenize('2 + 3');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('5');
+    });
+
+    it('should subtract two numbers', () => {
+      const tokens = lexer.tokenize('5 - 3');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('2');
+    });
+
+    it('should multiply two numbers', () => {
+      const tokens = lexer.tokenize('4 * 3');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('12');
+    });
+
+    it('should divide two numbers', () => {
+      const tokens = lexer.tokenize('10 / 2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('5');
+    });
+  });
+
+  describe('Decimal precision', () => {
+    it('should handle 0.1 + 0.2 correctly', () => {
+      const tokens = lexer.tokenize('0.1 + 0.2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('0.3');
+    });
+
+    it('should handle floating point division', () => {
+      const tokens = lexer.tokenize('1 / 3');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(parseFloat(result.toString())).toBeCloseTo(0.333, 2);
+    });
+  });
+
+  describe('Operator precedence', () => {
+    it('should respect precedence', () => {
+      const tokens = lexer.tokenize('2 + 3 * 4');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('14');
+    });
+
+    it('should respect parentheses', () => {
+      const tokens = lexer.tokenize('(2 + 3) * 4');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('20');
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should throw on division by zero', () => {
+      const tokens = lexer.tokenize('1 / 0');
+      const ast = parser.parse(tokens);
+
+      expect(() => engine.evaluate(ast)).toThrow('DivisionByZero');
+    });
+  });
+
+  describe('Complex expressions', () => {
+    it('should handle multiple operations', () => {
+      const tokens = lexer.tokenize('2.5 * 3 + (10 - 4) / 2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('10.5');
+    });
+
+    it('should handle modulo', () => {
+      const tokens = lexer.tokenize('10 % 3');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('1');
+    });
+  });
+
+  describe('Negative number operations', () => {
+    it('should handle -5 + 3', () => {
+      const tokens = lexer.tokenize('-5 + 3');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('-2');
+    });
+
+    it('should handle -10 * -2', () => {
+      const tokens = lexer.tokenize('-10 * -2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('20');
+    });
+  });
+
+  describe('Modulo edge cases', () => {
+    it('should throw on modulo by zero', () => {
+      const tokens = lexer.tokenize('5 % 0');
+      const ast = parser.parse(tokens);
+
+      expect(() => engine.evaluate(ast)).toThrow('DivisionByZero');
+    });
+  });
+});

package/test/unit/error-handler.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import { ErrorHandler, ErrorType } from '../../src/errors/handler.js';
+
+describe('ErrorHandler', () => {
+  describe('syntaxError', () => {
+    it('should create syntax error with position', () => {
+      const handler = new ErrorHandler();
+      const error = handler.syntaxError('Unexpected token', 5, 8);
+
+      expect(error.success).toBe(false);
+      expect(error.error.type).toBe('SyntaxError');
+      expect(error.error.message).toBe('Unexpected token');
+      expect(error.error.position).toEqual({ start: 5, end: 8 });
+    });
+
+    it('should include suggestion for syntax errors', () => {
+      const handler = new ErrorHandler();
+      const error = handler.syntaxError('Unexpected token', 5, 8);
+
+      expect(error.error.suggestion).toBeDefined();
+      expect(typeof error.error.suggestion).toBe('string');
+      expect(error.error.suggestion).toContain('syntax');
+    });
+  });
+
+  describe('runtimeError', () => {
+    it('should create runtime error', () => {
+      const handler = new ErrorHandler();
+      const error = handler.runtimeError('DivisionByZero', 'Cannot divide by zero');
+
+      expect(error.success).toBe(false);
+      expect(error.error.type).toBe('DivisionByZero');
+      expect(error.error.message).toBe('Cannot divide by zero');
+    });
+
+    it('should include suggestion for runtime errors', () => {
+      const handler = new ErrorHandler();
+      const error = handler.runtimeError('DivisionByZero', 'Cannot divide by zero');
+
+      expect(error.error.suggestion).toBeDefined();
+      expect(typeof error.error.suggestion).toBe('string');
+      expect(error.error.suggestion).toContain('denominators');
+    });
+  });
+
+  describe('createError', () => {
+    it('should create error with position', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('InvalidOperator', 'Unsupported operator', { start: 10, end: 12 });
+
+      expect(error.success).toBe(false);
+      expect(error.error.type).toBe('InvalidOperator');
+      expect(error.error.message).toBe('Unsupported operator');
+      expect(error.error.position).toEqual({ start: 10, end: 12 });
+    });
+
+    it('should create error without position', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('EmptyInput', 'No expression provided');
+
+      expect(error.success).toBe(false);
+      expect(error.error.type).toBe('EmptyInput');
+      expect(error.error.message).toBe('No expression provided');
+      expect(error.error.position).toBeUndefined();
+    });
+
+    it('should include suggestion for error type', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('OverflowError', 'Number too large');
+
+      expect(error.error.suggestion).toBeDefined();
+      expect(error.error.suggestion).toContain('too large');
+    });
+  });
+
+  describe('success', () => {
+    it('should create success response with result only', () => {
+      const handler = new ErrorHandler();
+      const response = handler.success('42');
+
+      expect(response.success).toBe(true);
+      expect(response.result).toBe('42');
+      expect(response.details).toBeUndefined();
+    });
+
+    it('should create success response with details', () => {
+      const handler = new ErrorHandler();
+      const response = handler.success('42', {
+        expression: '2 * 21',
+        steps: ['2 * 21 = 42'],
+      });
+
+      expect(response.success).toBe(true);
+      expect(response.result).toBe('42');
+      expect(response.details).toEqual({
+        expression: '2 * 21',
+        steps: ['2 * 21 = 42'],
+      });
+    });
+  });
+
+  describe('Error suggestions completeness', () => {
+    const errorTypes: ErrorType[] = [
+      'SyntaxError',
+      'DivisionByZero',
+      'InvalidNumber',
+      'OverflowError',
+      'InvalidBase',
+      'UnmatchedParen',
+      'InvalidOperator',
+      'EmptyInput',
+    ];
+
+    it('should have suggestions for all 8 error types', () => {
+      const handler = new ErrorHandler();
+
+      errorTypes.forEach((errorType) => {
+        const error = handler.createError(errorType, 'Test error message');
+        expect(error.error.suggestion).toBeDefined();
+        expect(typeof error.error.suggestion).toBe('string');
+        expect(error.error.suggestion.length).toBeGreaterThan(0);
+      });
+    });
+
+    it('should provide specific suggestion for SyntaxError', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('SyntaxError', 'Test');
+      expect(error.error.suggestion).toContain('syntax');
+    });
+
+    it('should provide specific suggestion for DivisionByZero', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('DivisionByZero', 'Test');
+      expect(error.error.suggestion).toContain('denominators');
+    });
+
+    it('should provide specific suggestion for InvalidNumber', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('InvalidNumber', 'Test');
+      expect(error.error.suggestion).toContain('format');
+    });
+
+    it('should provide specific suggestion for OverflowError', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('OverflowError', 'Test');
+      expect(error.error.suggestion).toContain('too large');
+    });
+
+    it('should provide specific suggestion for InvalidBase', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('InvalidBase', 'Test');
+      expect(error.error.suggestion).toContain('2, 8, 10, and 16');
+    });
+
+    it('should provide specific suggestion for UnmatchedParen', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('UnmatchedParen', 'Test');
+      expect(error.error.suggestion).toContain('parenthesis');
+    });
+
+    it('should provide specific suggestion for InvalidOperator', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('InvalidOperator', 'Test');
+      expect(error.error.suggestion).toContain('operator');
+    });
+
+    it('should provide specific suggestion for EmptyInput', () => {
+      const handler = new ErrorHandler();
+      const error = handler.createError('EmptyInput', 'Test');
+      expect(error.error.suggestion).toContain('empty');
+    });
+  });
+});