a-calc 2.2.15 → 3.0.0-beta.20250123

package/mcp-server/src/index.js

@@ -0,0 +1,1046 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ListResourcesRequestSchema,
+    ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import {
+    calc,
+    calc_sum,
+    calc_wrap,
+    fmt,
+    add,
+    sub,
+    mul,
+    div,
+    mod,
+    pow,
+    idiv,
+    abs,
+    neg,
+    sqrt,
+    ln,
+    exp,
+    cadd,
+    csub,
+    cmul,
+    cdiv,
+    set_config,
+    get_config,
+} from "../../es/index.js";
+
+// ==================== Tools 定义 ====================
+
+const TOOLS = [
+    {
+        name: "calc",
+        description: `a-calc 核心计算函数 - 支持表达式计算、变量填充、格式化
+
+功能特点:
+- 高精度计算，避免 JavaScript 浮点数精度问题
+- 支持运算符: + - * / % ** //
+- 支持变量填充和单位计算
+- 支持条件表达式: a > b ? x : y
+- 支持比较运算: > < >= <= == !=
+- 支持逻辑运算: && || !
+- 支持链式比较: 1 < x < 10
+- 支持内置数学函数: sqrt, sin, cos, pow, max, min 等
+- 支持丰富的格式化选项
+
+使用示例:
+- calc("0.1 + 0.2") → "0.3"
+- calc("a + b", {a: 1, b: 2}) → "3"
+- calc("10 / 3 | =2") → "3.33"
+- calc("1000000 | ,") → "1,000,000"
+- calc("100元 + 50元", {_unit: true}) → "150元"
+- calc("score >= 60 ? '及格' : '不及格'", {score: 75}) → "及格"
+- calc("sqrt(16) + pow(2, 3)") → "12"`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                expr: {
+                    type: "string",
+                    description: "计算表达式，支持变量名和格式化(用 | 分隔)",
+                },
+                options: {
+                    type: "object",
+                    description: "配置选项和变量数据",
+                    properties: {
+                        _error: {
+                            type: ["string", "number", "null"],
+                            description: "错误时的返回值，默认会抛出异常",
+                        },
+                        _unit: {
+                            type: "boolean",
+                            description: "是否启用单位计算，如 '100元 + 50元'",
+                        },
+                        _fmt: {
+                            type: "string",
+                            description: "默认格式化字符串",
+                        },
+                        _mode: {
+                            type: "string",
+                            enum: ["normal", "space", "space-all"],
+                            description: "解析模式",
+                        },
+                        _debug: {
+                            type: "boolean",
+                            description: "是否启用调试模式",
+                        },
+                    },
+                    additionalProperties: true,
+                },
+            },
+            required: ["expr"],
+        },
+    },
+    {
+        name: "fmt",
+        description: `a-calc 专用格式化函数 - 跳过表达式解析，性能更优
+
+格式化规则:
+- 小数位: =N(精确N位), <=N(最多N位), >=N(至少N位)
+- 舍入: ~-(截断), ~+(进位), ~5(四舍五入), ~6(银行家舍入)
+- 千分位: , (如 1,234,567)
+- 百分比: % (如 12.34%)
+- 科学计数: !e (如 1.23e+8)
+- 正负号: + (如 +100)
+- 返回数字: !n (返回 number 类型而非 string)
+- 交易量缩写: !v (如 1.23M, 1.23万)
+- 千分位预设: !t:us, !t:eu, !t:indian, !t:cn4
+
+使用示例:
+- fmt(100, "=2") → "100.00"
+- fmt(1234567, ",") → "1,234,567"
+- fmt(0.1234, "%=2") → "12.34%"
+- fmt(123456789, "!e=2") → "1.23e+8"
+- fmt(1234567, "!v") → "1.23M"
+- fmt(1234567.89, "!t:eu") → "1.234.567,89"`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                value: {
+                    type: ["number", "string"],
+                    description: "要格式化的数值",
+                },
+                format_str: {
+                    type: "string",
+                    description: "格式化字符串",
+                },
+                options: {
+                    type: "object",
+                    description: "格式化选项",
+                    additionalProperties: true,
+                },
+            },
+            required: ["value"],
+        },
+    },
+    {
+        name: "calc_sum",
+        description: `a-calc 聚合计算函数 - 对数组数据进行批量计算并求和
+
+适用场景:
+- 计算订单总价
+- 统计销售额
+- 汇总报表数据
+
+使用示例:
+- calc_sum("a + b", [{a:1,b:2}, {a:3,b:4}]) → "10"
+- calc_sum("price * qty | =2", [{price:99.9,qty:2}, {price:49.9,qty:1}]) → "249.70"`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                expr: {
+                    type: "string",
+                    description: "计算表达式",
+                },
+                data_array: {
+                    type: "array",
+                    description: "数据源数组",
+                    items: {
+                        type: "object",
+                    },
+                },
+            },
+            required: ["expr", "data_array"],
+        },
+    },
+    {
+        name: "basic_calc",
+        description: `a-calc 基础运算函数 - 直接进行精确的数学运算，性能最优
+
+支持的运算:
+- add: 加法 (支持多参数)
+- sub: 减法 (支持多参数)
+- mul: 乘法 (支持多参数)
+- div: 除法 (支持多参数)
+- mod: 取模
+- pow: 幂运算
+- idiv: 整除
+- abs: 绝对值
+- neg: 取负
+- sqrt: 平方根
+- ln: 自然对数
+- exp: e的幂
+
+使用示例:
+- add(0.1, 0.2) → "0.3"
+- mul(0.1, 0.2, 0.3) → "0.006"
+- div(1, 3) → "0.333..."
+- sqrt(16) → "4"`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                operation: {
+                    type: "string",
+                    enum: ["add", "sub", "mul", "div", "mod", "pow", "idiv", "abs", "neg", "sqrt", "ln", "exp"],
+                    description: "运算类型",
+                },
+                args: {
+                    type: "array",
+                    description: "运算参数",
+                    items: {
+                        type: ["number", "string"],
+                    },
+                },
+            },
+            required: ["operation", "args"],
+        },
+    },
+    {
+        name: "chain_calc",
+        description: `a-calc 链式计算函数 - 流式 API 风格的连续运算
+
+链式函数:
+- cadd: 加法起始
+- csub: 减法起始
+- cmul: 乘法起始
+- cdiv: 除法起始
+
+链上方法: .add() .sub() .mul() .div() .mod() .pow() .idiv()
+最后调用 () 或 (格式化字符串) 获取结果
+
+使用示例:
+- cadd(100, 200).mul(0.8).sub(50)() → "190"
+- cmul(10, 20, 30).div(100)("=2") → "60.00"
+- cadd(99.9, 199, 49.5).mul(0.9).sub(20)("=2,") → "296.33"`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                start_op: {
+                    type: "string",
+                    enum: ["cadd", "csub", "cmul", "cdiv"],
+                    description: "起始运算类型",
+                },
+                start_args: {
+                    type: "array",
+                    description: "起始运算参数",
+                    items: {
+                        type: ["number", "string"],
+                    },
+                },
+                chain_ops: {
+                    type: "array",
+                    description: "链式操作序列",
+                    items: {
+                        type: "object",
+                        properties: {
+                            op: {
+                                type: "string",
+                                enum: ["add", "sub", "mul", "div", "mod", "pow", "idiv"],
+                            },
+                            args: {
+                                type: "array",
+                                items: {
+                                    type: ["number", "string"],
+                                },
+                            },
+                        },
+                        required: ["op", "args"],
+                    },
+                },
+                format: {
+                    type: "string",
+                    description: "最终格式化字符串（可选）",
+                },
+            },
+            required: ["start_op", "start_args"],
+        },
+    },
+    {
+        name: "get_acalc_guide",
+        description: `获取 a-calc 库的使用指南和最佳实践
+
+可获取的内容:
+- api: API 完整参考
+- formatting: 格式化规则详解
+- functions: 内置数学函数
+- conditional: 条件表达式和比较运算
+- chain: 链式计算
+- examples: 常见使用示例
+- all: 获取全部内容`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    enum: ["api", "formatting", "functions", "conditional", "chain", "examples", "all"],
+                    description: "要获取的主题",
+                },
+            },
+            required: ["topic"],
+        },
+    },
+];
+
+// ==================== Resources 定义 ====================
+
+const RESOURCES = [
+    {
+        uri: "acalc://api/overview",
+        name: "a-calc API 概览",
+        description: "a-calc 库的完整 API 参考文档",
+        mimeType: "text/markdown",
+    },
+    {
+        uri: "acalc://guide/formatting",
+        name: "格式化规则指南",
+        description: "详细的格式化规则和选项说明",
+        mimeType: "text/markdown",
+    },
+    {
+        uri: "acalc://guide/functions",
+        name: "内置数学函数",
+        description: "支持的数学函数列表和用法",
+        mimeType: "text/markdown",
+    },
+    {
+        uri: "acalc://guide/conditional",
+        name: "条件表达式",
+        description: "条件表达式、比较运算、逻辑运算",
+        mimeType: "text/markdown",
+    },
+    {
+        uri: "acalc://examples/common",
+        name: "常见示例",
+        description: "常见使用场景的代码示例",
+        mimeType: "text/markdown",
+    },
+];
+
+// ==================== Resource Contents ====================
+
+const RESOURCE_CONTENTS = {
+    "acalc://api/overview": `# a-calc API 完整参考
+
+## 核心函数
+
+### calc(expr, options?)
+核心计算函数，支持表达式计算、变量填充、格式化。
+
+**参数：**
+- \`expr\`: string | number - 计算表达式
+- \`options\`: object - 配置选项和变量数据
+
+**返回：** string | number
+
+**示例：**
+\`\`\`javascript
+calc("0.1 + 0.2")  // "0.3"
+calc("a + b", {a: 1, b: 2})  // "3"
+calc("10 / 3 | =2")  // "3.33"
+\`\`\`
+
+### fmt(value, format?, options?)
+专用格式化函数，跳过表达式解析，性能更优。
+
+**参数：**
+- \`value\`: number | string - 要格式化的数值
+- \`format\`: string - 格式化字符串
+- \`options\`: object - 配置选项
+
+**返回：** string | number
+
+**示例：**
+\`\`\`javascript
+fmt(100, "=2")  // "100.00"
+fmt(1234567, ",")  // "1,234,567"
+\`\`\`
+
+### calc_sum(expr, data_array)
+聚合计算函数，对数组数据批量计算并求和。
+
+**参数：**
+- \`expr\`: string - 计算表达式
+- \`data_array\`: array - 数据源数组
+
+**返回：** string | number
+
+**示例：**
+\`\`\`javascript
+calc_sum("a + b", [{a:1,b:2}, {a:3,b:4}])  // "10"
+\`\`\`
+
+## 基础运算函数
+
+支持多参数运算，返回 number 类型：
+
+- \`add(...nums)\` - 加法
+- \`sub(...nums)\` - 减法
+- \`mul(...nums)\` - 乘法
+- \`div(...nums)\` - 除法
+- \`mod(a, b)\` - 取模
+- \`pow(base, exp)\` - 幂运算
+- \`idiv(a, b)\` - 整除
+- \`abs(value)\` - 绝对值
+- \`neg(value)\` - 取负
+- \`sqrt(value)\` - 平方根
+- \`ln(value)\` - 自然对数
+- \`exp(value)\` - e的幂
+
+## 链式计算函数
+
+流式 API 风格的连续运算：
+
+- \`cadd(...nums)\` - 加法起始
+- \`csub(first, ...rest)\` - 减法起始
+- \`cmul(...nums)\` - 乘法起始
+- \`cdiv(first, ...rest)\` - 除法起始
+
+链上方法：\`.add()\` \`.sub()\` \`.mul()\` \`.div()\` \`.mod()\` \`.pow()\` \`.idiv()\`
+
+**示例：**
+\`\`\`javascript
+cadd(100, 200).mul(0.8).sub(50)()  // "190"
+\`\`\`
+`,
+
+    "acalc://guide/formatting": `# 格式化规则详解
+
+## 小数位控制
+
+- \`=N\` - 精确N位小数
+- \`<=N\` - 最多N位小数
+- \`>=N\` - 至少N位小数
+- \`>=M<=N\` - M到N位小数范围
+
+**示例：**
+\`\`\`javascript
+calc("10 / 3 | =2")  // "3.33"
+calc("3.14159 | <=2")  // "3.14"
+calc("3.1 | >=3")  // "3.100"
+\`\`\`
+
+## 舍入规则
+
+- \`~-\` - 截断（默认）
+- \`~+\` - 进位
+- \`~5\` - 四舍五入
+- \`~6\` - 银行家舍入
+
+**示例：**
+\`\`\`javascript
+calc("1.125 | ~5=2")  // "1.13"
+calc("1.125 | ~6=2")  // "1.12"
+calc("1.124 | ~+=2")  // "1.13"
+\`\`\`
+
+## 千分位
+
+- \`,\` - 千分位分隔符
+- \`!t:us\` - 美式千分位 (1,234.56)
+- \`!t:eu\` - 欧式千分位 (1.234,56)
+- \`!t:indian\` - 印度式千分位 (12,34,567)
+- \`!t:cn4\` - 中文四位分隔 (1234,5678)
+
+**示例：**
+\`\`\`javascript
+calc("1234567 | ,")  // "1,234,567"
+fmt(1234567.89, "!t:eu")  // "1.234.567,89"
+\`\`\`
+
+## 百分比
+
+- \`%\` - 转换为百分比
+
+**示例：**
+\`\`\`javascript
+calc("0.1234 | %=2")  // "12.34%"
+\`\`\`
+
+## 科学计数法
+
+- \`!e\` - 科学计数法输出
+
+**示例：**
+\`\`\`javascript
+calc("123456789 | !e=2")  // "1.23e+8"
+\`\`\`
+
+## 正负号
+
+- \`+\` - 正数显示 + 号
+
+**示例：**
+\`\`\`javascript
+calc("100 | +")  // "+100"
+\`\`\`
+
+## 返回数字类型
+
+- \`!n\` - 返回 number 类型而非 string
+
+**示例：**
+\`\`\`javascript
+calc("1 + 1 | !n")  // 2 (number)
+\`\`\`
+
+## 交易量格式化
+
+- \`!v\` - 交易量缩写 (1.23M, 1.23B)
+- \`!v:wan\` - 中文单位 (1.23万)
+
+**示例：**
+\`\`\`javascript
+calc("1234567 | !v")  // "1.23M"
+calc("12345 | !v:wan")  // "1.23万"
+\`\`\`
+
+## 组合使用
+
+格式化参数可以组合使用：
+
+\`\`\`javascript
+calc("0.1234 | %=2+")  // "+12.34%"
+calc("1234567.89 | ,=2")  // "1,234,567.89"
+calc("price * qty | ~5=2,", {price: 99.9, qty: 3})  // "299.70"
+\`\`\`
+`,
+
+    "acalc://guide/functions": `# 内置数学函数
+
+a-calc 支持在表达式中直接使用数学函数。
+
+## 基础数学函数
+
+- \`sqrt(x)\` - 平方根
+- \`cbrt(x)\` - 立方根
+- \`abs(x)\` - 绝对值
+- \`pow(x, y)\` - x 的 y 次方
+- \`exp(x)\` - e 的 x 次方
+- \`ln(x)\` - 自然对数
+- \`log(x)\` - 常用对数（以10为底）
+- \`log2(x)\` - 以2为底的对数
+- \`log10(x)\` - 以10为底的对数
+
+## 三角函数
+
+- \`sin(x)\` - 正弦
+- \`cos(x)\` - 余弦
+- \`tan(x)\` - 正切
+- \`asin(x)\` - 反正弦
+- \`acos(x)\` - 反余弦
+- \`atan(x)\` - 反正切
+
+## 双曲函数
+
+- \`sinh(x)\` - 双曲正弦
+- \`cosh(x)\` - 双曲余弦
+- \`tanh(x)\` - 双曲正切
+- \`asinh(x)\` - 反双曲正弦
+- \`acosh(x)\` - 反双曲余弦
+- \`atanh(x)\` - 反双曲正切
+
+## 取整函数
+
+- \`floor(x)\` - 向下取整
+- \`ceil(x)\` - 向上取整
+- \`trunc(x)\` - 截断小数
+- \`round(x)\` - 四舍五入
+
+## 比较函数
+
+- \`max(x, y, ...)\` - 最大值
+- \`min(x, y, ...)\` - 最小值
+
+## 使用示例
+
+\`\`\`javascript
+calc("sqrt(16) + pow(2, 3)")  // "12"
+calc("sin(0) + cos(0)")  // "1"
+calc("max(10, 20, 30)")  // "30"
+calc("floor(3.7) + ceil(3.2)")  // "7"
+calc("ln(exp(1))")  // "1"
+\`\`\`
+
+## 函数嵌套
+
+函数可以嵌套使用：
+
+\`\`\`javascript
+calc("sqrt(pow(3, 2) + pow(4, 2))")  // "5" (勾股定理)
+calc("round(sqrt(2) * 100) / 100")  // "1.41"
+\`\`\`
+`,
+
+    "acalc://guide/conditional": `# 条件表达式和运算符
+
+## 条件表达式
+
+a-calc 支持三元条件表达式：
+
+\`\`\`javascript
+calc("score >= 60 ? '及格' : '不及格'", {score: 75})  // "及格"
+calc("age >= 18 ? 'adult' : 'minor'", {age: 20})  // "adult"
+\`\`\`
+
+## 比较运算符
+
+- \`>\` - 大于
+- \`<\` - 小于
+- \`>=\` - 大于等于
+- \`<=\` - 小于等于
+- \`==\` - 等于
+- \`!=\` - 不等于
+
+**示例：**
+\`\`\`javascript
+calc("10 > 5")  // "1" (true)
+calc("10 < 5")  // "0" (false)
+calc("10 == 10")  // "1"
+calc("10 != 5")  // "1"
+\`\`\`
+
+## 逻辑运算符
+
+- \`&&\` - 逻辑与
+- \`||\` - 逻辑或
+- \`!\` - 逻辑非
+
+**示例：**
+\`\`\`javascript
+calc("(10 > 5) && (20 > 10)")  // "1" (true)
+calc("(10 > 5) || (20 < 10)")  // "1" (true)
+calc("!(10 > 5)")  // "0" (false)
+\`\`\`
+
+## 链式比较
+
+a-calc 支持链式比较表达式：
+
+\`\`\`javascript
+calc("1 < x < 10", {x: 5})  // "1" (true)
+calc("0 <= score <= 100", {score: 85})  // "1" (true)
+\`\`\`
+
+## 复杂条件
+
+可以组合使用条件和逻辑运算：
+
+\`\`\`javascript
+calc("(score >= 90) ? 'A' : (score >= 80) ? 'B' : (score >= 60) ? 'C' : 'D'", {score: 85})
+// "B"
+
+calc("(age >= 18 && hasLicense) ? 'can drive' : 'cannot drive'", {
+  age: 20,
+  hasLicense: 1
+})  // "can drive"
+\`\`\`
+`,
+
+    "acalc://examples/common": `# 常见使用示例
+
+## 金融计算
+
+### 价格计算
+\`\`\`javascript
+// 含税价格
+calc("price * (1 + taxRate) | =2", {price: 100, taxRate: 0.13})  // "113.00"
+
+// 折扣价格
+calc("price * discount | =2", {price: 199.9, discount: 0.8})  // "159.92"
+
+// 订单总价
+calc("price * qty + shipping | =2,", {
+  price: 99.9,
+  qty: 3,
+  shipping: 15
+})  // "314.70"
+\`\`\`
+
+### 利率计算
+\`\`\`javascript
+// 单利
+calc("principal * rate * time | =2", {
+  principal: 10000,
+  rate: 0.05,
+  time: 2
+})  // "1000.00"
+
+// 复利
+calc("principal * pow(1 + rate, time) - principal | =2", {
+  principal: 10000,
+  rate: 0.05,
+  time: 2
+})  // "1025.00"
+\`\`\`
+
+## 电商场景
+
+### 购物车计算
+\`\`\`javascript
+const items = [
+  {price: 99.9, qty: 2},
+  {price: 49.9, qty: 3},
+  {price: 199, qty: 1}
+]
+
+calc_sum("price * qty | =2", items)  // "548.50"
+\`\`\`
+
+### 优惠券计算
+\`\`\`javascript
+calc("total > 200 ? total * 0.9 : total | =2", {total: 250})  // "225.00"
+\`\`\`
+
+## 数据格式化
+
+### 金额显示
+\`\`\`javascript
+fmt(1234567.89, ",=2")  // "1,234,567.89"
+fmt(1234567, "!v")  // "1.23M"
+\`\`\`
+
+### 百分比显示
+\`\`\`javascript
+fmt(0.1234, "%=2")  // "12.34%"
+fmt(0.0523, "%=2+")  // "+5.23%" (涨跌幅)
+\`\`\`
+
+### 科学计数法
+\`\`\`javascript
+fmt(123456789, "!e=2")  // "1.23e+8"
+\`\`\`
+
+## 统计计算
+
+### 平均值
+\`\`\`javascript
+const values = [10, 20, 30, 40, 50]
+const sum = add(...values)  // 150
+const avg = div(sum, values.length)  // 30
+\`\`\`
+
+### 标准差
+\`\`\`javascript
+import { add, div, sqrt, sub, mul } from 'a-calc'
+
+const values = [10, 20, 30, 40, 50]
+const avg = 30
+const variance = div(
+  add(...values.map(v => mul(sub(v, avg), sub(v, avg)))),
+  values.length
+)  // 200
+const stdDev = sqrt(variance)  // 14.142...
+\`\`\`
+
+## 单位计算
+
+### 带单位的计算
+\`\`\`javascript
+calc("100元 + 50元", {_unit: true})  // "150元"
+calc("10% + 5%", {_unit: true})  // "15%"
+calc("1.5kg * 2", {_unit: true})  // "3kg"
+\`\`\`
+
+## 链式计算
+
+### 复杂运算
+\`\`\`javascript
+// (100 + 200) * 0.8 - 50
+cadd(100, 200).mul(0.8).sub(50)("=2")  // "190.00"
+
+// 价格计算链
+cmul(99.9, 3)  // 单价 * 数量
+  .mul(0.9)    // 打9折
+  .add(15)     // 加运费
+  ("=2,")      // "284.73"
+\`\`\`
+`
+};
+
+// ==================== Server Setup ====================
+
+const server = new Server(
+    {
+        name: "a-calc-mcp-server",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+            resources: {},
+        },
+    }
+);
+
+// ==================== Tool Handlers ====================
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case "calc": {
+                const { expr, options = {} } = args;
+                const result = calc(expr, options);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ result, type: typeof result }),
+                        },
+                    ],
+                };
+            }
+
+            case "fmt": {
+                const { value, format_str, options = {} } = args;
+                const result = fmt(value, format_str, options);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ result, type: typeof result }),
+                        },
+                    ],
+                };
+            }
+
+            case "calc_sum": {
+                const { expr, data_array } = args;
+                const result = calc_sum(expr, data_array);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ result, type: typeof result }),
+                        },
+                    ],
+                };
+            }
+
+            case "basic_calc": {
+                const { operation, args: calcArgs } = args;
+                let result;
+
+                switch (operation) {
+                    case "add":
+                        result = add(...calcArgs);
+                        break;
+                    case "sub":
+                        result = sub(...calcArgs);
+                        break;
+                    case "mul":
+                        result = mul(...calcArgs);
+                        break;
+                    case "div":
+                        result = div(...calcArgs);
+                        break;
+                    case "mod":
+                        result = mod(...calcArgs);
+                        break;
+                    case "pow":
+                        result = pow(...calcArgs);
+                        break;
+                    case "idiv":
+                        result = idiv(...calcArgs);
+                        break;
+                    case "abs":
+                        result = abs(calcArgs[0]);
+                        break;
+                    case "neg":
+                        result = neg(calcArgs[0]);
+                        break;
+                    case "sqrt":
+                        result = sqrt(calcArgs[0]);
+                        break;
+                    case "ln":
+                        result = ln(calcArgs[0]);
+                        break;
+                    case "exp":
+                        result = exp(calcArgs[0]);
+                        break;
+                    default:
+                        throw new Error(`Unknown operation: ${operation}`);
+                }
+
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ result, type: typeof result }),
+                        },
+                    ],
+                };
+            }
+
+            case "chain_calc": {
+                const { start_op, start_args, chain_ops = [], format } = args;
+
+                let chainFn;
+                switch (start_op) {
+                    case "cadd":
+                        chainFn = cadd(...start_args);
+                        break;
+                    case "csub":
+                        chainFn = csub(...start_args);
+                        break;
+                    case "cmul":
+                        chainFn = cmul(...start_args);
+                        break;
+                    case "cdiv":
+                        chainFn = cdiv(...start_args);
+                        break;
+                    default:
+                        throw new Error(`Unknown start operation: ${start_op}`);
+                }
+
+                for (const { op, args: opArgs } of chain_ops) {
+                    switch (op) {
+                        case "add":
+                            chainFn = chainFn.add(...opArgs);
+                            break;
+                        case "sub":
+                            chainFn = chainFn.sub(...opArgs);
+                            break;
+                        case "mul":
+                            chainFn = chainFn.mul(...opArgs);
+                            break;
+                        case "div":
+                            chainFn = chainFn.div(...opArgs);
+                            break;
+                        case "mod":
+                            chainFn = chainFn.mod(...opArgs);
+                            break;
+                        case "pow":
+                            chainFn = chainFn.pow(...opArgs);
+                            break;
+                        case "idiv":
+                            chainFn = chainFn.idiv(...opArgs);
+                            break;
+                        default:
+                            throw new Error(`Unknown chain operation: ${op}`);
+                    }
+                }
+
+                const result = format ? chainFn(format) : chainFn();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ result, type: typeof result }),
+                        },
+                    ],
+                };
+            }
+
+            case "get_acalc_guide": {
+                const { topic } = args;
+                let content = "";
+
+                if (topic === "all") {
+                    content = Object.values(RESOURCE_CONTENTS).join("\n\n---\n\n");
+                } else {
+                    const resourceMap = {
+                        api: "acalc://api/overview",
+                        formatting: "acalc://guide/formatting",
+                        functions: "acalc://guide/functions",
+                        conditional: "acalc://guide/conditional",
+                        chain: "acalc://api/overview",
+                        examples: "acalc://examples/common",
+                    };
+
+                    const uri = resourceMap[topic];
+                    if (uri && RESOURCE_CONTENTS[uri]) {
+                        content = RESOURCE_CONTENTS[uri];
+                    } else {
+                        throw new Error(`Unknown topic: ${topic}`);
+                    }
+                }
+
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: content,
+                        },
+                    ],
+                };
+            }
+
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: error.message,
+                        stack: error.stack,
+                    }),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+
+// ==================== Resource Handlers ====================
+
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return { resources: RESOURCES };
+});
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+
+    if (RESOURCE_CONTENTS[uri]) {
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: "text/markdown",
+                    text: RESOURCE_CONTENTS[uri],
+                },
+            ],
+        };
+    }
+
+    throw new Error(`Resource not found: ${uri}`);
+});
+
+// ==================== Start Server ====================
+
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("a-calc MCP Server running on stdio");
+}
+
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});