calc-mcp-server 0.1.0

package/test/unit/lexer.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import { Lexer } from '../../src/parser/lexer.js';
+import { TokenType } from '../../src/parser/ast.js';
+
+describe('Lexer', () => {
+  describe('Number literals', () => {
+    it('should tokenize decimal integers', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('42');
+
+      expect(tokens).toHaveLength(2); // NUMBER + EOF
+      expect(tokens[0].type).toBe('NUMBER');
+      expect(tokens[0].value).toBe('42');
+    });
+
+    it('should tokenize decimal floats', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('3.14');
+
+      expect(tokens[0].type).toBe('NUMBER');
+      expect(tokens[0].value).toBe('3.14');
+    });
+
+    it('should tokenize hex literals', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('0xFF');
+
+      expect(tokens[0].type).toBe('HEX');
+      expect(tokens[0].value).toBe('0xFF');
+    });
+
+    it('should tokenize binary literals', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('0b1011');
+
+      expect(tokens[0].type).toBe('BINARY');
+      expect(tokens[0].value).toBe('0b1011');
+    });
+
+    it('should tokenize octal literals', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('0o77');
+
+      expect(tokens[0].type).toBe('OCTAL');
+      expect(tokens[0].value).toBe('0o77');
+    });
+  });
+
+  describe('Operators', () => {
+    it('should tokenize single character operators', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('1+2-3*4/5%6&7|8^9~0');
+
+      expect(tokens[0].type).toBe('NUMBER');
+      expect(tokens[1].type).toBe('OPERATOR');
+      expect(tokens[1].value).toBe('+');
+      expect(tokens[3].type).toBe('OPERATOR');
+      expect(tokens[3].value).toBe('-');
+      expect(tokens[5].type).toBe('OPERATOR');
+      expect(tokens[5].value).toBe('*');
+    });
+
+    it('should tokenize shift operators', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('1 << 2 >> 3');
+
+      expect(tokens[1].type).toBe('OPERATOR');
+      expect(tokens[1].value).toBe('<<');
+      expect(tokens[3].type).toBe('OPERATOR');
+      expect(tokens[3].value).toBe('>>');
+    });
+
+    it('should tokenize unsigned right shift operator', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('1 >>> 2');
+
+      expect(tokens[1].type).toBe('OPERATOR');
+      expect(tokens[1].value).toBe('>>>');
+    });
+  });
+
+  describe('Parentheses', () => {
+    it('should tokenize parentheses', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('()');
+
+      expect(tokens[0].type).toBe('LPAREN');
+      expect(tokens[0].value).toBe('(');
+      expect(tokens[1].type).toBe('RPAREN');
+      expect(tokens[1].value).toBe(')');
+    });
+
+    it('should tokenize nested expressions', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('((1+2)*3)');
+
+      expect(tokens[0].type).toBe('LPAREN');
+      expect(tokens[1].type).toBe('LPAREN');
+      expect(tokens[2].type).toBe('NUMBER');
+      expect(tokens[3].type).toBe('OPERATOR');
+      expect(tokens[4].type).toBe('NUMBER');
+      expect(tokens[5].type).toBe('RPAREN');
+      expect(tokens[6].type).toBe('OPERATOR');
+      expect(tokens[7].type).toBe('NUMBER');
+      expect(tokens[8].type).toBe('RPAREN');
+    });
+  });
+
+  describe('Character literals', () => {
+    it('should tokenize simple char literals', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize("'A'");
+
+      expect(tokens[0].type).toBe('CHAR_LITERAL');
+      expect(tokens[0].value).toBe("'A'");
+    });
+
+    it('should tokenize escaped char literals', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize("'\\n'");
+
+      expect(tokens[0].type).toBe('CHAR_LITERAL');
+      expect(tokens[0].value).toBe("'\\n'");
+    });
+  });
+
+  describe('Position tracking', () => {
+    it('should track token positions correctly', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('42 + 10');
+
+      expect(tokens[0].position).toEqual({ start: 0, end: 2 });
+      expect(tokens[1].position).toEqual({ start: 3, end: 4 });
+      expect(tokens[2].position).toEqual({ start: 5, end: 7 });
+    });
+
+    it('should track EOF position', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('42');
+
+      const eofToken = tokens[tokens.length - 1];
+      expect(eofToken.type).toBe('EOF');
+      expect(eofToken.position).toEqual({ start: 2, end: 2 });
+    });
+  });
+
+  describe('Whitespace handling', () => {
+    it('should ignore whitespace', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('1   +\t\n2');
+
+      expect(tokens).toHaveLength(4); // NUMBER, OPERATOR, NUMBER, EOF
+      expect(tokens[0].type).toBe('NUMBER');
+      expect(tokens[1].type).toBe('OPERATOR');
+      expect(tokens[2].type).toBe('NUMBER');
+    });
+  });
+
+  describe('Complex expressions', () => {
+    it('should tokenize complex arithmetic expressions', () => {
+      const lexer = new Lexer();
+      const tokens = lexer.tokenize('(1 + 2) * 3 >> 0b10');
+
+      expect(tokens[0].type).toBe('LPAREN');
+      expect(tokens[1].type).toBe('NUMBER');
+      expect(tokens[2].type).toBe('OPERATOR');
+      expect(tokens[3].type).toBe('NUMBER');
+      expect(tokens[4].type).toBe('RPAREN');
+      expect(tokens[5].type).toBe('OPERATOR');
+      expect(tokens[5].value).toBe('*');
+      expect(tokens[7].type).toBe('OPERATOR');
+      expect(tokens[7].value).toBe('>>');
+      expect(tokens[8].type).toBe('BINARY');
+    });
+  });
+});

