weaver-e9-assistant-cli 1.1.5 → 1.1.12

package/dist/client.js

@@ -171,7 +171,7 @@ export class E9Api {
             }
         }
         if (!er)
-            throw new Error(`请求失败：${method} ${url}。服务器可能不可达或网络不通。`);
+            throw new Error(`请求失败：${method} ${url}。服务器可能不可达或网络不通；若该服务器仅支持 TLS 1.3，请设置环境变量 E9_TLS_MAX=1.3 后重试。`);
         return er;
     }
     /**

package/dist/cube.js

@@ -31,6 +31,7 @@ import { createApiFromProfile, e9Request } from './client.js';
 import { endpointFor, profileNameFromBaseUrl } from './config.js';
 import { pickByPaths, stripHtml, extractColumns, extractRows, extractTotal } from './parse.js';
 import { sleep } from './util.js';
+import { cacheGet, cacheSet } from './cache-store.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
@@ -1399,47 +1400,24 @@ export function cubeCachePath(cfg) {
     const envkey = profileNameFromBaseUrl(baseUrl);
     return path.join(os.homedir(), '.e9', `cube_catalog_${envkey}.json`);
 }
-/** 读缓存；返回 {entries, fetchedAt, source, baseUrl} 或 null。 */
+/** 读缓存；返回 {entries, fetchedAt, source, baseUrl} 或 null（含 TTL 检查）。 */
 function readCubeCache(cfg) {
-    const p = cubeCachePath(cfg);
-    try {
-        if (!fs.existsSync(p))
-            return null;
-        const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
-        if (!raw || !Array.isArray(raw.entries))
-            return null;
-        return raw;
-    }
-    catch {
-        return null;
-    }
+    const TTL_MS = CUBE_CATALOG_TTL_DAYS * 24 * 3600 * 1000;
+    const raw = cacheGet(cubeCachePath(cfg), TTL_MS);
+    if (!raw || !Array.isArray(raw.entries)) return null;
+    return raw;
 }
 /** 写缓存（全量预热）。写入失败不阻断查询。 */
 function writeCubeCache(cfg, entries, source) {
-    const p = cubeCachePath(cfg);
-    try {
-        fs.mkdirSync(path.dirname(p), { recursive: true });
-        const baseUrl = endpointFor(cfg).baseUrl.replace(/\/+$/, '');
-        const raw = {
-            envkey: profileNameFromBaseUrl(baseUrl),
-            baseUrl,
-            fetchedAt: new Date().toISOString(),
-            source,
-            count: entries.length,
-            entries,
-        };
-        fs.writeFileSync(p, JSON.stringify(raw, null, 2) + '\n', 'utf8');
-    }
-    catch (e) {
-        console.error('[cube cache] 写入失败:', e.message);
-    }
-}
-/** 缓存是否过期（超 TTL 或无 fetchedAt）。 */
-function isCacheStale(cache) {
-    if (!cache || !cache.fetchedAt)
-        return true;
-    const ageMs = Date.now() - new Date(cache.fetchedAt).getTime();
-    return ageMs > CUBE_CATALOG_TTL_DAYS * 24 * 3600 * 1000;
+    const baseUrl = endpointFor(cfg).baseUrl.replace(/\/+$/, '');
+    cacheSet(cubeCachePath(cfg), {
+        envkey: profileNameFromBaseUrl(baseUrl),
+        baseUrl,
+        fetchedAt: new Date().toISOString(),
+        source,
+        count: entries.length,
+        entries,
+    });
 }
 /**
  * 路径1：调目录接口拉全量台账。
@@ -1640,7 +1618,7 @@ export async function listCubeMenus(cfg, opts = {}) {
     // 1. 缓存命中
     if (!opts.refresh && !opts.noCache) {
         const cache = readCubeCache(cfg);
-        if (cache && !isCacheStale(cache) && Array.isArray(cache.entries) && cache.entries.length > 0) {
+        if (cache && Array.isArray(cache.entries) && cache.entries.length > 0) {
             return { entries: cache.entries, source: cache.source || 'catalog', count: cache.entries.length, fetchedAt: cache.fetchedAt, fromCache: true };
         }
     }

package/dist/formula.js

@@ -0,0 +1,246 @@
+/**
+ * 流程表单公式（loadForm.linkageCfg.formulaCfg）本地计算。
+ *
+ * E9 的简单公式由前端 formulaNew_wev8.js 在浏览器本地执行（不是服务端接口），
+ * 表达式形如 `[main.27792]*[main.27793]`，目标主表/明细字段。
+ * 本模块支持四则运算 + 单元格引用；遇到函数（SUM/IF/...）、跨表明细引用等
+ * 未实现语法时跳过并在 skipped 里说明，绝不猜结果。
+ */
+
+function parseMaybeJson(value, fallback) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return parsed ?? fallback;
+        }
+        catch {
+            return fallback;
+        }
+    }
+    return fallback;
+}
+
+function toNumber(value) {
+    if (value === undefined || value === null || String(value).trim() === '')
+        return 0;
+    const n = Number(String(value).replace(/,/g, '').trim());
+    if (!Number.isFinite(n))
+        throw new Error(`非数字值: ${value}`);
+    return n;
+}
+
+function formatNumber(n) {
+    if (!Number.isFinite(n))
+        throw new Error('计算结果不是有效数字');
+    // 避免 0.1+0.2 之类的浮点噪声；业务金额通常 2 位，保留 10 位足够
+    return String(Number(n.toFixed(10)));
+}
+
+function getValue(obj, id) {
+    if (!obj)
+        return undefined;
+    const fieldKey = `field${id}`;
+    if (Object.prototype.hasOwnProperty.call(obj, fieldKey))
+        return obj[fieldKey];
+    return obj[id];
+}
+
+function setValue(obj, id, value) {
+    if (!obj)
+        return;
+    const fieldKey = `field${id}`;
+    // 保持调用方原有键风格：对象里已有 field<id> 键时继续用 field<id>，否则用纯 id
+    const usesFieldPrefix = Object.keys(obj).some((k) => /^field\d+/.test(k));
+    if (usesFieldPrefix || Object.prototype.hasOwnProperty.call(obj, fieldKey))
+        obj[fieldKey] = value;
+    else
+        obj[id] = value;
+}
+
+function tokenize(expression) {
+    const s = String(expression)
+        .replace(/×/g, '*').replace(/÷/g, '/')
+        .replace(/＋/g, '+').replace(/－/g, '-');
+    const tokens = [];
+    for (let i = 0; i < s.length;) {
+        const c = s[i];
+        if (/\s/.test(c)) {
+            i++;
+            continue;
+        }
+        if (c === '[') {
+            const end = s.indexOf(']', i);
+            if (end < 0)
+                throw new Error('公式缺少 ]');
+            tokens.push({ t: 'ref', v: s.slice(i + 1, end).trim() });
+            i = end + 1;
+            continue;
+        }
+        if (/[0-9.]/.test(c)) {
+            let j = i;
+            while (j < s.length && /[0-9.]/.test(s[j]))
+                j++;
+            tokens.push({ t: 'num', v: s.slice(i, j) });
+            i = j;
+            continue;
+        }
+        if ('+-*/()'.includes(c)) {
+            tokens.push({ t: 'op', v: c });
+            i++;
+            continue;
+        }
+        throw new Error(`不支持的公式字符: ${c}`);
+    }
+    return tokens;
+}
+
+function evaluate(expression, { resolve }) {
+    const tokens = tokenize(expression);
+    let pos = 0;
+    const peek = () => tokens[pos];
+    const eat = (v) => {
+        if (!peek() || peek().v !== v)
+            throw new Error(`公式语法错误：期望 ${v}`);
+        pos++;
+    };
+    const parseExpression = () => {
+        let value = parseTerm();
+        while (peek() && (peek().v === '+' || peek().v === '-')) {
+            const op = tokens[pos++].v;
+            const right = parseTerm();
+            value = op === '+' ? value + right : value - right;
+        }
+        return value;
+    };
+    const parseTerm = () => {
+        let value = parseFactor();
+        while (peek() && (peek().v === '*' || peek().v === '/')) {
+            const op = tokens[pos++].v;
+            const right = parseFactor();
+            if (op === '/' && right === 0)
+                throw new Error('除数为 0');
+            value = op === '*' ? value * right : value / right;
+        }
+        return value;
+    };
+    const parseFactor = () => {
+        const token = peek();
+        if (!token)
+            throw new Error('公式不完整');
+        if (token.t === 'op' && token.v === '-') {
+            pos++;
+            return -parseFactor();
+        }
+        if (token.t === 'op' && token.v === '(') {
+            pos++;
+            const value = parseExpression();
+            eat(')');
+            return value;
+        }
+        if (token.t === 'num') {
+            pos++;
+            return Number(token.v);
+        }
+        if (token.t === 'ref') {
+            pos++;
+            return resolve(token.v);
+        }
+        throw new Error(`公式语法错误：${token.v}`);
+    };
+    const value = parseExpression();
+    if (pos !== tokens.length)
+        throw new Error('公式语法错误：存在多余内容');
+    return value;
+}
+
+/**
+ * 执行 formulaCfg 里的公式（主表 + 明细）。
+ * values: 主表字段值（key 可为 "<id>" 或 "field<id>"）
+ * details: [{index, rows:[{<fieldId>: value}]}]
+ * 返回 { applied:[{dest, formula, value, table, row}], skipped:[{dest, formula, reason}] }
+ */
+export function applyFormulas(formData, values, details = []) {
+    const cfg = formData?.raw?.linkageCfg?.formulaCfg ?? formData?.linkageCfg?.formulaCfg;
+    const formulas = Array.isArray(cfg?.formulas) ? cfg.formulas : [];
+    const appliedMap = new Map();
+    const skipped = [];
+    if (formulas.length === 0)
+        return { applied: [], skipped };
+
+    // 公式可能互相引用，最多迭代 3 轮直到稳定
+    for (let pass = 0; pass < 3; pass++) {
+        let changed = false;
+        for (const f of formulas) {
+            const destList = parseMaybeJson(f.destfield, []);
+            const textList = parseMaybeJson(f.formulatxt, []);
+            const dests = Array.isArray(destList) ? destList : [destList];
+            const texts = Array.isArray(textList) ? textList : [textList];
+            const count = Math.max(dests.length, texts.length);
+            for (let i = 0; i < count; i++) {
+                const dest = String(dests[i] ?? '').trim();
+                const formula = String(texts[i] ?? '').trim();
+                if (!dest || !formula)
+                    continue;
+                const dot = dest.indexOf('.');
+                if (dot < 0)
+                    continue;
+                const table = dest.slice(0, dot);
+                const destId = dest.slice(dot + 1);
+                if (!destId)
+                    continue;
+                let rows;
+                if (table === 'main') {
+                    rows = [null];
+                }
+                else if (table.startsWith('detail_')) {
+                    const detailIndex = Number(table.slice('detail_'.length)) - 1;
+                    rows = details.find((d) => Number(d.index) === detailIndex)?.rows ?? [];
+                }
+                else {
+                    skipped.push({ dest, formula, reason: `不支持的表格: ${table}` });
+                    continue;
+                }
+                for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+                    const row = rows[rowIndex];
+                    try {
+                        const result = formatNumber(evaluate(formula, {
+                            resolve: (ref) => {
+                                const refDot = ref.indexOf('.');
+                                if (refDot < 0)
+                                    throw new Error(`不支持的引用: [${ref}]`);
+                                const refTable = ref.slice(0, refDot);
+                                const refId = ref.slice(refDot + 1);
+                                if (refTable === 'main')
+                                    return toNumber(getValue(values, refId));
+                                if (refTable.startsWith('detail_')) {
+                                    if (!row || refTable !== table)
+                                        throw new Error(`跨表引用暂不支持: [${ref}]`);
+                                    return toNumber(getValue(row, refId));
+                                }
+                                throw new Error(`不支持的引用: [${ref}]`);
+                            },
+                        }));
+                        const oldValue = table === 'main' ? getValue(values, destId) : getValue(row, destId);
+                        if (String(oldValue ?? '') !== result) {
+                            if (table === 'main')
+                                setValue(values, destId, result);
+                            else
+                                setValue(row, destId, result);
+                            changed = true;
+                        }
+                        const key = `${table}.${destId}#${table === 'main' ? -1 : rowIndex}`;
+                        appliedMap.set(key, { dest, formula, value: result, table, row: table === 'main' ? -1 : rowIndex });
+                    }
+                    catch (e) {
+                        skipped.push({ dest, formula, reason: e?.message ?? String(e) });
+                    }
+                }
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return { applied: [...appliedMap.values()], skipped };
+}

package/dist/hrm.js

@@ -20,6 +20,10 @@
  */
 import { createApiFromProfile } from './client.js';
 import { extractDataKey, extractRows, extractColumns, extractTotal, pickByPaths, stripHtml } from './parse.js';
+import { mapLimit } from './util.js';
+
+/** 组织树并发上限：兄弟部门/子树并行拉取，避免逐节点排队；同时防打满服务端。 */
+const ORG_TREE_CONCURRENCY = 4;
 
 // ─── Tab 定义 ────────────────────────────────────────────
 
@@ -394,19 +398,24 @@ export async function findHrmOrgNode(cfg, keyword, { matchType = null, maxDepth
     if (!kw)
         return null;
     const top = await getHrmSearchTree(cfg, { type: '0', id: '0', isVirtual: '0' });
-    const queue = top.datas.map((d) => ({ ...d, depth: 0 }));
-    while (queue.length) {
-        const node = queue.shift();
-        if (node.name === kw && (!matchType || node.type === matchType))
-            return node;
-        if (!node.isParent || node.depth >= maxDepth)
-            continue;
-        try {
-            const children = await getHrmSearchTree(cfg, { type: node.type, id: node.id, isVirtual: node.isVirtual });
-            for (const c of children.datas)
-                queue.push({ ...c, depth: node.depth + 1 });
-        }
-        catch { /* 子树拉取失败跳过该分支（同名节点仍可能在后继队列命中） */ }
+    // 逐层 BFS：同层各节点互不依赖，并发受限拉取子节点；匹配顺序仍按层序。
+    let level = top.datas.map((d) => ({ ...d, depth: 0 }));
+    while (level.length) {
+        const hit = level.find((node) => node.name === kw && (!matchType || node.type === matchType));
+        if (hit)
+            return hit;
+        const parents = level.filter((node) => node.isParent && node.depth < maxDepth);
+        if (!parents.length)
+            break;
+        const children = await mapLimit(parents, ORG_TREE_CONCURRENCY, async (node) => {
+            try {
+                return await getHrmSearchTree(cfg, { type: node.type, id: node.id, isVirtual: node.isVirtual });
+            }
+            catch {
+                return null; // 子树拉取失败跳过该分支（同名节点仍可能在其他分支命中）
+            }
+        });
+        level = children.flatMap((r, i) => r ? r.datas.map((c) => ({ ...c, depth: parents[i].depth + 1 })) : []);
     }
     return null;
 }
@@ -423,19 +432,24 @@ export async function expandHrmOrgTree(cfg, { type = '0', id = '0', depth = 1, m
         if (levels < 1)
             return [];
         const r = await getHrmSearchTree(cfg, { type: t, id: i });
-        const out = [];
+        // 先按数组顺序占用节点预算，再并发展开各子树——输出顺序与串行版一致。
+        const allowed = [];
         for (const n of r.datas) {
             if (count >= maxNodes) {
                 truncated = true;
                 break;
             }
             count++;
-            const node = { id: n.id, name: n.name, type: n.type, isParent: n.isParent, children: [] };
-            if (n.isParent && levels > 1)
-                node.children = await walk(n.type, n.id, levels - 1);
-            out.push(node);
+            allowed.push(n);
         }
-        return out;
+        const children = await mapLimit(allowed, ORG_TREE_CONCURRENCY, async (n) => {
+            if (n.isParent && levels > 1)
+                return walk(n.type, n.id, levels - 1);
+            return [];
+        });
+        return allowed.map((n, idx) => ({
+            id: n.id, name: n.name, type: n.type, isParent: n.isParent, children: children[idx],
+        }));
     }
     const nodes = await walk(type, id, depth);
     return { nodes, total: count, truncated };