cli-calctool 1.0.0 → 1.0.2

package/skills/blueprint/SKILL.md

@@ -1,47 +0,0 @@
----
-name: blueprint
-description: '把一个目标编译为可执行、可验证、可追溯的工程蓝图（确定性检查节点/依赖/验收标准/合同）。Compile one goal into an executable, verifiable, traceable engineering blueprint with deterministic checks. Превращает цель в исполняемый, проверяемый инженерный план с узлами, зависимостями, критериями приёмки и валидацией.'
----
-
-# Blueprint Skill
-
-Endpoint: https://cli.tax/wvz6zmRWmX
-Request schema: blueprint.skill.request/1.0
-Response schema: blueprint.skill.response/1.0
-
-## Request envelope
-
-POST JSON to the endpoint with an `input` wrapper:
-
-```json
-{
-  "input": {
-    "schemaVersion": "blueprint.skill.request/1.0",
-    "requestId": "<unique-id>",
-    "operation": "<operation>",
-    "input": {}
-  }
-}
-```
-
-## Operations
-
-- `capabilities`: discover the operation list, per-operation inputs, and the recommended next step.
-- `help`: return the usage guide, operation catalog, and request examples.
-- `intake`: return the questions the IDE must ask the user before building the Blueprint.
-- `validate`: deterministically validate a Blueprint object conforming to `blueprint.ir/1.0`.
-- `compile-inline`: validate and compile a Blueprint, returning the generated artifacts inline.
-
-## Required flow
-
-1. Call `capabilities` first and read the returned `nextStep`.
-2. Call `intake` and ask the user the returned questions one at a time, waiting for each answer.
-3. Do not compile a Blueprint until all required questions are answered.
-4. Build a Blueprint conforming to `blueprint.ir/1.0`, then call `validate`.
-5. Fix every validation finding until the report is green, then call `compile-inline` and save the artifacts.
-
-## Safety rules
-
-- Never send credentials, model keys, provider endpoints, or personal secrets inside the request envelope or `input`.
-- The response `status` must be `succeeded`; a `failed` response is an error, not a result.
-- Public responses never prove that code was developed, tested, or deployed.

package/skills/blueprint/install-meta.json

@@ -1,7 +0,0 @@
-{
-  "source": "wvz6zmRWmX",
-  "slug": "blueprint",
-  "version": "v0.4.0",
-  "endpoint": "https://cli.tax/api/public/skills/wvz6zmRWmX",
-  "installedAt": "2026-08-17T00:00:00.000Z"
-}

package/skills/blueprint/skill.json

@@ -1,10 +0,0 @@
-{
-  "name": "blueprint",
-  "displayName": "Blueprint",
-  "description": "Blueprint 是一个跨工具的工程规划 CLI，把明确目标编译为可执行、可追溯、可验收的全站工程蓝图，并通过确定性规则检查每个节点、分支、合同、任务与验收闭环。默认由当前 IDE 的多智能体协同推演，也可连接用户自行安装的本地 Hermes；平台不托管模型密钥。",
-  "schemaVersion": "cli.request/1.0",
-  "endpoint": "https://cli.tax/wvz6zmRWmX",
-  "method": "POST",
-  "version": "v0.4.0",
-  "type": "Skill"
-}

package/skills/calctool/install-meta.json

@@ -1,7 +0,0 @@
-{
-  "source": "KKyA6xljUX",
-  "slug": "calctool",
-  "version": "v0.4.0",
-  "endpoint": "https://cli.tax/api/public/skills/KKyA6xljUX",
-  "installedAt": "2026-08-17T00:00:00.000Z"
-}

package/skills/calctool/platform-template/README.md