package/test/unit/parser.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect } from 'vitest';
+import { Parser } from '../../src/parser/parser.js';
+import { Lexer } from '../../src/parser/lexer.js';
+
+describe('Parser', () => {
+  describe('Operator precedence', () => {
+    it('should respect multiplication over addition', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('2 + 3 * 4');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect(ast.operator).toBe('+');
+      expect((ast as any).left.type).toBe('Literal');
+      expect((ast as any).left.value).toBe('2');
+      expect((ast as any).right.type).toBe('BinaryOp');
+      expect((ast as any).right.operator).toBe('*');
+    });
+
+    it('should respect parentheses', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('(2 + 3) * 4');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect(ast.operator).toBe('*');
+      expect((ast as any).left.type).toBe('Group');
+      expect((ast as any).right.type).toBe('Literal');
+    });
+  });
+
+  describe('Unary operators', () => {
+    it('should parse bitwise NOT', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('~0xFF');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('UnaryOp');
+      expect((ast as any).operator).toBe('~');
+      expect((ast as any).operand.type).toBe('Literal');
+    });
+
+    it('should parse negation', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('-42');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('UnaryOp');
+      expect((ast as any).operator).toBe('-');
+    });
+  });
+
+  describe('Bitwise operators', () => {
+    it('should parse AND', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('0xFF & 0x0F');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect((ast as any).operator).toBe('&');
+    });
+
+    it('should parse OR', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('0xFF | 0x0F');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect((ast as any).operator).toBe('|');
+    });
+
+    it('should parse XOR', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('0xFF ^ 0x0F');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect((ast as any).operator).toBe('^');
+    });
+  });
+
+  describe('Shift operators', () => {
+    it('should parse left shift', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('1 << 4');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect((ast as any).operator).toBe('<<');
+    });
+
+    it('should parse right shift', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('16 >> 2');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect((ast as any).operator).toBe('>>');
+    });
+  });
+
+  describe('Error paths', () => {
+    it('should throw error for empty input', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('');
+
+      expect(() => parser.parse(tokens)).toThrow('Expression cannot be empty');
+    });
+
+    it('should throw error for unmatched opening parenthesis', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('(1 + 2');
+
+      expect(() => parser.parse(tokens)).toThrow();
+    });
+
+    it('should throw error for unmatched closing parenthesis', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('1 + 2)');
+
+      expect(() => parser.parse(tokens)).toThrow();
+    });
+
+    it('should throw error for unexpected character sequence', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      // '@' will be ignored by lexer, resulting in empty expression
+      const tokens = lexer.tokenize('@');
+
+      expect(() => parser.parse(tokens)).toThrow();
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should parse single literal', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('42');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('Literal');
+      expect((ast as any).value).toBe('42');
+    });
+
+    it('should parse single hex literal', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('0xFF');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('Literal');
+      expect((ast as any).value).toBe('0xFF');
+    });
+
+    it('should parse deeply nested parentheses', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('(((1 + 2) * 3) - 4)');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('Group');
+    });
+
+    it('should parse multiple unary operators', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('--42');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('UnaryOp');
+      expect((ast as any).operator).toBe('-');
+      expect((ast as any).operand.type).toBe('UnaryOp');
+    });
+
+    it('should parse mixed unary and binary operations', () => {
+      const lexer = new Lexer();
+      const parser = new Parser();
+      const tokens = lexer.tokenize('-2 + ~3');
+      const ast = parser.parse(tokens);
+
+      expect(ast.type).toBe('BinaryOp');
+      expect((ast as any).operator).toBe('+');
+    });
+  });
+});

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

