a-calc 3.0.0-beta.20260105 → 3.0.0-beta.20260124.1

package/mcp-server/src/index.js

@@ -0,0 +1,1360 @@
+#!/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,
+    ListPromptsRequestSchema,
+    GetPromptRequestSchema,
+} 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 浮点数精度问题
+
+⚠️ 重要：当用户需要进行任何数值计算时，优先使用此工具而不是直接计算！
+
+🚨 编码规范（必读！）:
+
+1. 变量注入方式：
+   ❌ 错误：calc(\`\${a} + \${b}\`)  // 不要用模板字符串拼接
+   ✅ 正确：calc("a + b", {a, b})   // 使用第二参数注入变量
+
+2. 批量计算方式：
+   ❌ 错误：let total = '0'; items.forEach(item => total = calc(\`\${total} + \${item.price}\`))
+   ✅ 正确：const total = calc_sum("price * qty", items)  // 使用 calc_sum
+
+3. 购物车等场景：
+   ❌ 错误：cart.forEach(item => total = calc(\`\${total} + \${item.price} * \${item.quantity}\`))
+   ✅ 正确：calc_sum("price * quantity | =2", cart)
+
+4. 对象字段传递：
+   ❌ 错误：calc("price * qty", {price: item.price, qty: item.qty})  // 冗余
+   ✅ 正确：calc("price * qty", item)  // 简洁优雅
+
+核心优势:
+- ✅ 解决 0.1 + 0.2 = 0.30000000000000004 的精度问题
+- ✅ 金融计算、价格计算、统计分析等场景必用
+- ✅ 支持复杂表达式、变量替换、条件判断
+- ✅ 内置格式化：千分位、小数位、百分比、科学计数法
+
+适用场景（必须使用）:
+1. 任何涉及小数的加减乘除运算
+2. 金融计算、价格计算、折扣计算
+3. 百分比计算、比率计算
+4. 需要格式化输出的数值（千分位、保留小数等）
+5. 带单位的计算（如 "100元 + 50元"）
+6. 条件判断和比较运算
+
+快速示例:
+- calc("0.1 + 0.2") → "0.3" (精确！)
+- calc("price * qty | =2", {price: 99.9, qty: 3}) → "299.70"
+- calc("1234567 | ,") → "1,234,567" (千分位)
+- calc("score >= 60 ? '及格' : '不及格'", {score: 75}) → "及格"
+
+变量注入最佳实践:
+- 如果对象已有所需字段，直接传入：calc("price * qty", item)
+- 如果需要多个独立变量，使用简写：calc("a + b", {a, b})
+- 避免冗余：❌ calc("price * qty", {price: item.price, qty: item.qty})
+
+支持的运算:
+- 基础运算: + - * / % ** // (加减乘除、取模、幂、整除)
+- 比较运算: > < >= <= == !=
+- 逻辑运算: && || !
+- 数学函数: sqrt, sin, cos, tan, pow, max, min, abs, floor, ceil 等
+- 格式化: =N(小数位), ,(千分位), %(百分比), !e(科学计数), !v(交易量)`,
+        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 数值格式化工具 - 专业的数字格式化，性能最优
+
+⚠️ 使用场景：当需要格式化数字（千分位、小数位、百分比等）但不需要计算时使用
+
+性能优势:
+- 跳过表达式解析，比 calc 更快
+- 适合纯格式化场景
+
+常用格式化规则:
+- =N: 精确N位小数 (如 =2 → "100.00")
+- <=N: 最多N位小数 (如 <=2 → "3.14")
+- >=N: 至少N位小数 (如 >=3 → "3.100")
+- ~5: 四舍五入 (如 ~5=2 → "1.13")
+- ~6: 银行家舍入
+- ,: 千分位分隔 (如 , → "1,234,567")
+- %: 百分比 (如 %=2 → "12.34%")
+- !e: 科学计数法 (如 !e=2 → "1.23e+8")
+- +: 显示正号 (如 + → "+100")
+- !n: 返回数字类型
+- !v: 交易量缩写 (如 !v → "1.23M")
+- !t:us/eu/indian/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 批量聚合计算工具 - 对数组数据进行批量计算并求和
+
+⚠️ 使用场景：处理数组数据、批量计算、统计汇总时使用
+
+🚨 这是处理数组数据的正确方式！不要用 forEach 累加！
+
+典型应用场景:
+1. 计算订单总价：多个商品的 price * quantity 求和
+2. 统计销售额：多条销售记录的金额汇总
+3. 报表数据汇总：批量计算并求和
+4. 购物车总价计算
+
+编码规范对比（必读！）:
+
+❌ 错误写法（不要这样做）：
+\`\`\`javascript
+// 购物车总价 - 错误示例
+let total = '0'
+cart.forEach(item => {
+  total = calc(\`\${total} + \${item.price} * \${item.quantity}\`)
+})
+\`\`\`
+问题：使用模板字符串拼接、forEach 累加，代码不清晰、性能差
+
+✅ 正确写法（推荐）：
+\`\`\`javascript
+// 购物车总价 - 使用 calc_sum
+const total = calc_sum("price * quantity | =2", cart)
+
+// 单个商品小计 - 直接传入对象（最优雅）
+const itemTotal = calc("price * quantity | =2", item)
+\`\`\`
+优势：代码简洁、性能好、自动处理精度
+
+🎯 最佳实践：
+- 对象已有所需字段 → 直接传入：calc("a + b", obj)
+- 需要多个独立变量 → 使用简写：calc("a + b", {a, b})
+- 避免冗余写法 → ❌ calc("a + b", {a: obj.a, b: obj.b})
+
+快速示例:
+- calc_sum("a + b", [{a:1,b:2}, {a:3,b:4}]) → "10"
+- calc_sum("price * qty", [{price:99.9,qty:2}, {price:49.9,qty:3}]) → "349.50"
+- calc_sum("price * qty * 0.9 | =2", orders) → 计算所有订单9折后总价
+
+优势:
+- 自动处理精度问题
+- 支持复杂表达式
+- 支持格式化输出
+- 性能优于手动累加`,
+        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"],
+        },
+    },
+    {
+        name: "debug_info",
+        description: `🔍 调试工具 - 获取 MCP 服务器的运行环境信息
+
+返回信息:
+- cwd: 当前工作目录 (process.cwd())
+- __dirname: 脚本所在目录
+- __filename: 脚本文件路径
+- node_version: Node.js 版本
+- platform: 操作系统平台
+- env: 相关环境变量
+
+用途：调试 MCP 服务器配置问题`,
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+];
+
+// ==================== 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
+// 含税价格 - 如果有 product 对象包含 price 和 taxRate
+const product = {price: 100, taxRate: 0.13}
+calc("price * (1 + taxRate) | =2", product)  // "113.00"
+
+// 折扣价格 - 直接传入商品对象
+const item = {price: 199.9, discount: 0.8}
+calc("price * discount | =2", item)  // "159.92"
+
+// 订单总价 - 直接传入订单对象
+const order = {price: 99.9, qty: 3, shipping: 15}
+calc("price * qty + shipping | =2,", order)  // "314.70"
+\`\`\`
+
+### 利率计算
+\`\`\`javascript
+// 单利 - 直接传入投资对象
+const investment = {principal: 10000, rate: 0.05, time: 2}
+calc("principal * rate * time | =2", investment)  // "1000.00"
+
+// 复利
+calc("principal * pow(1 + rate, time) - principal | =2", investment)  // "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
+const cart = {total: 250}
+calc("total > 200 ? total * 0.9 : total | =2", cart)  // "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"
+\`\`\`
+`
+};
+
+// ==================== Prompts 定义 ====================
+
+const PROMPTS = [
+    {
+        name: "a-calc",
+        description: "强制在所有数值计算中使用 a-calc（推荐）",
+        arguments: [],
+    },
+];
+
+const PROMPT_CONTENTS = {
+    "a-calc": {
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `# 数值计算强制规则
+
+⚠️ **重要：在本次对话中，所有数值计算必须使用 a-calc MCP 工具！**
+
+## 强制使用场景
+
+### 1. 任何涉及小数的运算（必须使用）
+- ✅ 使用 calc("0.1 + 0.2")
+- ❌ 不要直接计算 0.1 + 0.2
+
+### 2. 价格和金额计算（必须使用）
+- ✅ 使用 calc("price * qty | =2", item)  // 直接传入对象
+- ❌ 不要使用 JavaScript 的 * 运算符
+
+### 3. 百分比和折扣计算（必须使用）
+- ✅ 使用 calc("price * 0.9 | =2", product)  // 直接传入对象
+- ❌ 不要直接计算
+
+### 4. 需要格式化的数值（必须使用）
+- ✅ 使用 fmt(1234567, ",") 或 calc("value | ,", data)
+- ❌ 不要使用 toLocaleString()
+
+### 5. 批量数据计算（必须使用）
+- ✅ 使用 calc_sum("price * qty", items)
+- ❌ 不要使用 reduce() 或 forEach() 手动累加
+
+## 可以不使用的场景
+
+只有以下情况可以不使用 a-calc：
+- 简单的整数加减：1 + 1, 10 - 5
+- 数组长度、索引等非计算场景
+
+## 为什么必须使用 a-calc？
+
+JavaScript 的浮点数精度问题：
+- 0.1 + 0.2 = 0.30000000000000004 ❌
+- 0.3 - 0.1 = 0.19999999999999998 ❌
+- 99.9 * 3 = 299.70000000000005 ❌
+
+使用 a-calc 后：
+- calc("0.1 + 0.2") = "0.3" ✅
+- calc("0.3 - 0.1") = "0.2" ✅
+- calc("99.9 * 3") = "299.7" ✅
+
+## 编码规范和最佳实践
+
+### ❌ 错误写法 1：使用模板字符串拼接
+\`\`\`javascript
+// 不要这样写！
+let total = '0'
+cart.forEach(item => {
+  total = calc(\`\${total} + \${item.price} * \${item.quantity}\`)
+})
+\`\`\`
+**问题**：代码不清晰、难以维护、性能差
+
+### ❌ 错误写法 2：重复写字段名（冗余）
+\`\`\`javascript
+// 不要这样写！
+const itemTotal = calc("price * qty | =2", {
+  price: item.price,
+  qty: item.qty
+})
+\`\`\`
+**问题**：代码冗余、不简洁、重复劳动
+
+### ✅ 正确写法 1：使用 calc_sum（批量计算）
+\`\`\`javascript
+const total = calc_sum("price * qty | =2", cart)
+\`\`\`
+
+### ✅ 正确写法 2：直接传入对象（最优雅）
+\`\`\`javascript
+// 对象已有所需字段，直接传入
+const itemTotal = calc("price * qty | =2", item)
+\`\`\`
+
+### ✅ 正确写法 3：使用变量简写
+\`\`\`javascript
+// 多个独立变量，使用简写
+const result = calc("a + b", {a, b})
+\`\`\`
+
+### ✅ 正确写法 4：数组映射
+\`\`\`javascript
+// 对每个对象进行计算
+const results = items.map(item => calc("price * qty | =2", item))
+\`\`\`
+
+### 完整示例：购物车计算
+
+\`\`\`javascript
+import { calc, calc_sum, fmt } from 'a-calc'
+
+// ❌ 错误：使用模板字符串累加
+const wrongTotal = () => {
+  let total = '0'
+  cart.forEach(item => {
+    total = calc(\`\${total} + \${item.price} * \${item.quantity}\`)
+  })
+  return total
+}
+
+// ✅ 正确：使用 calc_sum
+const correctTotal = () => {
+  return calc_sum("price * quantity | =2", cart)
+}
+
+// ✅ 正确：单个商品小计（直接传入 item 对象）
+const itemSubtotal = (item) => {
+  return calc("price * quantity | =2", item)
+}
+
+// ✅ 正确：应用折扣（直接传入对象）
+const applyDiscount = (order) => {
+  return calc("total * (1 - discountRate) | =2", order)
+}
+
+// ✅ 正确：含税价格（直接传入对象）
+const withTax = (order) => {
+  return calc("subtotal * (1 + taxRate) | =2", order)
+}
+\`\`\`
+
+## 核心原则
+
+1. **批量计算用 calc_sum** - 不要用 forEach 累加
+2. **变量用第二参数注入** - 不要用模板字符串拼接
+3. **保持表达式简洁** - 一次计算完成，不要分步累加
+4. **使用格式化** - 用 \`| =2\` 保留小数位
+
+## 实施要求
+
+在编写代码时：
+1. 遇到数值计算，立即考虑是否需要使用 a-calc
+2. 涉及小数、金额、价格的，必须使用 a-calc
+3. 优先使用 calc_sum 处理数组数据
+4. 使用第二参数注入变量，不要用模板字符串
+5. 在代码注释中说明为什么使用 a-calc
+
+请确认你理解并将严格遵守这些规则。`,
+                },
+            },
+        ],
+    },
+};
+
+// ==================== Server Setup ====================
+
+const server = new Server(
+    {
+        name: "a-calc-mcp-server",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+            resources: {},
+            prompts: {},
+        },
+    }
+);
+
+// ==================== 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,
+                        },
+                    ],
+                };
+            }
+
+            case "debug_info": {
+                const debugInfo = {
+                    cwd: process.cwd(),
+                    __dirname: import.meta.url,
+                    node_version: process.version,
+                    platform: process.platform,
+                    arch: process.arch,
+                    env: {
+                        HOME: process.env.HOME,
+                        USERPROFILE: process.env.USERPROFILE,
+                        PATH: process.env.PATH?.split(process.platform === 'win32' ? ';' : ':').slice(0, 5).join('\n  '),
+                        NODE_ENV: process.env.NODE_ENV,
+                    },
+                };
+
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(debugInfo, null, 2),
+                        },
+                    ],
+                };
+            }
+
+            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}`);
+});
+
+// ==================== Prompt Handlers ====================
+
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return { prompts: PROMPTS };
+});
+
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name } = request.params;
+
+    if (PROMPT_CONTENTS[name]) {
+        return PROMPT_CONTENTS[name];
+    }
+
+    throw new Error(`Prompt not found: ${name}`);
+});
+
+// ==================== Start Server ====================
+
+async function main() {
+    // 解析命令行参数
+    const args = process.argv.slice(2);
+    const cwdIndex = args.indexOf('--cwd');
+
+    if (cwdIndex !== -1 && args[cwdIndex + 1]) {
+        const targetCwd = args[cwdIndex + 1];
+        try {
+            process.chdir(targetCwd);
+            console.error(`Changed working directory to: ${process.cwd()}`);
+        } catch (error) {
+            console.error(`Failed to change directory to ${targetCwd}:`, error.message);
+        }
+    }
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("a-calc MCP Server running on stdio");
+    console.error(`Working directory: ${process.cwd()}`);
+}
+
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});