@@ -1,74 +0,0 @@
-# calctool 平台模板
-
-由 calctool 生成的**可运行计算工具**工程模板（配置驱动、框架不变）。
-
-## 一键运行
-
-```bash
-npm install        # 或 pnpm install / yarn install（环境自动适配）
-npm run dev        # 启动开发服务器 http://localhost:5173
-```
-
-## 结构
-
-```
-├── src/
-│   ├── main.tsx                    # 入口（Ant Design X ConfigProvider）
-│   ├── App.tsx                     # 应用壳（录入/指标卡/链路/报告/授权 五页）
-│   ├── engine-definition.json      # ★ 引擎定义 + 链路（改这里 = 改工具，框架不动）
-│   ├── engine/
-│   │   ├── evaluate.ts             # JSON AST + decimal.js 确定性求值
-│   │   └── (recompute.ts 依赖图增量重算，按需扩展)
-│   ├── pipeline.ts                 # ★ 链路编排（联通节点，非单页孤岛）
-│   ├── authz.ts                    # ★ 授权管理（首次使用同意 + 逐能力授权，一次授权持久化）
-│   └── store.ts                    # 存储层（localStorage，可换 sqlite）
-├── vite.config.ts
-└── package.json
-```
-
-## 整套工具（联通节点，非单页孤岛）
-
-工具由**联通节点**组成，数据流在节点间流动：
-
-```
-录入/导入 → 数据校验 → 确定性计算 → 数据存储 → 指标卡/报告
-                                    ↘ 自动化（可选）
-```
-
-- 改动指标/公式：只改 `engine-definition.json`，链路自动感知
-- 新增能力：在 `pipeline.ts` 加节点（如导入、导出、告警），页面无需改
-- 页面「链路」Tab 可视化每个节点及其上下游，改工具时定位影响范围
-
-## 授权与消耗提示
-
-1. **首次使用总提示**：打开工具时弹窗告知"可能调用其他技能辅助、可能增加消耗"，同意后持久化不再提示（可按工具分别记录）
-2. **逐能力授权**：实际调用外部能力（Blueprint/搜索/模型/存储/自动化）前询问，一次授权永久记住
-3. **授权管理页**：随时查看已授权能力、撤销授权
-
-
-## 改指标/公式（需求变更，框架不变）
-
-编辑 `src/engine-definition.json`：
-
-```json
-{
-  "fields": [{ "key": "visitors", "label": "访客数", "type": "integer", "unit": "人" }],
-  "formulas": [
-    { "key": "conversionRate", "label": "转化率",
-      "expression": { "op": "safeDivide", "args": [{ "ref": "orders" }, { "ref": "visitors" }] } }
-  ]
-}
-```
-
-保存即热更新——**不用改任何代码**。
-
-## 公式运算符（详见 formula-dsl.md）
-
-`add / sub / mul / div（除零报错）/ safeDivide（除零回退）/ percentOf / round / if / ref / lit`
-
-## 环境适配
-
-- Node ≥18：全功能（可换 better-sqlite3 持久化）
-- Node 16：兼容（sql.js WASM）
-- Node <16：建议只用 L0 配置预览
-- 包管理器：npm/pnpm/yarn 命令自动适配

package/skills/calctool/platform-template/index.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>calctool 计算工具</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

package/skills/calctool/platform-template/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "calctool-tool",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "description": "calctool 生成的可运行计算工具（配置驱动，Ant Design X + decimal.js）",
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc -b && vite build",
-    "preview": "vite preview",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "antd": "^6.0.0",
-    "@ant-design/x": "^2.9.0",
-    "decimal.js": "^10.4.3",
-    "lucide-react": "^0.469.0"
-  },
-  "devDependencies": {
-    "@vitejs/plugin-react": "^4.3.4",
-    "typescript": "^5.6.0",
-    "vite": "^6.0.0"
-  }
-}

package/skills/calctool/platform-template/src/App.tsx

