calc-mcp-server 0.1.0

package/src/mcp/server.ts

@@ -0,0 +1,287 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+import { basicCalculate } from './tools/basic.js';
+import { programmerCalculate } from './tools/programmer.js';
+import { convertBase } from './tools/conversion.js';
+import { asciiToNumber, numberToAscii } from './tools/ascii.js';
+
+// Define available tools
+const TOOLS: Tool[] = [
+  {
+    name: 'basic_calculate',
+    description: 'Evaluate basic arithmetic expressions with decimal precision. Supports operators: +, -, *, /, %, and parentheses. Examples: "2 + 3 * 4", "(10 - 4) / 2", "0.1 + 0.2"',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        expression: {
+          type: 'string',
+          description: 'The arithmetic expression to evaluate',
+        },
+      },
+      required: ['expression'],
+    },
+  },
+  {
+    name: 'programmer_calculate',
+    description: 'Evaluate programmer calculator expressions with integer arithmetic and bitwise operations. Supports decimal (10), hex (0x), binary (0b), octal (0o), and character literals (\'A\'). Operators: +, -, *, /, %, &, |, ^, ~, <<, >>, >>>. Examples: "0xA + 0x5", "0b1010 & 0b1100", "\'A\' + 1"',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        expression: {
+          type: 'string',
+          description: 'The programmer expression to evaluate',
+        },
+      },
+      required: ['expression'],
+    },
+  },
+  {
+    name: 'convert_base',
+    description: 'Convert numbers between different bases (2, 8, 10, 16). Supports binary, octal, decimal, and hexadecimal conversions. Examples: Convert "1010" from base 2 to base 10, convert "FF" from base 16 to base 2',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        value: {
+          type: 'string',
+          description: 'The numeric value to convert (without prefix)',
+        },
+        fromBase: {
+          type: 'number',
+          description: 'The source base (2, 8, 10, or 16)',
+          enum: [2, 8, 10, 16],
+        },
+        toBase: {
+          type: 'number',
+          description: 'The target base (2, 8, 10, or 16)',
+          enum: [2, 8, 10, 16],
+        },
+      },
+      required: ['value', 'fromBase', 'toBase'],
+    },
+  },
+  {
+    name: 'ascii_to_number',
+    description: 'Convert text to ASCII/Unicode codes. Returns comma-separated decimal codes for each character. Example: "ABC" becomes "65, 66, 67"',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string',
+          description: 'The text to convert to ASCII/Unicode codes',
+        },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'number_to_ascii',
+    description: 'Convert an ASCII/Unicode code to its character. Supports single code or array of codes. Examples: 65 becomes "A", [72, 101, 108, 108, 111] becomes "Hello"',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'number',
+          description: 'The ASCII/Unicode code to convert (0-65535)',
+        },
+        codes: {
+          type: 'array',
+          items: {
+            type: 'number',
+          },
+          description: 'Array of ASCII/Unicode codes to convert (each 0-65535)',
+        },
+      },
+    },
+  },
+];
+
+export function createMCPServer(): Server {
+  const server = new Server(
+    {
+      name: 'mcp-calculator',
+      version: '0.1.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // Handle list tools request
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: TOOLS,
+    };
+  });
+
+  // Handle tool execution
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+      switch (name) {
+        case 'basic_calculate': {
+          const { expression } = args as { expression: string };
+          const result = basicCalculate({ expression });
+
+          if (result.success) {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Result: ${result.result}${result.details?.expression ? `\nExpression: ${result.details.expression}` : ''}`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Error: ${result.error.type}: ${result.error.message}${result.error.suggestion ? `\n\nSuggestion: ${result.error.suggestion}` : ''}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        }
+
+        case 'programmer_calculate': {
+          const { expression } = args as { expression: string };
+          const result = programmerCalculate({ expression });
+
+          if (result.success) {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Result: ${result.result}${result.details?.expression ? `\nExpression: ${result.details.expression}` : ''}`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Error: ${result.error.type}: ${result.error.message}${result.error.suggestion ? `\n\nSuggestion: ${result.error.suggestion}` : ''}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        }
+
+        case 'convert_base': {
+          const { value, fromBase, toBase } = args as { value: string; fromBase: number; toBase: number };
+          const result = convertBase({ value, fromBase, toBase });
+
+          if (result.success) {
+            const steps = result.details?.steps || [];
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Result: ${result.result}\n\nConversion steps:\n${steps.map((s: string, i: number) => `${i + 1}. ${s}`).join('\n')}`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Error: ${result.error.type}: ${result.error.message}${result.error.suggestion ? `\n\nSuggestion: ${result.error.suggestion}` : ''}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        }
+
+        case 'ascii_to_number': {
+          const { text } = args as { text: string };
+          const result = asciiToNumber({ text });
+
+          if (result.success) {
+            const steps = result.details?.steps || [];
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `ASCII codes: ${result.result}\n\nDetails:\n${steps.map((s: string) => `  ${s}`).join('\n')}`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Error: ${result.error.type}: ${result.error.message}${result.error.suggestion ? `\n\nSuggestion: ${result.error.suggestion}` : ''}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        }
+
+        case 'number_to_ascii': {
+          const { code, codes } = args as { code?: number; codes?: number[] };
+          const result = numberToAscii({ code, codes });
+
+          if (result.success) {
+            const steps = result.details?.steps || [];
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Character: ${result.result}\n\nDetails:\n${steps.map((s: string) => `  ${s}`).join('\n')}`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `Error: ${result.error.type}: ${result.error.message}${result.error.suggestion ? `\n\nSuggestion: ${result.error.suggestion}` : ''}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        }
+
+        default:
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `Error: Unknown tool "${name}"`,
+              },
+            ],
+            isError: true,
+          };
+      }
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  });
+
+  return server;
+}

package/src/mcp/tools/ascii.ts

@@ -0,0 +1,116 @@
+import { ErrorHandler, CalculationResponse } from '../../errors/handler.js';
+
+export interface AsciiToNumberInput {
+  text: string;
+}
+
+export interface NumberToAsciiInput {
+  code?: number;
+  codes?: number[];
+}
+
+export function asciiToNumber(input: AsciiToNumberInput): CalculationResponse {
+  const errorHandler = new ErrorHandler();
+  const { text } = input;
+
+  if (!text || text.length === 0) {
+    return errorHandler.runtimeError('EmptyInput', 'Text cannot be empty');
+  }
+
+  try {
+    const codes: number[] = [];
+
+    for (let i = 0; i < text.length; i++) {
+      const code = text.charCodeAt(i);
+      codes.push(code);
+    }
+
+    return errorHandler.success(codes.join(', '), {
+      expression: `"${text}" → ASCII codes`,
+      steps: [
+        `Input text: "${text}"`,
+        `Character count: ${text.length}`,
+        `ASCII codes: ${codes.map((c, i) => `'${text[i]}' = ${c}`).join(', ')}`,
+      ],
+    });
+  } catch (error) {
+    return errorHandler.runtimeError('InvalidNumber', error instanceof Error ? error.message : 'Unknown error during ASCII conversion');
+  }
+}
+
+export function numberToAscii(input: NumberToAsciiInput): CalculationResponse {
+  const errorHandler = new ErrorHandler();
+  const { code, codes } = input;
+
+  // 参数验证：必须恰好提供一个参数
+  const hasCode = code !== undefined;
+  const hasCodes = codes !== undefined && codes.length > 0;
+
+  if (!hasCode && !hasCodes) {
+    return errorHandler.runtimeError('EmptyInput', 'Either code or codes parameter must be provided');
+  }
+
+  if (hasCode && hasCodes) {
+    return errorHandler.runtimeError('InvalidNumber', 'Only one of code or codes parameter should be provided, not both');
+  }
+
+  // 处理单个代码
+  if (hasCode) {
+    if (code < 0 || code > 0x10FFFF) {
+      return errorHandler.runtimeError('InvalidNumber', `Invalid Unicode code point: ${code}. Valid range is 0 to 1114111 (0x10FFFF).`);
+    }
+
+    try {
+      if (code > 0xFFFF) {
+        return errorHandler.runtimeError('InvalidNumber', `Code point ${code} requires surrogate pair handling. Currently only BMP characters (0-65535) are supported.`);
+      }
+
+      const text = String.fromCharCode(code);
+
+      return errorHandler.success(`"${text}"`, {
+        expression: `${code} → ASCII/Unicode character`,
+        steps: [
+          `Input code: ${code}`,
+          `Hex: 0x${code.toString(16).toUpperCase()}`,
+          `Binary: ${code.toString(2).padStart(16, '0')}`,
+          `Character: "${text}"`,
+        ],
+      });
+    } catch (error) {
+      return errorHandler.runtimeError('InvalidNumber', error instanceof Error ? error.message : 'Unknown error during ASCII conversion');
+    }
+  }
+
+  // 处理代码数组
+  if (hasCodes) {
+    try {
+      let text = '';
+      const steps: string[] = [];
+
+      for (const c of codes!) {
+        if (c < 0 || c > 0xFFFF) {
+          return errorHandler.runtimeError('InvalidNumber', `Invalid code point: ${c}. Valid range is 0 to 65535.`);
+        }
+
+        const char = String.fromCharCode(c);
+        text += char;
+        steps.push(`${c} → '${char}'`);
+      }
+
+      return errorHandler.success(`"${text}"`, {
+        expression: `[${codes.join(', ')}] → ASCII/Unicode text`,
+        steps: [
+          `Input codes: [${codes.join(', ')}]`,
+          `Character count: ${codes.length}`,
+          ...steps,
+          `Result: "${text}"`,
+        ],
+      });
+    } catch (error) {
+      return errorHandler.runtimeError('InvalidNumber', error instanceof Error ? error.message : 'Unknown error during ASCII conversion');
+    }
+  }
+
+  // 不应该到达这里
+  return errorHandler.runtimeError('InvalidNumber', 'Unexpected error in numberToAscii');
+}

package/src/mcp/tools/basic.ts

@@ -0,0 +1,44 @@
+import { Lexer } from '../../parser/lexer.js';
+import { Parser } from '../../parser/parser.js';
+import { DecimalEngine } from '../../engines/decimal.js';
+import { ErrorHandler, CalculationResponse } from '../../errors/handler.js';
+
+export interface BasicCalculateInput {
+  expression: string;
+}
+
+export function basicCalculate(input: BasicCalculateInput): CalculationResponse {
+  const errorHandler = new ErrorHandler();
+  const lexer = new Lexer();
+  const parser = new Parser();
+  const engine = new DecimalEngine();
+
+  const { expression } = input;
+
+  if (!expression || expression.trim().length === 0) {
+    return errorHandler.runtimeError('EmptyInput', 'Expression cannot be empty');
+  }
+
+  try {
+    const tokens = lexer.tokenize(expression);
+    const ast = parser.parse(tokens);
+    const result = engine.evaluate(ast);
+
+    return errorHandler.success(result.toString(), {
+      expression,
+    });
+  } catch (error) {
+    if (typeof error === 'object' && error !== null && 'success' in error) {
+      return error as CalculationResponse;
+    }
+
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    // Map error messages to error types
+    if (errorMessage === 'DivisionByZero') {
+      return errorHandler.runtimeError('DivisionByZero', 'Cannot divide by zero');
+    }
+
+    return errorHandler.runtimeError('InvalidNumber', errorMessage);
+  }
+}

package/src/mcp/tools/conversion.ts

@@ -0,0 +1,95 @@
+import { ErrorHandler, CalculationResponse } from '../../errors/handler.js';
+
+export interface ConvertBaseInput {
+  value: string;
+  fromBase: number;
+  toBase: number;
+}
+
+export function convertBase(input: ConvertBaseInput): CalculationResponse {
+  const errorHandler = new ErrorHandler();
+  const { value, fromBase, toBase } = input;
+
+  if (!value || value.trim().length === 0) {
+    return errorHandler.runtimeError('EmptyInput', 'Value cannot be empty');
+  }
+
+  // Validate bases
+  const validBases = [2, 8, 10, 16];
+  if (!validBases.includes(fromBase)) {
+    return errorHandler.runtimeError('InvalidBase', `Invalid source base: ${fromBase}. Supported bases are 2, 8, 10, and 16.`);
+  }
+
+  if (!validBases.includes(toBase)) {
+    return errorHandler.runtimeError('InvalidBase', `Invalid target base: ${toBase}. Supported bases are 2, 8, 10, and 16.`);
+  }
+
+  try {
+    // Parse the value from the source base to decimal
+    let decimalValue: bigint;
+
+    switch (fromBase) {
+      case 2:
+        if (!/^[01]+$/.test(value)) {
+          return errorHandler.runtimeError('InvalidNumber', `Invalid binary number: ${value}`);
+        }
+        decimalValue = BigInt('0b' + value);
+        break;
+      case 8:
+        if (!/^[0-7]+$/.test(value)) {
+          return errorHandler.runtimeError('InvalidNumber', `Invalid octal number: ${value}`);
+        }
+        decimalValue = BigInt('0o' + value);
+        break;
+      case 10:
+        if (!/^-?\d+$/.test(value)) {
+          return errorHandler.runtimeError('InvalidNumber', `Invalid decimal number: ${value}`);
+        }
+        decimalValue = BigInt(value);
+        break;
+      case 16:
+        if (!/^[0-9a-fA-F]+$/.test(value)) {
+          return errorHandler.runtimeError('InvalidNumber', `Invalid hexadecimal number: ${value}`);
+        }
+        decimalValue = BigInt('0x' + value);
+        break;
+      default:
+        return errorHandler.runtimeError('InvalidBase', `Unsupported base: ${fromBase}`);
+    }
+
+    // Handle negative numbers for base 10
+    const isNegative = decimalValue < 0n;
+    const absoluteValue = isNegative ? -decimalValue : decimalValue;
+
+    // Convert from decimal to target base
+    let result: string;
+
+    switch (toBase) {
+      case 2:
+        result = absoluteValue.toString(2);
+        break;
+      case 8:
+        result = absoluteValue.toString(8);
+        break;
+      case 10:
+        result = decimalValue.toString();
+        break;
+      case 16:
+        result = absoluteValue.toString(16).toUpperCase();
+        break;
+      default:
+        return errorHandler.runtimeError('InvalidBase', `Unsupported base: ${toBase}`);
+    }
+
+    return errorHandler.success(result, {
+      expression: `${value} (base ${fromBase}) → (base ${toBase})`,
+      steps: [
+        `Input: ${value} in base ${fromBase}`,
+        `Decimal value: ${decimalValue}`,
+        `Output: ${result} in base ${toBase}`,
+      ],
+    });
+  } catch (error) {
+    return errorHandler.runtimeError('InvalidNumber', error instanceof Error ? error.message : 'Unknown error during base conversion');
+  }
+}

package/src/mcp/tools/programmer.ts

@@ -0,0 +1,36 @@
+import { Lexer } from '../../parser/lexer.js';
+import { Parser } from '../../parser/parser.js';
+import { ProgrammerEngine } from '../../engines/programmer.js';
+import { ErrorHandler, CalculationResponse } from '../../errors/handler.js';
+
+export interface ProgrammerCalculateInput {
+  expression: string;
+}
+
+export function programmerCalculate(input: ProgrammerCalculateInput): CalculationResponse {
+  const errorHandler = new ErrorHandler();
+  const lexer = new Lexer();
+  const parser = new Parser();
+  const engine = new ProgrammerEngine();
+
+  const { expression } = input;
+
+  if (!expression || expression.trim().length === 0) {
+    return errorHandler.runtimeError('EmptyInput', 'Expression cannot be empty');
+  }
+
+  try {
+    const tokens = lexer.tokenize(expression);
+    const ast = parser.parse(tokens);
+    const result = engine.evaluate(ast);
+
+    return errorHandler.success(result.toString(), {
+      expression,
+    });
+  } catch (error) {
+    if (typeof error === 'object' && error !== null && 'success' in error) {
+      return error as CalculationResponse;
+    }
+    return errorHandler.runtimeError('InvalidNumber', error instanceof Error ? error.message : 'Unknown error');
+  }
+}

package/src/parser/ast.ts

@@ -0,0 +1,51 @@
+export type TokenType =
+  | 'NUMBER'
+  | 'HEX'
+  | 'BINARY'
+  | 'OCTAL'
+  | 'OPERATOR'
+  | 'LPAREN'
+  | 'RPAREN'
+  | 'CHAR_LITERAL'
+  | 'WHITESPACE'
+  | 'EOF';
+
+export interface Token {
+  type: TokenType;
+  value: string;
+  position: { start: number; end: number };
+}
+
+export type ASTNode =
+  | BinaryOpNode
+  | UnaryOpNode
+  | LiteralNode
+  | GroupNode;
+
+export interface BinaryOpNode {
+  type: 'BinaryOp';
+  operator: string;
+  left: ASTNode;
+  right: ASTNode;
+  position?: { start: number; end: number };
+}
+
+export interface UnaryOpNode {
+  type: 'UnaryOp';
+  operator: string;
+  operand: ASTNode;
+  position?: { start: number; end: number };
+}
+
+export interface LiteralNode {
+  type: 'Literal';
+  value: string;
+  tokenType: TokenType;
+  position?: { start: number; end: number };
+}
+
+export interface GroupNode {
+  type: 'Group';
+  expression: ASTNode;
+  position?: { start: number; end: number };
+}