cli-calctool 0.3.4 → 1.0.1

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
-}

package/skills/calctool/platform-template/src/engine-definition.json

@@ -1,195 +0,0 @@
-{
-  "engineId": "ecommerce-ops-dashboard",
-  "name": "电商运营仪表盘",
-  "semanticVersion": "1.0.0",
-  "category": "ecommerce",
-  "decimalPolicy": "decimal-string",
-  "fields": [
-    {
-      "key": "visitors",
-      "label": "访客数",
-      "type": "integer",
-      "unit": "人",
-      "required": true
-    },
-    {
-      "key": "orders",
-      "label": "订单数",
-      "type": "integer",
-      "unit": "单",
-      "required": true
-    },
-    {
-      "key": "gmv",
-      "label": "GMV",
-      "type": "money",
-      "unit": "CNY",
-      "required": true
-    },
-    {
-      "key": "adSpend",
-      "label": "广告费",
-      "type": "money",
-      "unit": "CNY",
-      "required": true
-    },
-    {
-      "key": "customRate",
-      "label": "自定义转化率修正",
-      "type": "percent",
-      "unit": "%"
-    }
-  ],
-  "formulas": [
-    {
-      "key": "conversionRate",
-      "label": "转化率",
-      "expression": {
-        "op": "safeDivide",
-        "args": [
-          {
-            "ref": "orders"
-          },
-          {
-            "ref": "visitors"
-          }
-        ]
-      }
-    },
-    {
-      "key": "aov",
-      "label": "客单价",
-      "expression": {
-        "op": "safeDivide",
-        "args": [
-          {
-            "ref": "gmv"
-          },
-          {
-            "ref": "orders"
-          }
-        ]
-      }
-    },
-    {
-      "key": "roas",
-      "label": "ROAS",
-      "expression": {
-        "op": "safeDivide",
-        "args": [
-          {
-            "ref": "gmv"
-          },
-          {
-            "ref": "adSpend"
-          }
-        ]
-      }
-    },
-    {
-      "key": "gmvPerVisitor",
-      "label": "访客价值",
-      "expression": {
-        "op": "safeDivide",
-        "args": [
-          {
-            "ref": "gmv"
-          },
-          {
-            "ref": "visitors"
-          }
-        ]
-      }
-    }
-  ],
-  "rules": [],
-  "views": [],
-  "testSuites": [
-    {
-      "name": "基准样例",
-      "inputs": {
-        "visitors": 10000,
-        "orders": 300,
-        "gmv": 50000,
-        "adSpend": 12000
-      },
-      "expect": {
-        "conversionRate": "3",
-        "aov": "166.6667",
-        "roas": "4.1667"
-      }
-    }
-  ],
-  "pipeline": {
-    "engineId": "ecommerce-ops-dashboard",
-    "nodes": [
-      {
-        "id": "input",
-        "kind": "input",
-        "label": "录入/导入",
-        "inputs": [],
-        "outputs": [
-          "validate"
-        ]
-      },
-      {
-        "id": "validate",
-        "kind": "validate",
-        "label": "数据校验",
-        "inputs": [
-          "input"
-        ],
-        "outputs": [
-          "compute"
-        ]
-      },
-      {
-        "id": "compute",
-        "kind": "compute",
-        "label": "确定性计算",
-        "inputs": [
-          "validate"
-        ],
-        "outputs": [
-          "store",
-          "output"
-        ]
-      },
-      {
-        "id": "store",
-        "kind": "store",
-        "label": "数据存储",
-        "inputs": [
-          "compute"
-        ],
-        "outputs": [
-          "output"
-        ]
-      },
-      {
-        "id": "output",
-        "kind": "output",
-        "label": "指标卡/报告",
-        "inputs": [
-          "compute",
-          "store"
-        ],
-        "outputs": []
-      },
-      {
-        "id": "automate",
-        "kind": "automate",
-        "label": "自动化（可选）",
-        "inputs": [
-          "store"
-        ],
-        "outputs": [
-          "output"
-        ],
-        "config": {
-          "enabled": false
-        }
-      }
-    ]
-  }
-}

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

@@ -1,13 +0,0 @@
-import React from 'react'
-import ReactDOM from 'react-dom/client'
-import { ConfigProvider } from 'antd'
-import zhCN from 'antd/locale/zh_CN'
-import App from './App'
-
-ReactDOM.createRoot(document.getElementById('root')!).render(
-  <React.StrictMode>
-    <ConfigProvider locale={zhCN}>
-      <App />
-    </ConfigProvider>
-  </React.StrictMode>,
-)