@@ -1,233 +0,0 @@
-// calctool 生成的可运行工具：整套工具（联通节点，非单页孤岛）
-// 链路：录入 → 校验 → 计算 → 存储 → 输出（+ 自动化）
-// 调用外部能力前必须授权（一次授权持久化，不再提示）
-import { useEffect, useState } from 'react'
-import { Alert, Button, Card, Form, Input, InputNumber, message, Modal, Segmented, Space, Statistic, Table, Tag, Typography } from 'antd'
-import { evaluateEngine } from './engine/evaluate'
-import { ToolStore } from './store'
-import { authz, OnboardingConsent, type CapabilityKind } from './authz'
-import { defaultPipeline, nodeNeighbors, type EngineDefinition } from './pipeline'
-import engine from './engine-definition.json'
-
-const { Title, Paragraph, Text } = Typography
-
-const def = engine as EngineDefinition
-const store = new ToolStore(def.engineId)
-const pipeline = def.pipeline ?? defaultPipeline(def.engineId)
-const onboarding = new OnboardingConsent(def.engineId)
-
-export default function App() {
-  const [form] = Form.useForm()
-  const [results, setResults] = useState<Record<string, string>>({})
-  const [page, setPage] = useState<string>('input')
-  const [history, setHistory] = useState(store.list())
-  const [authzModal, setAuthzModal] = useState<{ capability: CapabilityKind; purpose: string } | null>(null)
-  const [showOnboarding, setShowOnboarding] = useState(!onboarding.accepted())
-
-  // 首次使用总提示（一次性同意，持久化不再弹）
-  useEffect(() => {
-    if (!onboarding.accepted()) setShowOnboarding(true)
-  }, [])
-
-  const acceptOnboarding = () => {
-    onboarding.accept()
-    setShowOnboarding(false)
-    message.success('已记录同意；如需调整可在「授权管理」页查看')
-  }
-
-  // 授权确认（一次授权持久化；未授权则询问，授权后不再提示）
-  const ensureAuthz = (capability: CapabilityKind, purpose: string): boolean => {
-    if (authz.isGranted(capability)) return true
-    setAuthzModal({ capability, purpose })
-    return false
-  }
-  const confirmAuthz = () => {
-    if (authzModal) {
-      authz.grant(authzModal.capability, authzModal.purpose)
-      message.success(`已授权「${authz.label(authzModal.capability)}」，后续不再提示`)
-      setAuthzModal(null)
-    }
-  }
-
-  const run = (values: Record<string, unknown>) => {
-    // 计算前需授权存储能力（写入历史）
-    if (!ensureAuthz('storage', '保存计算记录到本地历史')) return
-    try {
-      const inputs = Object.fromEntries(
-        Object.entries(values).map(([k, v]) => [k, v === undefined || v === '' ? null : Number(v)]),
-      )
-      // 链路：compute -> store -> output
-      const out = evaluateEngine(def.formulas, inputs)
-      setResults(out)
-      store.save(inputs, out)
-      setHistory(store.list())
-      message.success('计算完成')
-      setPage('dashboard')
-    } catch (error) {
-      message.error(error instanceof Error ? error.message : '计算失败，请检查输入')
-    }
-  }
-
-  // 首次使用总提示弹窗（同意后持久化，不再弹出）
-  const renderOnboardingModal = () => (
-    <Modal
-      open={showOnboarding}
-      title={`欢迎使用「${def.name}」`}
-      okText="同意并开始使用"
-      cancelText="暂不使用"
-      onOk={acceptOnboarding}
-      onCancel={acceptOnboarding}
-      closable={false}
-      maskClosable={false}
-    >
-      <Paragraph>
-        <Text strong>关于能力调用与消耗：</Text>
-      </Paragraph>
-      <Paragraph>
-        本工具为整套计算工具（录入 → 校验 → 计算 → 存储 → 输出，联通节点）。
-        使用过程中<b>可能调用其他技能辅助</b>（如 Blueprint 开发流程编排、互联网情报搜索、AI 模型），
-        <b>可能增加调用消耗</b>。
-      </Paragraph>
-      <Paragraph type="secondary">
-        同意后不再提示；后续可在「授权管理」页查看已授权能力并随时撤销。
-      </Paragraph>
-    </Modal>
-  )
-
-  // 授权确认弹窗（用户可见，一次授权）
-  const renderAuthzModal = () => (
-    <Modal
-      open={authzModal !== null}
-      title="能力调用授权"
-      okText="授权"
-      cancelText="拒绝"
-      onOk={confirmAuthz}
-      onCancel={() => setAuthzModal(null)}
-    >
-      {authzModal ? (
-        <Paragraph>
-          本工具将调用 <Text strong>{authz.label(authzModal.capability)}</Text>：
-          <br />{authzModal.purpose}
-          <br />
-          <Text type="secondary">授权一次后永久记住，后续不再提示。可在「授权管理」页撤销。</Text>
-        </Paragraph>
-      ) : null}
-    </Modal>
-  )
-
-  const renderInput = () => (
-    <Card title="录入" style={{ maxWidth: 720, margin: '0 auto' }}>
-      <Form form={form} layout="vertical" onFinish={run}>
-        {def.fields.map((f) => (
-          <Form.Item
-            key={f.key}
-            name={f.key}
-            label={`${f.label}${f.unit ? `（${f.unit}）` : ''}`}
-            rules={[{ required: Boolean(f.required), message: `请输入${f.label}` }]}
-          >
-            {['integer', 'number', 'money', 'percent'].includes(f.type)
-              ? <InputNumber style={{ width: '100%' }} placeholder={`请输入${f.label}`} />
-              : <Input placeholder={`请输入${f.label}`} />}
-          </Form.Item>
-        ))}
-        <Button type="primary" htmlType="submit">计算</Button>
-      </Form>
-    </Card>
-  )
-
-  const renderDashboard = () => (
-    <Card title="指标卡" style={{ maxWidth: 720, margin: '0 auto' }}>
-      <Space direction="vertical" size="middle" style={{ width: '100%' }}>
-        <Button onClick={() => setPage('input')}>返回修改</Button>
-        <Space wrap size="large">
-          {def.formulas.map((f) => (
-            <Statistic key={f.key} title={f.label} value={results[f.key] ?? '—'} precision={2} valueStyle={{ fontSize: 22 }} />
-          ))}
-        </Space>
-        <Text type="secondary">计算基于确定性公式引擎（decimal.js），结果可复现。</Text>
-      </Space>
-    </Card>
-  )
-
-  const renderPipeline = () => (
-    <Card title="工具链路（整套工具 · 联通节点）" style={{ maxWidth: 720, margin: '0 auto' }}>
-      <Space direction="vertical" size="middle" style={{ width: '100%' }}>
-        {pipeline.nodes.map((node) => {
-          const neighbors = nodeNeighbors(pipeline, node.id)
-          const downstream = neighbors?.downstream.map((n) => n.id).join(' → ') || '（终端）'
-          return (
-            <div key={node.id} style={{ border: '1px solid #d9d9d9', borderRadius: 8, padding: 12 }}>
-              <Space>
-                <Tag color="blue">{node.kind}</Tag>
-                <Text strong>{node.label}</Text>
-                <Text type="secondary">→ {downstream}</Text>
-              </Space>
-            </div>
-          )
-        })}
-        <Alert type="info" showIcon message="链路说明" description="工具由联通节点组成：录入 → 校验 → 计算 → 存储 → 输出。改动指标/公式只改引擎定义，链路自动感知；新增自动化节点可扩展。" />
-      </Space>
-    </Card>
-  )
-
-  const renderReport = () => (
-    <Card title="历史记录" style={{ maxWidth: 720, margin: '0 auto' }}>
-      <Table<Record<string, unknown>>
-        rowKey="id"
-        dataSource={history}
-        pagination={{ pageSize: 5 }}
-        columns={[
-          { title: '时间', dataIndex: 'updatedAt', render: (v: string) => new Date(v).toLocaleString() },
-          { title: '输入', dataIndex: 'inputs', render: (v: Record<string, unknown>) => JSON.stringify(v) },
-          { title: '结果', dataIndex: 'results', render: (v: Record<string, unknown>) => JSON.stringify(v) },
-        ]}
-      />
-      <Button danger style={{ marginTop: 16 }} onClick={() => { if (ensureAuthz('storage', '清空本地历史记录')) { store.clear(); setHistory([]) } }}>清空历史</Button>
-    </Card>
-  )
-
-  const renderAuthz = () => (
-    <Card title="授权管理" style={{ maxWidth: 720, margin: '0 auto' }}>
-      <Table<ReturnType<typeof authz.list>[number]>
-        rowKey="capability"
-        dataSource={authz.list()}
-        pagination={false}
-        columns={[
-          { title: '能力', dataIndex: 'capability', render: (v: CapabilityKind) => authz.label(v) },
-          { title: '状态', dataIndex: 'granted', render: (v: boolean) => (v ? <Tag color="green">已授权</Tag> : <Tag>未授权</Tag>) },
-          { title: '授权时间', dataIndex: 'grantedAt', render: (v: string) => new Date(v).toLocaleString() },
-          { title: '操作', render: (_, r) => <Button size="small" danger onClick={() => { authz.revoke(r.capability); setPage('authz') }}>撤销</Button> },
-        ]}
-      />
-    </Card>
-  )
-
-  return (
-    <div style={{ maxWidth: 960, margin: '0 auto', padding: '32px 16px' }}>
-      <Title level={2} style={{ textAlign: 'center' }}>{def.name}</Title>
-      <Paragraph type="secondary" style={{ textAlign: 'center' }}>
-        引擎 ID：{def.engineId} · 整套工具（{pipeline.nodes.length} 个联通节点）· 配置驱动
-      </Paragraph>
-      <div style={{ textAlign: 'center', marginBottom: 24 }}>
-        <Segmented
-          value={page}
-          onChange={(v) => setPage(String(v))}
-          options={[
-            { label: '录入', value: 'input' },
-            { label: '指标卡', value: 'dashboard' },
-            { label: '链路', value: 'pipeline' },
-            { label: '报告', value: 'report' },
-            { label: '授权', value: 'authz' },
-          ]}
-        />
-      </div>
-      {page === 'input' && renderInput()}
-      {page === 'dashboard' && renderDashboard()}
-      {page === 'pipeline' && renderPipeline()}
-      {page === 'report' && renderReport()}
-      {page === 'authz' && renderAuthz()}
-      {renderOnboardingModal()}
-      {renderAuthzModal()}
-    </div>
-  )
-}