@@ -0,0 +1,234 @@
+import { describe, it, expect } from 'vitest';
+import { ProgrammerEngine } from '../../src/engines/programmer.js';
+import { Lexer } from '../../src/parser/lexer.js';
+import { Parser } from '../../src/parser/parser.js';
+
+describe('ProgrammerEngine', () => {
+  const lexer = new Lexer();
+  const parser = new Parser();
+  const engine = new ProgrammerEngine();
+
+  describe('Bitwise AND', () => {
+    it('should perform bitwise AND', () => {
+      const tokens = lexer.tokenize('0xFF & 0x0F');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('15');
+    });
+  });
+
+  describe('Bitwise OR', () => {
+    it('should perform bitwise OR', () => {
+      const tokens = lexer.tokenize('0xF0 | 0x0F');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('255');
+    });
+  });
+
+  describe('Bitwise XOR', () => {
+    it('should perform bitwise XOR', () => {
+      const tokens = lexer.tokenize('0xFF ^ 0xFF');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('0');
+    });
+  });
+
+  describe('Bitwise NOT', () => {
+    it('should perform bitwise NOT', () => {
+      const tokens = lexer.tokenize('~0x00');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      // ~0 = -1 in two's complement
+      expect(result.toString()).toBe('-1');
+    });
+  });
+
+  describe('Left shift', () => {
+    it('should perform left shift', () => {
+      const tokens = lexer.tokenize('1 << 4');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('16');
+    });
+  });
+
+  describe('Right shift', () => {
+    it('should perform right shift', () => {
+      const tokens = lexer.tokenize('16 >> 2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('4');
+    });
+  });
+
+  describe('BigInt support', () => {
+    it('should handle very large numbers', () => {
+      const tokens = lexer.tokenize('0xFFFFFFFFFFFFFFFF + 1');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('18446744073709551616');
+    });
+  });
+
+  describe('Complex expressions', () => {
+    it('should handle multiple bitwise operations', () => {
+      const tokens = lexer.tokenize('0xFF & 0x0F | 0x10');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      // (0xFF & 0x0F) | 0x10 = 15 | 16 = 31
+      expect(result.toString()).toBe('31');
+    });
+
+    it('should handle shift with bitwise ops', () => {
+      const tokens = lexer.tokenize('(1 << 4) & 0xFF');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      // (16) & 255 = 16
+      expect(result.toString()).toBe('16');
+    });
+  });
+
+  describe('Binary literals', () => {
+    it('should parse binary literals', () => {
+      const tokens = lexer.tokenize('0b1010');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('10');
+    });
+
+    it('should perform operations on binary literals', () => {
+      const tokens = lexer.tokenize('0b1010 << 2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('40');
+    });
+  });
+
+  describe('Octal literals', () => {
+    it('should parse octal literals', () => {
+      const tokens = lexer.tokenize('0o77');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('63');
+    });
+  });
+
+  describe('Unsigned right shift', () => {
+    it('should perform unsigned right shift', () => {
+      const tokens = lexer.tokenize('-16 >>> 2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      // -16 >>> 2 = 1073741820 (in 32-bit arithmetic)
+      expect(result.toString()).toBe('1073741820');
+    });
+
+    it('should handle positive unsigned right shift', () => {
+      const tokens = lexer.tokenize('16 >>> 2');
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('4');
+    });
+  });
+
+  describe('Char literals', () => {
+    it('should parse char literals', () => {
+      const tokens = lexer.tokenize("'A'");
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('65'); // ASCII code for 'A'
+    });
+
+    it('should handle backslash in char literals', () => {
+      const tokens = lexer.tokenize("'\\\\'");
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('92'); // ASCII code for backslash
+    });
+
+    it('should perform operations on char literals', () => {
+      const tokens = lexer.tokenize("'A' + 'B'");
+      const ast = parser.parse(tokens);
+      const result = engine.evaluate(ast);
+
+      expect(result.toString()).toBe('131'); // 65 + 66
+    });
+  });
+
+  describe('Division by zero error', () => {
+    it('should throw division by zero error for division', () => {
+      const tokens = lexer.tokenize('10 / 0');
+      const ast = parser.parse(tokens);
+
+      expect(() => engine.evaluate(ast)).toThrow();
+      try {
+        engine.evaluate(ast);
+        expect.fail('Should have thrown an error');
+      } catch (e) {
+        expect(e).toHaveProperty('error');
+        expect(e.error.type).toBe('DivisionByZero');
+      }
+    });
+
+    it('should throw division by zero error for modulo', () => {
+      const tokens = lexer.tokenize('10 % 0');
+      const ast = parser.parse(tokens);
+
+      expect(() => engine.evaluate(ast)).toThrow();
+      try {
+        engine.evaluate(ast);
+        expect.fail('Should have thrown an error');
+      } catch (e) {
+        expect(e).toHaveProperty('error');
+        expect(e.error.type).toBe('DivisionByZero');
+      }
+    });
+  });
+
+  describe('Floating point error', () => {
+    it('should throw error for floating point numbers', () => {
+      const tokens = lexer.tokenize('3.14');
+      const ast = parser.parse(tokens);
+
+      expect(() => engine.evaluate(ast)).toThrow();
+      try {
+        engine.evaluate(ast);
+        expect.fail('Should have thrown an error');
+      } catch (e) {
+        expect(e).toHaveProperty('error');
+        expect(e.error.type).toBe('InvalidNumber');
+      }
+    });
+
+    it('should throw error for floating point in expression', () => {
+      const tokens = lexer.tokenize('10 + 3.14');
+      const ast = parser.parse(tokens);
+
+      expect(() => engine.evaluate(ast)).toThrow();
+      try {
+        engine.evaluate(ast);
+        expect.fail('Should have thrown an error');
+      } catch (e) {
+        expect(e).toHaveProperty('error');
+        expect(e.error.type).toBe('InvalidNumber');
+      }
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "lib": ["ES2022"],
+    "outDir": "./build",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "build", "test"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: ['**/node_modules/**', '**/dist/**', '**/test/**'],
+    },
+  },
+});