package/skills/calctool/platform-template/src/authz.ts

@@ -1,103 +0,0 @@
-// calctool 授权管理：调用外部能力前的透明授权 + 一次授权持久化
-// 原则：调用任何外部能力（blueprint / 网络搜索 / 模型 / 外部 API）前必须告知用户，
-// 用户授权一次后记住（localStorage 持久化），后续不再重复提示。
-
-export type CapabilityKind =
-  | 'blueprint'      // Blueprint 开发流程编排
-  | 'web-search'     // 情报蜂群网络搜索
-  | 'model'          // AI 模型调用
-  | 'external-api'   // 外部 API（数据源/报表导出等）
-  | 'storage'        // 本地/远端数据存储
-  | 'automation'     // 自动化（定时/触发器）
-
-export type Authorization = {
-  capability: CapabilityKind
-  granted: boolean
-  grantedAt: string
-  note?: string
-}
-
-const AUTH_KEY = 'calctool:authz:v1'
-const ONBOARDING_KEY = 'calctool:onboarding:v1'
-const CAPABILITY_LABELS: Record<CapabilityKind, string> = {
-  'blueprint': 'Blueprint 开发流程编排',
-  'web-search': '互联网情报搜索',
-  'model': 'AI 模型调用',
-  'external-api': '外部 API 数据源',
-  'storage': '数据存储',
-  'automation': '自动化任务',
-}
-
-/** 首次使用总提示：告知工具可能调用其他技能/增加消耗，同意后持久化不再弹 */
-export class OnboardingConsent {
-  constructor(private readonly engineId: string) {}
-
-  private key(): string { return `${ONBOARDING_KEY}:${this.engineId}` }
-
-  /** 是否已同意首次使用提示 */
-  accepted(): boolean {
-    if (typeof localStorage === 'undefined') return true
-    return localStorage.getItem(this.key()) === 'accepted'
-  }
-
-  /** 同意并持久化（一次同意，不再提示） */
-  accept(): void {
-    if (typeof localStorage !== 'undefined') {
-      localStorage.setItem(this.key(), 'accepted')
-    }
-  }
-
-  /** 首次使用提示文案（可自定义，默认含消耗提示） */
-  notice(extra?: string): string {
-    return extra ?? '本工具为整套计算工具，可能调用其他技能辅助使用（如 Blueprint 开发流程编排、互联网情报搜索、AI 模型），可能增加调用消耗。同意后不再提示，可随时在「授权管理」页查看与撤销。'
-  }
-}
-
-export class AuthzManager {
-  private store: Record<string, Authorization> = {}
-
-  constructor() {
-    if (typeof localStorage === 'undefined') return
-    try {
-      this.store = JSON.parse(localStorage.getItem(AUTH_KEY) ?? '{}')
-    } catch { this.store = {} }
-  }
-
-  /** 是否已授权某能力 */
-  isGranted(capability: CapabilityKind): boolean {
-    return this.store[capability]?.granted === true
-  }
-
-  /** 需要授权时的提示文案 */
-  promptFor(capability: CapabilityKind, purpose: string): string {
-    return `调用「${CAPABILITY_LABELS[capability]}」：${purpose}。是否授权？授权一次后不再提示。`
-  }
-
-  /** 记录授权（一次授权，持久化） */
-  grant(capability: CapabilityKind, note?: string): void {
-    this.store[capability] = {
-      capability, granted: true, grantedAt: new Date().toISOString(), note,
-    }
-    if (typeof localStorage !== 'undefined') {
-      localStorage.setItem(AUTH_KEY, JSON.stringify(this.store))
-    }
-  }
-
-  /** 撤销授权 */
-  revoke(capability: CapabilityKind): void {
-    delete this.store[capability]
-    if (typeof localStorage !== 'undefined') {
-      localStorage.setItem(AUTH_KEY, JSON.stringify(this.store))
-    }
-  }
-
-  list(): Authorization[] {
-    return Object.values(this.store)
-  }
-
-  static label(capability: CapabilityKind): string {
-    return CAPABILITY_LABELS[capability]
-  }
-}
-
-export const authz = new AuthzManager()

package/skills/calctool/platform-template/src/engine/evaluate.ts

@@ -1,114 +0,0 @@
-// calctool 公式引擎：JSON AST + decimal.js 确定性求值
-// 公式 DSL 规范见 references/formula-dsl.md
-import Decimal from 'decimal.js'
-
-export type FormulaNode =
-  | { ref: string }
-  | { lit: string | number }
-  | { op: string; args: FormulaNode[] }
-
-export type CalcError =
-  | { code: 'DIV_ZERO'; nodeId: string }
-  | { code: 'MISSING_INPUT'; fieldId: string }
-  | { code: 'NON_FINITE'; nodeId: string }
-
-export type EngineValues = Record<string, string | number | null>
-
-/** 安全除法：除数为 0 用 fallback（默认 0），与 div 报错区分 */
-function safeDiv(a: Decimal, b: Decimal, fallback = '0'): Decimal {
-  if (b.isZero()) return new Decimal(fallback)
-  return a.div(b)
-}
-
-/** 求值一个公式 AST 节点（纯函数，无副作用）
- * 节点形态：{ ref: 'field' } 引用 / { lit: 1 } 字面量 / { op, args } 运算
- */
-export function evaluate(node: FormulaNode, values: EngineValues): Decimal {
-  // 引用节点（无 op，只有 ref）
-  if ('ref' in node && node.ref !== undefined) {
-    const raw = values[node.ref]
-    if (raw === null || raw === undefined || raw === '') {
-      throw { code: 'MISSING_INPUT', fieldId: node.ref } as CalcError
-    }
-    return new Decimal(String(raw))
-  }
-  // 字面量节点（无 op，只有 lit）
-  if ('lit' in node && node.lit !== undefined) {
-    return new Decimal(String(node.lit ?? 0))
-  }
-  switch (node.op) {
-    case 'add':
-      return node.args.reduce((acc, arg) => acc.plus(evaluate(arg, values)), new Decimal(0))
-    case 'sub': {
-      const [a, b] = node.args
-      return evaluate(a, values).minus(evaluate(b, values))
-    }
-    case 'mul':
-      return node.args.reduce((acc, arg) => acc.times(evaluate(arg, values)), new Decimal(1))
-    case 'div': {
-      const [a, b] = node.args
-      const divisor = evaluate(b, values)
-      if (divisor.isZero()) throw { code: 'DIV_ZERO', nodeId: 'div' } as CalcError
-      return evaluate(a, values).div(divisor)
-    }
-    case 'safeDivide': {
-      const [a, b] = node.args
-      return safeDiv(evaluate(a, values), evaluate(b, values))
-    }
-    case 'percentOf': {
-      const [a, b] = node.args
-      return evaluate(a, values).div(evaluate(b, values)).times(100)
-    }
-    case 'round': {
-      const [a] = node.args
-      return evaluate(a, values).toDecimalPlaces(2)
-    }
-    case 'if': {
-      const [cond, thenNode, elseNode] = node.args
-      const v = evaluate(cond, values)
-      return v.isZero() ? evaluate(elseNode, values) : evaluate(thenNode, values)
-    }
-    default:
-      throw new Error(`Unsupported operator: ${node.op}`)
-  }
-}
-
-/** 从 AST 提取引用的字段 key（依赖图构建用） */
-export function extractRefs(node: FormulaNode | undefined): string[] {
-  if (!node) return []
-  if ('ref' in node && node.ref !== undefined) return [node.ref]
-  if ('lit' in node && node.lit !== undefined) return []
-  return (node.args ?? []).flatMap(extractRefs)
-}
-
-/** 按公式定义计算全部结果（含跨公式引用，安全除零） */
-export function evaluateEngine(
-  formulas: Array<{ key: string; expression: FormulaNode }>,
-  inputs: EngineValues,
-): Record<string, string> {
-  const values: EngineValues = { ...inputs }
-  const results: Record<string, string> = {}
-  const visited = new Set<string>()
-  const stack: string[] = []
-
-  const compute = (key: string) => {
-    if (visited.has(key)) return
-    if (stack.includes(key)) throw new Error(`Cycle detected: ${[...stack, key].join(' → ')}`)
-    const formula = formulas.find((f) => f.key === key)
-    if (!formula) return
-    stack.push(key)
-    const refs = extractRefs(formula.expression)
-    for (const ref of refs) {
-      if (formulas.some((f) => f.key === ref)) compute(ref) // 跨公式引用先算
-    }
-    const result = evaluate(formula.expression, values)
-    const str = result.toFixed(4).replace(/\.?0+$/, '')
-    values[key] = str
-    results[key] = str
-    stack.pop()
-    visited.add(key)
-  }
-
-  for (const f of formulas) compute(f.key)
-  return results
-}