Upload LittleWhiteBox extension
This commit is contained in:
RT15548
746
modules/variables/state2/executor.js
Normal file
746
modules/variables/state2/executor.js
Normal file
@@ -0,0 +1,746 @@
|
||||
import { getContext } from '../../../../../../extensions.js';
|
||||
import { getLocalVariable, setLocalVariable } from '../../../../../../variables.js';
|
||||
import { extractStateBlocks, computeStateSignature, parseStateBlock } from './parser.js';
|
||||
import { generateSemantic } from './semantic.js';
|
||||
import { validate, setRule, loadRulesFromMeta, saveRulesToMeta } from './guard.js';
|
||||
|
||||
/**
|
||||
* =========================
|
||||
* Path / JSON helpers
|
||||
* =========================
|
||||
*/
|
||||
function splitPath(path) {
|
||||
const s = String(path || '');
|
||||
const segs = [];
|
||||
let buf = '';
|
||||
let i = 0;
|
||||
|
||||
while (i < s.length) {
|
||||
const ch = s[i];
|
||||
if (ch === '.') {
|
||||
if (buf) { segs.push(/^\d+$/.test(buf) ? Number(buf) : buf); buf = ''; }
|
||||
i++;
|
||||
} else if (ch === '[') {
|
||||
if (buf) { segs.push(/^\d+$/.test(buf) ? Number(buf) : buf); buf = ''; }
|
||||
i++;
|
||||
let val = '';
|
||||
if (s[i] === '"' || s[i] === "'") {
|
||||
const q = s[i++];
|
||||
while (i < s.length && s[i] !== q) val += s[i++];
|
||||
i++;
|
||||
} else {
|
||||
while (i < s.length && s[i] !== ']') val += s[i++];
|
||||
}
|
||||
if (s[i] === ']') i++;
|
||||
segs.push(/^\d+$/.test(val.trim()) ? Number(val.trim()) : val.trim());
|
||||
} else {
|
||||
buf += ch;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (buf) segs.push(/^\d+$/.test(buf) ? Number(buf) : buf);
|
||||
return segs;
|
||||
}
|
||||
|
||||
function normalizePath(path) {
|
||||
return splitPath(path).map(String).join('.');
|
||||
}
|
||||
|
||||
function safeJSON(v) {
|
||||
try { return JSON.stringify(v); } catch { return ''; }
|
||||
}
|
||||
|
||||
function safeParse(s) {
|
||||
if (s == null || s === '') return undefined;
|
||||
if (typeof s !== 'string') return s;
|
||||
const t = s.trim();
|
||||
if (!t) return undefined;
|
||||
if (t[0] === '{' || t[0] === '[') {
|
||||
try { return JSON.parse(t); } catch { return s; }
|
||||
}
|
||||
if (/^-?\d+(?:\.\d+)?$/.test(t)) return Number(t);
|
||||
if (t === 'true') return true;
|
||||
if (t === 'false') return false;
|
||||
return s;
|
||||
}
|
||||
|
||||
function deepClone(obj) {
|
||||
try { return structuredClone(obj); } catch {
|
||||
try { return JSON.parse(JSON.stringify(obj)); } catch { return obj; }
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* =========================
|
||||
* Variable getters/setters (local vars)
|
||||
* =========================
|
||||
*/
|
||||
function getVar(path) {
|
||||
const segs = splitPath(path);
|
||||
if (!segs.length) return undefined;
|
||||
|
||||
const rootRaw = getLocalVariable(String(segs[0]));
|
||||
if (segs.length === 1) return safeParse(rootRaw);
|
||||
|
||||
let obj = safeParse(rootRaw);
|
||||
if (!obj || typeof obj !== 'object') return undefined;
|
||||
|
||||
for (let i = 1; i < segs.length; i++) {
|
||||
obj = obj?.[segs[i]];
|
||||
if (obj === undefined) return undefined;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
function setVar(path, value) {
|
||||
const segs = splitPath(path);
|
||||
if (!segs.length) return;
|
||||
|
||||
const rootName = String(segs[0]);
|
||||
|
||||
if (segs.length === 1) {
|
||||
const toStore = (value && typeof value === 'object') ? safeJSON(value) : String(value ?? '');
|
||||
setLocalVariable(rootName, toStore);
|
||||
return;
|
||||
}
|
||||
|
||||
let root = safeParse(getLocalVariable(rootName));
|
||||
if (!root || typeof root !== 'object') {
|
||||
root = typeof segs[1] === 'number' ? [] : {};
|
||||
}
|
||||
|
||||
let cur = root;
|
||||
for (let i = 1; i < segs.length - 1; i++) {
|
||||
const key = segs[i];
|
||||
const nextKey = segs[i + 1];
|
||||
if (cur[key] == null || typeof cur[key] !== 'object') {
|
||||
cur[key] = typeof nextKey === 'number' ? [] : {};
|
||||
}
|
||||
cur = cur[key];
|
||||
}
|
||||
cur[segs[segs.length - 1]] = value;
|
||||
|
||||
setLocalVariable(rootName, safeJSON(root));
|
||||
}
|
||||
|
||||
function delVar(path) {
|
||||
const segs = splitPath(path);
|
||||
if (!segs.length) return;
|
||||
|
||||
const rootName = String(segs[0]);
|
||||
|
||||
if (segs.length === 1) {
|
||||
setLocalVariable(rootName, '');
|
||||
return;
|
||||
}
|
||||
|
||||
let root = safeParse(getLocalVariable(rootName));
|
||||
if (!root || typeof root !== 'object') return;
|
||||
|
||||
let cur = root;
|
||||
for (let i = 1; i < segs.length - 1; i++) {
|
||||
cur = cur?.[segs[i]];
|
||||
if (!cur || typeof cur !== 'object') return;
|
||||
}
|
||||
|
||||
const lastKey = segs[segs.length - 1];
|
||||
if (Array.isArray(cur) && typeof lastKey === 'number') {
|
||||
cur.splice(lastKey, 1);
|
||||
} else {
|
||||
delete cur[lastKey];
|
||||
}
|
||||
|
||||
setLocalVariable(rootName, safeJSON(root));
|
||||
}
|
||||
|
||||
function pushVar(path, value) {
|
||||
const segs = splitPath(path);
|
||||
if (!segs.length) return { ok: false, reason: 'invalid-path' };
|
||||
|
||||
const rootName = String(segs[0]);
|
||||
|
||||
if (segs.length === 1) {
|
||||
let arr = safeParse(getLocalVariable(rootName));
|
||||
// ✅ 类型检查：必须是数组或不存在
|
||||
if (arr !== undefined && !Array.isArray(arr)) {
|
||||
return { ok: false, reason: 'not-array' };
|
||||
}
|
||||
if (!Array.isArray(arr)) arr = [];
|
||||
const items = Array.isArray(value) ? value : [value];
|
||||
arr.push(...items);
|
||||
setLocalVariable(rootName, safeJSON(arr));
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
let root = safeParse(getLocalVariable(rootName));
|
||||
if (!root || typeof root !== 'object') {
|
||||
root = typeof segs[1] === 'number' ? [] : {};
|
||||
}
|
||||
|
||||
let cur = root;
|
||||
for (let i = 1; i < segs.length - 1; i++) {
|
||||
const key = segs[i];
|
||||
const nextKey = segs[i + 1];
|
||||
if (cur[key] == null || typeof cur[key] !== 'object') {
|
||||
cur[key] = typeof nextKey === 'number' ? [] : {};
|
||||
}
|
||||
cur = cur[key];
|
||||
}
|
||||
|
||||
const lastKey = segs[segs.length - 1];
|
||||
let arr = cur[lastKey];
|
||||
|
||||
// ✅ 类型检查：必须是数组或不存在
|
||||
if (arr !== undefined && !Array.isArray(arr)) {
|
||||
return { ok: false, reason: 'not-array' };
|
||||
}
|
||||
if (!Array.isArray(arr)) arr = [];
|
||||
|
||||
const items = Array.isArray(value) ? value : [value];
|
||||
arr.push(...items);
|
||||
cur[lastKey] = arr;
|
||||
|
||||
setLocalVariable(rootName, safeJSON(root));
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
function popVar(path, value) {
|
||||
const segs = splitPath(path);
|
||||
if (!segs.length) return { ok: false, reason: 'invalid-path' };
|
||||
|
||||
const rootName = String(segs[0]);
|
||||
let root = safeParse(getLocalVariable(rootName));
|
||||
|
||||
if (segs.length === 1) {
|
||||
if (!Array.isArray(root)) {
|
||||
return { ok: false, reason: 'not-array' };
|
||||
}
|
||||
const toRemove = Array.isArray(value) ? value : [value];
|
||||
for (const v of toRemove) {
|
||||
const vStr = safeJSON(v);
|
||||
const idx = root.findIndex(x => safeJSON(x) === vStr);
|
||||
if (idx !== -1) root.splice(idx, 1);
|
||||
}
|
||||
setLocalVariable(rootName, safeJSON(root));
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
if (!root || typeof root !== 'object') {
|
||||
return { ok: false, reason: 'not-array' };
|
||||
}
|
||||
|
||||
let cur = root;
|
||||
for (let i = 1; i < segs.length - 1; i++) {
|
||||
cur = cur?.[segs[i]];
|
||||
if (!cur || typeof cur !== 'object') {
|
||||
return { ok: false, reason: 'path-not-found' };
|
||||
}
|
||||
}
|
||||
|
||||
const lastKey = segs[segs.length - 1];
|
||||
let arr = cur[lastKey];
|
||||
|
||||
if (!Array.isArray(arr)) {
|
||||
return { ok: false, reason: 'not-array' };
|
||||
}
|
||||
|
||||
const toRemove = Array.isArray(value) ? value : [value];
|
||||
for (const v of toRemove) {
|
||||
const vStr = safeJSON(v);
|
||||
const idx = arr.findIndex(x => safeJSON(x) === vStr);
|
||||
if (idx !== -1) arr.splice(idx, 1);
|
||||
}
|
||||
|
||||
setLocalVariable(rootName, safeJSON(root));
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
/**
|
||||
* =========================
|
||||
* Storage (chat_metadata.extensions.LittleWhiteBox)
|
||||
* =========================
|
||||
*/
|
||||
const EXT_ID = 'LittleWhiteBox';
|
||||
const ERR_VAR_NAME = 'LWB_STATE_ERRORS';
|
||||
const LOG_KEY = 'stateLogV2';
|
||||
const CKPT_KEY = 'stateCkptV2';
|
||||
|
||||
|
||||
/**
|
||||
* 写入状态错误到本地变量（覆盖写入）
|
||||
*/
|
||||
function writeStateErrorsToLocalVar(lines) {
|
||||
try {
|
||||
const text = Array.isArray(lines) && lines.length
|
||||
? lines.map(s => `- ${String(s)}`).join('\n')
|
||||
: '';
|
||||
setLocalVariable(ERR_VAR_NAME, text);
|
||||
} catch {}
|
||||
}
|
||||
|
||||
function getLwbExtMeta() {
|
||||
const ctx = getContext();
|
||||
const meta = ctx?.chatMetadata || (ctx.chatMetadata = {});
|
||||
meta.extensions ||= {};
|
||||
meta.extensions[EXT_ID] ||= {};
|
||||
return meta.extensions[EXT_ID];
|
||||
}
|
||||
|
||||
function getStateLog() {
|
||||
const ext = getLwbExtMeta();
|
||||
ext[LOG_KEY] ||= { version: 1, floors: {} };
|
||||
return ext[LOG_KEY];
|
||||
}
|
||||
|
||||
function getCheckpointStore() {
|
||||
const ext = getLwbExtMeta();
|
||||
ext[CKPT_KEY] ||= { version: 1, every: 50, points: {} };
|
||||
return ext[CKPT_KEY];
|
||||
}
|
||||
|
||||
function saveWalRecord(floor, signature, rules, ops) {
|
||||
const log = getStateLog();
|
||||
log.floors[String(floor)] = {
|
||||
signature: String(signature || ''),
|
||||
rules: Array.isArray(rules) ? deepClone(rules) : [],
|
||||
ops: Array.isArray(ops) ? deepClone(ops) : [],
|
||||
ts: Date.now(),
|
||||
};
|
||||
getContext()?.saveMetadataDebounced?.();
|
||||
}
|
||||
|
||||
/**
|
||||
* checkpoint = 执行完 floor 后的全量变量+规则
|
||||
*/
|
||||
function saveCheckpointIfNeeded(floor) {
|
||||
const ckpt = getCheckpointStore();
|
||||
const every = Number(ckpt.every) || 50;
|
||||
|
||||
// floor=0 也可以存，但一般没意义；你可按需调整
|
||||
if (floor < 0) return;
|
||||
if (every <= 0) return;
|
||||
if (floor % every !== 0) return;
|
||||
|
||||
const ctx = getContext();
|
||||
const meta = ctx?.chatMetadata || {};
|
||||
const vars = deepClone(meta.variables || {});
|
||||
// 2.0 rules 存在 chatMetadata 里（guard.js 写入的位置）
|
||||
const rules = deepClone(meta.LWB_RULES_V2 || {});
|
||||
|
||||
ckpt.points[String(floor)] = { vars, rules, ts: Date.now() };
|
||||
ctx?.saveMetadataDebounced?.();
|
||||
}
|
||||
|
||||
/**
|
||||
* =========================
|
||||
* Applied signature map (idempotent)
|
||||
* =========================
|
||||
*/
|
||||
const LWB_STATE_APPLIED_KEY = 'LWB_STATE_APPLIED_KEY';
|
||||
|
||||
function getAppliedMap() {
|
||||
const meta = getContext()?.chatMetadata || {};
|
||||
meta[LWB_STATE_APPLIED_KEY] ||= {};
|
||||
return meta[LWB_STATE_APPLIED_KEY];
|
||||
}
|
||||
|
||||
export function clearStateAppliedFor(floor) {
|
||||
try {
|
||||
delete getAppliedMap()[floor];
|
||||
getContext()?.saveMetadataDebounced?.();
|
||||
} catch {}
|
||||
}
|
||||
|
||||
export function clearStateAppliedFrom(floorInclusive) {
|
||||
try {
|
||||
const map = getAppliedMap();
|
||||
for (const k of Object.keys(map)) {
|
||||
if (Number(k) >= floorInclusive) delete map[k];
|
||||
}
|
||||
getContext()?.saveMetadataDebounced?.();
|
||||
} catch {}
|
||||
}
|
||||
|
||||
function isIndexDeleteOp(opItem) {
|
||||
if (!opItem || opItem.op !== 'del') return false;
|
||||
const segs = splitPath(opItem.path);
|
||||
if (!segs.length) return false;
|
||||
const last = segs[segs.length - 1];
|
||||
return typeof last === 'number' && Number.isFinite(last);
|
||||
}
|
||||
|
||||
function buildExecOpsWithIndexDeleteReorder(ops) {
|
||||
// 同一个数组的 index-del：按 parentPath 分组，组内 index 倒序
|
||||
// 其它操作：保持原顺序
|
||||
const groups = new Map(); // parentPath -> { order, items: [{...opItem, index}] }
|
||||
const groupOrder = new Map();
|
||||
let orderCounter = 0;
|
||||
|
||||
const normalOps = [];
|
||||
|
||||
for (const op of ops) {
|
||||
if (isIndexDeleteOp(op)) {
|
||||
const segs = splitPath(op.path);
|
||||
const idx = segs[segs.length - 1];
|
||||
const parentPath = segs.slice(0, -1).reduce((acc, s) => {
|
||||
if (typeof s === 'number') return acc + `[${s}]`;
|
||||
return acc ? `${acc}.${s}` : String(s);
|
||||
}, '');
|
||||
|
||||
if (!groups.has(parentPath)) {
|
||||
groups.set(parentPath, []);
|
||||
groupOrder.set(parentPath, orderCounter++);
|
||||
}
|
||||
groups.get(parentPath).push({ op, idx });
|
||||
} else {
|
||||
normalOps.push(op);
|
||||
}
|
||||
}
|
||||
|
||||
// 按“该数组第一次出现的顺序”输出各组（可预测）
|
||||
const orderedParents = Array.from(groups.keys()).sort((a, b) => (groupOrder.get(a) ?? 0) - (groupOrder.get(b) ?? 0));
|
||||
|
||||
const reorderedIndexDeletes = [];
|
||||
for (const parent of orderedParents) {
|
||||
const items = groups.get(parent) || [];
|
||||
// 关键：倒序
|
||||
items.sort((a, b) => b.idx - a.idx);
|
||||
for (const it of items) reorderedIndexDeletes.push(it.op);
|
||||
}
|
||||
|
||||
// ✅ 我们把“索引删除”放在最前面执行：这样它们永远按“原索引”删
|
||||
// （避免在同一轮里先删后 push 导致索引变化）
|
||||
return [...reorderedIndexDeletes, ...normalOps];
|
||||
}
|
||||
|
||||
/**
|
||||
* =========================
|
||||
* Core: apply one message text (<state>...) => update vars + rules + wal + checkpoint
|
||||
* =========================
|
||||
*/
|
||||
export function applyStateForMessage(messageId, messageContent) {
|
||||
const ctx = getContext();
|
||||
const chatId = ctx?.chatId || '';
|
||||
|
||||
loadRulesFromMeta();
|
||||
|
||||
const text = String(messageContent ?? '');
|
||||
const signature = computeStateSignature(text);
|
||||
const blocks = extractStateBlocks(text);
|
||||
// ✅ 统一：只要没有可执行 blocks，就视为本层 state 被移除
|
||||
if (!signature || blocks.length === 0) {
|
||||
clearStateAppliedFor(messageId);
|
||||
writeStateErrorsToLocalVar([]);
|
||||
// delete WAL record
|
||||
try {
|
||||
const ext = getLwbExtMeta();
|
||||
const log = ext[LOG_KEY];
|
||||
if (log?.floors) delete log.floors[String(messageId)];
|
||||
getContext()?.saveMetadataDebounced?.();
|
||||
} catch {}
|
||||
return { atoms: [], errors: [], skipped: false };
|
||||
}
|
||||
|
||||
const appliedMap = getAppliedMap();
|
||||
if (appliedMap[messageId] === signature) {
|
||||
return { atoms: [], errors: [], skipped: true };
|
||||
}
|
||||
const atoms = [];
|
||||
const errors = [];
|
||||
let idx = 0;
|
||||
|
||||
const mergedRules = [];
|
||||
const mergedOps = [];
|
||||
|
||||
for (const block of blocks) {
|
||||
const parsed = parseStateBlock(block);
|
||||
mergedRules.push(...(parsed?.rules || []));
|
||||
mergedOps.push(...(parsed?.ops || []));
|
||||
}
|
||||
|
||||
if (blocks.length) {
|
||||
// ✅ WAL：一次写入完整的 rules/ops
|
||||
saveWalRecord(messageId, signature, mergedRules, mergedOps);
|
||||
|
||||
// ✅ rules 一次性注册
|
||||
let rulesTouched = false;
|
||||
for (const { path, rule } of mergedRules) {
|
||||
if (path && rule && Object.keys(rule).length) {
|
||||
setRule(normalizePath(path), rule);
|
||||
rulesTouched = true;
|
||||
}
|
||||
}
|
||||
if (rulesTouched) saveRulesToMeta();
|
||||
|
||||
const execOps = buildExecOpsWithIndexDeleteReorder(mergedOps);
|
||||
|
||||
// 执行操作（用 execOps）
|
||||
for (const opItem of execOps) {
|
||||
const { path, op, value, delta, warning } = opItem;
|
||||
if (!path) continue;
|
||||
if (warning) errors.push(`[${path}] ${warning}`);
|
||||
|
||||
const absPath = normalizePath(path);
|
||||
const oldValue = getVar(path);
|
||||
|
||||
const guard = validate(op, absPath, op === 'inc' ? delta : value, oldValue);
|
||||
if (!guard.allow) {
|
||||
errors.push(`${path}: ${guard.reason || '\u88ab\u89c4\u5219\u62d2\u7edd'}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
// 记录修正信息
|
||||
if (guard.note) {
|
||||
if (op === 'inc') {
|
||||
const raw = Number(delta);
|
||||
const rawTxt = Number.isFinite(raw) ? `${raw >= 0 ? '+' : ''}${raw}` : String(delta ?? '');
|
||||
errors.push(`${path}: ${rawTxt} ${guard.note}`);
|
||||
} else {
|
||||
errors.push(`${path}: ${guard.note}`);
|
||||
}
|
||||
}
|
||||
|
||||
let execOk = true;
|
||||
let execReason = '';
|
||||
|
||||
try {
|
||||
switch (op) {
|
||||
case 'set':
|
||||
setVar(path, guard.value);
|
||||
break;
|
||||
case 'inc':
|
||||
// guard.value 对 inc 是最终 nextValue
|
||||
setVar(path, guard.value);
|
||||
break;
|
||||
case 'push': {
|
||||
const result = pushVar(path, guard.value);
|
||||
if (!result.ok) { execOk = false; execReason = result.reason; }
|
||||
break;
|
||||
}
|
||||
case 'pop': {
|
||||
const result = popVar(path, guard.value);
|
||||
if (!result.ok) { execOk = false; execReason = result.reason; }
|
||||
break;
|
||||
}
|
||||
case 'del':
|
||||
delVar(path);
|
||||
break;
|
||||
default:
|
||||
execOk = false;
|
||||
execReason = `未知 op=${op}`;
|
||||
}
|
||||
} catch (e) {
|
||||
execOk = false;
|
||||
execReason = e?.message || String(e);
|
||||
}
|
||||
|
||||
if (!execOk) {
|
||||
errors.push(`[${path}] 失败: ${execReason}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
const newValue = getVar(path);
|
||||
|
||||
atoms.push({
|
||||
atomId: `sa-${messageId}-${idx}`,
|
||||
chatId,
|
||||
floor: messageId,
|
||||
idx,
|
||||
path,
|
||||
op,
|
||||
oldValue,
|
||||
newValue,
|
||||
delta: op === 'inc' ? delta : undefined,
|
||||
semantic: generateSemantic(path, op, oldValue, newValue, delta, value),
|
||||
timestamp: Date.now(),
|
||||
});
|
||||
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
|
||||
appliedMap[messageId] = signature;
|
||||
getContext()?.saveMetadataDebounced?.();
|
||||
|
||||
// ✅ checkpoint：执行完该楼后，可选存一次全量
|
||||
saveCheckpointIfNeeded(messageId);
|
||||
|
||||
// Write error list to local variable
|
||||
writeStateErrorsToLocalVar(errors);
|
||||
|
||||
return { atoms, errors, skipped: false };
|
||||
}
|
||||
|
||||
/**
|
||||
* =========================
|
||||
* Restore / Replay (for rollback & rebuild)
|
||||
* =========================
|
||||
*/
|
||||
|
||||
/**
|
||||
* 恢复到 targetFloor 执行完成后的变量状态（含规则）
|
||||
* - 使用最近 checkpoint，然后 replay WAL
|
||||
* - 不依赖消息文本 <state>（避免被正则清掉）
|
||||
*/
|
||||
export async function restoreStateV2ToFloor(targetFloor) {
|
||||
const ctx = getContext();
|
||||
const meta = ctx?.chatMetadata || {};
|
||||
const floor = Number(targetFloor);
|
||||
|
||||
if (!Number.isFinite(floor) || floor < 0) {
|
||||
// floor < 0 => 清空
|
||||
meta.variables = {};
|
||||
meta.LWB_RULES_V2 = {};
|
||||
ctx?.saveMetadataDebounced?.();
|
||||
return { ok: true, usedCheckpoint: null };
|
||||
}
|
||||
|
||||
const log = getStateLog();
|
||||
const ckpt = getCheckpointStore();
|
||||
const points = ckpt.points || {};
|
||||
const available = Object.keys(points)
|
||||
.map(Number)
|
||||
.filter(n => Number.isFinite(n) && n <= floor)
|
||||
.sort((a, b) => b - a);
|
||||
|
||||
const ck = available.length ? available[0] : null;
|
||||
|
||||
// 1) 恢复 checkpoint 或清空基线
|
||||
if (ck != null) {
|
||||
const snap = points[String(ck)];
|
||||
meta.variables = deepClone(snap?.vars || {});
|
||||
meta.LWB_RULES_V2 = deepClone(snap?.rules || {});
|
||||
} else {
|
||||
meta.variables = {};
|
||||
meta.LWB_RULES_V2 = {};
|
||||
}
|
||||
|
||||
ctx?.saveMetadataDebounced?.();
|
||||
|
||||
// 2) 从 meta 载入规则到内存（guard.js 的内存表）
|
||||
loadRulesFromMeta();
|
||||
|
||||
let rulesTouchedAny = false;
|
||||
|
||||
// 3) replay WAL: (ck+1 .. floor)
|
||||
const start = ck == null ? 0 : (ck + 1);
|
||||
for (let f = start; f <= floor; f++) {
|
||||
const rec = log.floors?.[String(f)];
|
||||
if (!rec) continue;
|
||||
|
||||
// 先应用 rules
|
||||
const rules = Array.isArray(rec.rules) ? rec.rules : [];
|
||||
let touched = false;
|
||||
for (const r of rules) {
|
||||
const p = r?.path;
|
||||
const rule = r?.rule;
|
||||
if (p && rule && typeof rule === 'object') {
|
||||
setRule(normalizePath(p), rule);
|
||||
touched = true;
|
||||
}
|
||||
}
|
||||
if (touched) rulesTouchedAny = true;
|
||||
|
||||
// 再应用 ops（不产出 atoms、不写 wal）
|
||||
const ops = Array.isArray(rec.ops) ? rec.ops : [];
|
||||
const execOps = buildExecOpsWithIndexDeleteReorder(ops);
|
||||
for (const opItem of execOps) {
|
||||
const path = opItem?.path;
|
||||
const op = opItem?.op;
|
||||
if (!path || !op) continue;
|
||||
|
||||
const absPath = normalizePath(path);
|
||||
const oldValue = getVar(path);
|
||||
|
||||
const payload = (op === 'inc') ? opItem.delta : opItem.value;
|
||||
const guard = validate(op, absPath, payload, oldValue);
|
||||
if (!guard.allow) continue;
|
||||
|
||||
try {
|
||||
switch (op) {
|
||||
case 'set':
|
||||
setVar(path, guard.value);
|
||||
break;
|
||||
case 'inc':
|
||||
setVar(path, guard.value);
|
||||
break;
|
||||
case 'push': {
|
||||
const result = pushVar(path, guard.value);
|
||||
if (!result.ok) {/* ignore */}
|
||||
break;
|
||||
}
|
||||
case 'pop': {
|
||||
const result = popVar(path, guard.value);
|
||||
if (!result.ok) {/* ignore */}
|
||||
break;
|
||||
}
|
||||
case 'del':
|
||||
delVar(path);
|
||||
break;
|
||||
}
|
||||
} catch {
|
||||
// ignore replay errors
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (rulesTouchedAny) {
|
||||
saveRulesToMeta();
|
||||
}
|
||||
|
||||
// 4) 清理 applied signature：floor 之后都要重新计算
|
||||
clearStateAppliedFrom(floor + 1);
|
||||
|
||||
ctx?.saveMetadataDebounced?.();
|
||||
return { ok: true, usedCheckpoint: ck };
|
||||
}
|
||||
|
||||
/**
|
||||
* 删除 floor >= fromFloor 的 2.0 持久化数据：
|
||||
* - WAL: stateLogV2.floors
|
||||
* - checkpoint: stateCkptV2.points
|
||||
* - applied signature: LWB_STATE_APPLIED_KEY
|
||||
*
|
||||
* 用于 MESSAGE_DELETED 等“物理删除消息”场景，避免 WAL/ckpt 无限膨胀。
|
||||
*/
|
||||
export async function trimStateV2FromFloor(fromFloor) {
|
||||
const start = Number(fromFloor);
|
||||
if (!Number.isFinite(start)) return { ok: false };
|
||||
|
||||
const ctx = getContext();
|
||||
const meta = ctx?.chatMetadata || {};
|
||||
meta.extensions ||= {};
|
||||
meta.extensions[EXT_ID] ||= {};
|
||||
|
||||
const ext = meta.extensions[EXT_ID];
|
||||
|
||||
// 1) WAL
|
||||
const log = ext[LOG_KEY];
|
||||
if (log?.floors && typeof log.floors === 'object') {
|
||||
for (const k of Object.keys(log.floors)) {
|
||||
const f = Number(k);
|
||||
if (Number.isFinite(f) && f >= start) {
|
||||
delete log.floors[k];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2) Checkpoints
|
||||
const ckpt = ext[CKPT_KEY];
|
||||
if (ckpt?.points && typeof ckpt.points === 'object') {
|
||||
for (const k of Object.keys(ckpt.points)) {
|
||||
const f = Number(k);
|
||||
if (Number.isFinite(f) && f >= start) {
|
||||
delete ckpt.points[k];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 3) Applied signatures（floor>=start 都要重新算）
|
||||
try {
|
||||
clearStateAppliedFrom(start);
|
||||
} catch {}
|
||||
|
||||
ctx?.saveMetadataDebounced?.();
|
||||
return { ok: true };
|
||||
}
|
||||
249
modules/variables/state2/guard.js
Normal file
249
modules/variables/state2/guard.js
Normal file
@@ -0,0 +1,249 @@
|
||||
import { getContext } from '../../../../../../extensions.js';
|
||||
|
||||
const LWB_RULES_V2_KEY = 'LWB_RULES_V2';
|
||||
|
||||
let rulesTable = {};
|
||||
|
||||
export function loadRulesFromMeta() {
|
||||
try {
|
||||
const meta = getContext()?.chatMetadata || {};
|
||||
rulesTable = meta[LWB_RULES_V2_KEY] || {};
|
||||
} catch {
|
||||
rulesTable = {};
|
||||
}
|
||||
}
|
||||
|
||||
export function saveRulesToMeta() {
|
||||
try {
|
||||
const meta = getContext()?.chatMetadata || {};
|
||||
meta[LWB_RULES_V2_KEY] = { ...rulesTable };
|
||||
getContext()?.saveMetadataDebounced?.();
|
||||
} catch {}
|
||||
}
|
||||
|
||||
export function getRuleNode(absPath) {
|
||||
return matchRuleWithWildcard(absPath);
|
||||
}
|
||||
|
||||
export function setRule(path, rule) {
|
||||
rulesTable[path] = { ...(rulesTable[path] || {}), ...rule };
|
||||
}
|
||||
|
||||
export function clearRule(path) {
|
||||
delete rulesTable[path];
|
||||
saveRulesToMeta();
|
||||
}
|
||||
|
||||
export function clearAllRules() {
|
||||
rulesTable = {};
|
||||
saveRulesToMeta();
|
||||
}
|
||||
|
||||
export function getParentPath(absPath) {
|
||||
const parts = String(absPath).split('.').filter(Boolean);
|
||||
if (parts.length <= 1) return '';
|
||||
return parts.slice(0, -1).join('.');
|
||||
}
|
||||
|
||||
/**
|
||||
* 通配符路径匹配
|
||||
* 例如：data.同行者.张三.HP 可以匹配 data.同行者.*.HP
|
||||
*/
|
||||
function matchRuleWithWildcard(absPath) {
|
||||
// 1. 精确匹配
|
||||
if (rulesTable[absPath]) return rulesTable[absPath];
|
||||
|
||||
const segs = String(absPath).split('.').filter(Boolean);
|
||||
const n = segs.length;
|
||||
|
||||
// 2. 尝试各种 * 替换组合（从少到多）
|
||||
for (let starCount = 1; starCount <= n; starCount++) {
|
||||
const patterns = generateStarPatterns(segs, starCount);
|
||||
for (const pattern of patterns) {
|
||||
if (rulesTable[pattern]) return rulesTable[pattern];
|
||||
}
|
||||
}
|
||||
|
||||
// 3. 尝试 [*] 匹配（数组元素模板）
|
||||
for (let i = 0; i < n; i++) {
|
||||
if (/^\d+$/.test(segs[i])) {
|
||||
const trySegs = [...segs];
|
||||
trySegs[i] = '[*]';
|
||||
const tryPath = trySegs.join('.');
|
||||
if (rulesTable[tryPath]) return rulesTable[tryPath];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 生成恰好有 starCount 个 * 的所有模式
|
||||
*/
|
||||
function generateStarPatterns(segs, starCount) {
|
||||
const n = segs.length;
|
||||
const results = [];
|
||||
|
||||
function backtrack(idx, stars, path) {
|
||||
if (idx === n) {
|
||||
if (stars === starCount) results.push(path.join('.'));
|
||||
return;
|
||||
}
|
||||
// 用原值
|
||||
if (n - idx > starCount - stars) {
|
||||
backtrack(idx + 1, stars, [...path, segs[idx]]);
|
||||
}
|
||||
// 用 *
|
||||
if (stars < starCount) {
|
||||
backtrack(idx + 1, stars + 1, [...path, '*']);
|
||||
}
|
||||
}
|
||||
|
||||
backtrack(0, 0, []);
|
||||
return results;
|
||||
}
|
||||
|
||||
function getValueType(v) {
|
||||
if (Array.isArray(v)) return 'array';
|
||||
if (v === null) return 'null';
|
||||
return typeof v;
|
||||
}
|
||||
|
||||
/**
|
||||
* 验证操作
|
||||
* @returns {{ allow: boolean, value?: any, reason?: string, note?: string }}
|
||||
*/
|
||||
export function validate(op, absPath, payload, currentValue) {
|
||||
const node = getRuleNode(absPath);
|
||||
const parentPath = getParentPath(absPath);
|
||||
const parentNode = parentPath ? getRuleNode(parentPath) : null;
|
||||
const isNewKey = currentValue === undefined;
|
||||
|
||||
const lastSeg = String(absPath).split('.').pop() || '';
|
||||
|
||||
// ===== 1. $schema 白名单检查 =====
|
||||
if (parentNode?.allowedKeys && Array.isArray(parentNode.allowedKeys)) {
|
||||
if (isNewKey && (op === 'set' || op === 'push')) {
|
||||
if (!parentNode.allowedKeys.includes(lastSeg)) {
|
||||
return { allow: false, reason: `字段不在结构模板中` };
|
||||
}
|
||||
}
|
||||
if (op === 'del') {
|
||||
if (parentNode.allowedKeys.includes(lastSeg)) {
|
||||
return { allow: false, reason: `模板定义的字段不能删除` };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ===== 2. 父层结构锁定（无 objectExt / 无 allowedKeys / 无 hasWildcard） =====
|
||||
if (parentNode && parentNode.typeLock === 'object') {
|
||||
if (!parentNode.objectExt && !parentNode.allowedKeys && !parentNode.hasWildcard) {
|
||||
if (isNewKey && (op === 'set' || op === 'push')) {
|
||||
return { allow: false, reason: '父层结构已锁定，不允许新增字段' };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ===== 3. 类型锁定 =====
|
||||
if (node?.typeLock && op === 'set') {
|
||||
let finalPayload = payload;
|
||||
|
||||
// 宽松：数字字符串 => 数字
|
||||
if (node.typeLock === 'number' && typeof payload === 'string') {
|
||||
if (/^-?\d+(?:\.\d+)?$/.test(payload.trim())) {
|
||||
finalPayload = Number(payload);
|
||||
}
|
||||
}
|
||||
|
||||
const finalType = getValueType(finalPayload);
|
||||
if (node.typeLock !== finalType) {
|
||||
return { allow: false, reason: `类型不匹配，期望 ${node.typeLock}，实际 ${finalType}` };
|
||||
}
|
||||
|
||||
payload = finalPayload;
|
||||
}
|
||||
|
||||
// ===== 4. 数组扩展检查 =====
|
||||
if (op === 'push') {
|
||||
if (node && node.typeLock === 'array' && !node.arrayGrow) {
|
||||
return { allow: false, reason: '数组不允许扩展' };
|
||||
}
|
||||
}
|
||||
|
||||
// ===== 5. $ro 只读 =====
|
||||
if (node?.ro && (op === 'set' || op === 'inc')) {
|
||||
return { allow: false, reason: '只读字段' };
|
||||
}
|
||||
|
||||
// ===== 6. set 操作：数值约束 =====
|
||||
if (op === 'set') {
|
||||
const num = Number(payload);
|
||||
|
||||
// range 限制
|
||||
if (Number.isFinite(num) && (node?.min !== undefined || node?.max !== undefined)) {
|
||||
let v = num;
|
||||
const min = node?.min;
|
||||
const max = node?.max;
|
||||
|
||||
if (min !== undefined) v = Math.max(v, min);
|
||||
if (max !== undefined) v = Math.min(v, max);
|
||||
|
||||
const clamped = v !== num;
|
||||
return {
|
||||
allow: true,
|
||||
value: v,
|
||||
note: clamped ? `超出范围，已限制到 ${v}` : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
// enum 枚举（不自动修正，直接拒绝）
|
||||
if (node?.enum?.length) {
|
||||
const s = String(payload ?? '');
|
||||
if (!node.enum.includes(s)) {
|
||||
return { allow: false, reason: `枚举不匹配，允许：${node.enum.join(' / ')}` };
|
||||
}
|
||||
}
|
||||
|
||||
return { allow: true, value: payload };
|
||||
}
|
||||
|
||||
// ===== 7. inc 操作：step / range 限制 =====
|
||||
if (op === 'inc') {
|
||||
const delta = Number(payload);
|
||||
if (!Number.isFinite(delta)) return { allow: false, reason: 'delta 不是数字' };
|
||||
|
||||
const cur = Number(currentValue) || 0;
|
||||
let d = delta;
|
||||
const noteParts = [];
|
||||
|
||||
// step 限制
|
||||
if (node?.step !== undefined && node.step >= 0) {
|
||||
const before = d;
|
||||
if (d > node.step) d = node.step;
|
||||
if (d < -node.step) d = -node.step;
|
||||
if (d !== before) {
|
||||
noteParts.push(`超出步长限制，已限制到 ${d >= 0 ? '+' : ''}${d}`);
|
||||
}
|
||||
}
|
||||
|
||||
let next = cur + d;
|
||||
|
||||
// range 限制
|
||||
const beforeClamp = next;
|
||||
if (node?.min !== undefined) next = Math.max(next, node.min);
|
||||
if (node?.max !== undefined) next = Math.min(next, node.max);
|
||||
if (next !== beforeClamp) {
|
||||
noteParts.push(`超出范围，已限制到 ${next}`);
|
||||
}
|
||||
|
||||
return {
|
||||
allow: true,
|
||||
value: next,
|
||||
note: noteParts.length ? noteParts.join('，') : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
return { allow: true, value: payload };
|
||||
}
|
||||
|
||||
|
||||
21
modules/variables/state2/index.js
Normal file
21
modules/variables/state2/index.js
Normal file
@@ -0,0 +1,21 @@
|
||||
export {
|
||||
applyStateForMessage,
|
||||
clearStateAppliedFor,
|
||||
clearStateAppliedFrom,
|
||||
restoreStateV2ToFloor,
|
||||
trimStateV2FromFloor,
|
||||
} from './executor.js';
|
||||
|
||||
export { parseStateBlock, extractStateBlocks, computeStateSignature, parseInlineValue } from './parser.js';
|
||||
export { generateSemantic } from './semantic.js';
|
||||
|
||||
export {
|
||||
validate,
|
||||
setRule,
|
||||
clearRule,
|
||||
clearAllRules,
|
||||
loadRulesFromMeta,
|
||||
saveRulesToMeta,
|
||||
getRuleNode,
|
||||
getParentPath,
|
||||
} from './guard.js';
|
||||
514
modules/variables/state2/parser.js
Normal file
514
modules/variables/state2/parser.js
Normal file
@@ -0,0 +1,514 @@
|
||||
import jsyaml from '../../../libs/js-yaml.mjs';
|
||||
|
||||
/**
|
||||
* Robust <state> block matcher (no regex)
|
||||
* - Pairs each </state> with the nearest preceding <state ...>
|
||||
* - Ignores unclosed <state>
|
||||
*/
|
||||
|
||||
function isValidOpenTagAt(s, i) {
|
||||
if (s[i] !== '<') return false;
|
||||
|
||||
const head = s.slice(i, i + 6).toLowerCase();
|
||||
if (head !== '<state') return false;
|
||||
|
||||
const next = s[i + 6] ?? '';
|
||||
if (next && !(next === '>' || next === '/' || /\s/.test(next))) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function isValidCloseTagAt(s, i) {
|
||||
if (s[i] !== '<') return false;
|
||||
if (s[i + 1] !== '/') return false;
|
||||
|
||||
const head = s.slice(i, i + 7).toLowerCase();
|
||||
if (head !== '</state') return false;
|
||||
|
||||
let j = i + 7;
|
||||
while (j < s.length && /\s/.test(s[j])) j++;
|
||||
return s[j] === '>';
|
||||
}
|
||||
|
||||
function findTagEnd(s, openIndex) {
|
||||
const end = s.indexOf('>', openIndex);
|
||||
return end === -1 ? -1 : end;
|
||||
}
|
||||
|
||||
function findStateBlockSpans(text) {
|
||||
const s = String(text ?? '');
|
||||
const closes = [];
|
||||
|
||||
for (let i = 0; i < s.length; i++) {
|
||||
if (s[i] !== '<') continue;
|
||||
if (isValidCloseTagAt(s, i)) closes.push(i);
|
||||
}
|
||||
if (!closes.length) return [];
|
||||
|
||||
const spans = [];
|
||||
let searchEnd = s.length;
|
||||
|
||||
for (let cIdx = closes.length - 1; cIdx >= 0; cIdx--) {
|
||||
const closeStart = closes[cIdx];
|
||||
if (closeStart >= searchEnd) continue;
|
||||
|
||||
let closeEnd = closeStart + 7;
|
||||
while (closeEnd < s.length && s[closeEnd] !== '>') closeEnd++;
|
||||
if (s[closeEnd] !== '>') continue;
|
||||
closeEnd += 1;
|
||||
|
||||
let openStart = -1;
|
||||
for (let i = closeStart - 1; i >= 0; i--) {
|
||||
if (s[i] !== '<') continue;
|
||||
if (!isValidOpenTagAt(s, i)) continue;
|
||||
|
||||
const tagEnd = findTagEnd(s, i);
|
||||
if (tagEnd === -1) continue;
|
||||
if (tagEnd >= closeStart) continue;
|
||||
|
||||
openStart = i;
|
||||
break;
|
||||
}
|
||||
|
||||
if (openStart === -1) continue;
|
||||
|
||||
const openTagEnd = findTagEnd(s, openStart);
|
||||
if (openTagEnd === -1) continue;
|
||||
|
||||
spans.push({
|
||||
openStart,
|
||||
openTagEnd: openTagEnd + 1,
|
||||
closeStart,
|
||||
closeEnd,
|
||||
});
|
||||
|
||||
searchEnd = openStart;
|
||||
}
|
||||
|
||||
spans.reverse();
|
||||
return spans;
|
||||
}
|
||||
|
||||
export function extractStateBlocks(text) {
|
||||
const s = String(text ?? '');
|
||||
const spans = findStateBlockSpans(s);
|
||||
const out = [];
|
||||
for (const sp of spans) {
|
||||
const inner = s.slice(sp.openTagEnd, sp.closeStart);
|
||||
if (inner.trim()) out.push(inner);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export function computeStateSignature(text) {
|
||||
const s = String(text ?? '');
|
||||
const spans = findStateBlockSpans(s);
|
||||
if (!spans.length) return '';
|
||||
const chunks = spans.map(sp => s.slice(sp.openStart, sp.closeEnd).trim());
|
||||
return chunks.join('\n---\n');
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Parse $schema block
|
||||
*/
|
||||
function parseSchemaBlock(basePath, schemaLines) {
|
||||
const rules = [];
|
||||
|
||||
const nonEmpty = schemaLines.filter(l => l.trim());
|
||||
if (!nonEmpty.length) return rules;
|
||||
|
||||
const minIndent = Math.min(...nonEmpty.map(l => l.search(/\S/)));
|
||||
const yamlText = schemaLines
|
||||
.map(l => (l.trim() ? l.slice(minIndent) : ''))
|
||||
.join('\n');
|
||||
|
||||
let schemaObj;
|
||||
try {
|
||||
schemaObj = jsyaml.load(yamlText);
|
||||
} catch (e) {
|
||||
console.warn('[parser] $schema YAML parse failed:', e.message);
|
||||
return rules;
|
||||
}
|
||||
|
||||
if (!schemaObj || typeof schemaObj !== 'object') return rules;
|
||||
|
||||
function walk(obj, curPath) {
|
||||
if (obj === null || obj === undefined) return;
|
||||
|
||||
if (Array.isArray(obj)) {
|
||||
if (obj.length === 0) {
|
||||
rules.push({
|
||||
path: curPath,
|
||||
rule: { typeLock: 'array', arrayGrow: true },
|
||||
});
|
||||
} else {
|
||||
rules.push({
|
||||
path: curPath,
|
||||
rule: { typeLock: 'array', arrayGrow: true },
|
||||
});
|
||||
walk(obj[0], curPath ? `${curPath}.[*]` : '[*]');
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (typeof obj !== 'object') {
|
||||
const t = typeof obj;
|
||||
if (t === 'string' || t === 'number' || t === 'boolean') {
|
||||
rules.push({
|
||||
path: curPath,
|
||||
rule: { typeLock: t },
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const keys = Object.keys(obj);
|
||||
|
||||
if (keys.length === 0) {
|
||||
rules.push({
|
||||
path: curPath,
|
||||
rule: { typeLock: 'object', objectExt: true },
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
const hasWildcard = keys.includes('*');
|
||||
|
||||
if (hasWildcard) {
|
||||
rules.push({
|
||||
path: curPath,
|
||||
rule: { typeLock: 'object', objectExt: true, hasWildcard: true },
|
||||
});
|
||||
|
||||
const wildcardTemplate = obj['*'];
|
||||
if (wildcardTemplate !== undefined) {
|
||||
walk(wildcardTemplate, curPath ? `${curPath}.*` : '*');
|
||||
}
|
||||
|
||||
for (const k of keys) {
|
||||
if (k === '*') continue;
|
||||
const childPath = curPath ? `${curPath}.${k}` : k;
|
||||
walk(obj[k], childPath);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
rules.push({
|
||||
path: curPath,
|
||||
rule: { typeLock: 'object', allowedKeys: keys },
|
||||
});
|
||||
|
||||
for (const k of keys) {
|
||||
const childPath = curPath ? `${curPath}.${k}` : k;
|
||||
walk(obj[k], childPath);
|
||||
}
|
||||
}
|
||||
|
||||
walk(schemaObj, basePath);
|
||||
return rules;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse rule line ($ro, $range, $step, $enum)
|
||||
*/
|
||||
function parseRuleLine(line) {
|
||||
const tokens = line.trim().split(/\s+/);
|
||||
const directives = [];
|
||||
let pathStart = 0;
|
||||
|
||||
for (let i = 0; i < tokens.length; i++) {
|
||||
if (tokens[i].startsWith('$')) {
|
||||
directives.push(tokens[i]);
|
||||
pathStart = i + 1;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
const path = tokens.slice(pathStart).join(' ').trim();
|
||||
if (!path || !directives.length) return null;
|
||||
|
||||
const rule = {};
|
||||
|
||||
for (const tok of directives) {
|
||||
if (tok === '$ro') { rule.ro = true; continue; }
|
||||
|
||||
const rangeMatch = tok.match(/^\$range=\[\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\]$/);
|
||||
if (rangeMatch) {
|
||||
rule.min = Math.min(Number(rangeMatch[1]), Number(rangeMatch[2]));
|
||||
rule.max = Math.max(Number(rangeMatch[1]), Number(rangeMatch[2]));
|
||||
continue;
|
||||
}
|
||||
|
||||
const stepMatch = tok.match(/^\$step=(\d+(?:\.\d+)?)$/);
|
||||
if (stepMatch) { rule.step = Math.abs(Number(stepMatch[1])); continue; }
|
||||
|
||||
const enumMatch = tok.match(/^\$enum=\{([^}]+)\}$/);
|
||||
if (enumMatch) {
|
||||
rule.enum = enumMatch[1].split(/[,、;]/).map(s => s.trim()).filter(Boolean);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return { path, rule };
|
||||
}
|
||||
|
||||
export function parseStateBlock(content) {
|
||||
const lines = String(content ?? '').split(/\r?\n/);
|
||||
|
||||
const rules = [];
|
||||
const dataLines = [];
|
||||
|
||||
let inSchema = false;
|
||||
let schemaPath = '';
|
||||
let schemaLines = [];
|
||||
let schemaBaseIndent = -1;
|
||||
|
||||
const flushSchema = () => {
|
||||
if (schemaLines.length) {
|
||||
const parsed = parseSchemaBlock(schemaPath, schemaLines);
|
||||
rules.push(...parsed);
|
||||
}
|
||||
inSchema = false;
|
||||
schemaPath = '';
|
||||
schemaLines = [];
|
||||
schemaBaseIndent = -1;
|
||||
};
|
||||
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const raw = lines[i];
|
||||
const trimmed = raw.trim();
|
||||
const indent = raw.search(/\S/);
|
||||
|
||||
if (!trimmed || trimmed.startsWith('#')) {
|
||||
if (inSchema && schemaBaseIndent >= 0) schemaLines.push(raw);
|
||||
continue;
|
||||
}
|
||||
|
||||
// $schema 开始
|
||||
if (trimmed.startsWith('$schema')) {
|
||||
flushSchema();
|
||||
const rest = trimmed.slice(7).trim();
|
||||
schemaPath = rest || '';
|
||||
inSchema = true;
|
||||
schemaBaseIndent = -1;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (inSchema) {
|
||||
if (schemaBaseIndent < 0) {
|
||||
schemaBaseIndent = indent;
|
||||
}
|
||||
|
||||
// 缩进回退 => schema 结束
|
||||
if (indent < schemaBaseIndent && indent >= 0 && trimmed) {
|
||||
flushSchema();
|
||||
i--;
|
||||
continue;
|
||||
}
|
||||
|
||||
schemaLines.push(raw);
|
||||
continue;
|
||||
}
|
||||
|
||||
// 普通 $rule（$ro, $range, $step, $enum）
|
||||
if (trimmed.startsWith('$')) {
|
||||
const parsed = parseRuleLine(trimmed);
|
||||
if (parsed) rules.push(parsed);
|
||||
continue;
|
||||
}
|
||||
|
||||
dataLines.push(raw);
|
||||
}
|
||||
|
||||
flushSchema();
|
||||
|
||||
const ops = parseDataLines(dataLines);
|
||||
return { rules, ops };
|
||||
}
|
||||
|
||||
/**
|
||||
* 解析数据行
|
||||
*/
|
||||
function stripYamlInlineComment(s) {
|
||||
const text = String(s ?? '');
|
||||
if (!text) return '';
|
||||
let inSingle = false;
|
||||
let inDouble = false;
|
||||
let escaped = false;
|
||||
for (let i = 0; i < text.length; i++) {
|
||||
const ch = text[i];
|
||||
if (inSingle) {
|
||||
if (ch === "'") {
|
||||
if (text[i + 1] === "'") { i++; continue; }
|
||||
inSingle = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (inDouble) {
|
||||
if (escaped) { escaped = false; continue; }
|
||||
if (ch === '\\') { escaped = true; continue; }
|
||||
if (ch === '"') inDouble = false;
|
||||
continue;
|
||||
}
|
||||
if (ch === "'") { inSingle = true; continue; }
|
||||
if (ch === '"') { inDouble = true; continue; }
|
||||
if (ch === '#') {
|
||||
const prev = i > 0 ? text[i - 1] : '';
|
||||
if (i === 0 || /\s/.test(prev)) {
|
||||
return text.slice(0, i).trimEnd();
|
||||
}
|
||||
}
|
||||
}
|
||||
return text.trimEnd();
|
||||
}
|
||||
|
||||
function parseDataLines(lines) {
|
||||
const results = [];
|
||||
|
||||
let pendingPath = null;
|
||||
let pendingLines = [];
|
||||
|
||||
const flushPending = () => {
|
||||
if (!pendingPath) return;
|
||||
|
||||
if (!pendingLines.length) {
|
||||
results.push({ path: pendingPath, op: 'set', value: '' });
|
||||
pendingPath = null;
|
||||
pendingLines = [];
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const nonEmpty = pendingLines.filter(l => l.trim());
|
||||
const minIndent = nonEmpty.length
|
||||
? Math.min(...nonEmpty.map(l => l.search(/\S/)))
|
||||
: 0;
|
||||
|
||||
const yamlText = pendingLines
|
||||
.map(l => (l.trim() ? l.slice(minIndent) : ''))
|
||||
.join('\n');
|
||||
|
||||
const obj = jsyaml.load(yamlText);
|
||||
results.push({ path: pendingPath, op: 'set', value: obj });
|
||||
} catch (e) {
|
||||
results.push({ path: pendingPath, op: 'set', value: null, warning: `YAML 解析失败: ${e.message}` });
|
||||
} finally {
|
||||
pendingPath = null;
|
||||
pendingLines = [];
|
||||
}
|
||||
};
|
||||
|
||||
for (const raw of lines) {
|
||||
const trimmed = raw.trim();
|
||||
if (!trimmed || trimmed.startsWith('#')) continue;
|
||||
|
||||
const indent = raw.search(/\S/);
|
||||
|
||||
if (indent === 0) {
|
||||
flushPending();
|
||||
const colonIdx = findTopLevelColon(trimmed);
|
||||
if (colonIdx === -1) continue;
|
||||
|
||||
const path = trimmed.slice(0, colonIdx).trim();
|
||||
let rhs = trimmed.slice(colonIdx + 1).trim();
|
||||
rhs = stripYamlInlineComment(rhs);
|
||||
if (!path) continue;
|
||||
|
||||
if (!rhs) {
|
||||
pendingPath = path;
|
||||
pendingLines = [];
|
||||
} else {
|
||||
results.push({ path, ...parseInlineValue(rhs) });
|
||||
}
|
||||
} else if (pendingPath) {
|
||||
pendingLines.push(raw);
|
||||
}
|
||||
}
|
||||
|
||||
flushPending();
|
||||
return results;
|
||||
}
|
||||
|
||||
function findTopLevelColon(line) {
|
||||
let inQuote = false;
|
||||
let q = '';
|
||||
let esc = false;
|
||||
for (let i = 0; i < line.length; i++) {
|
||||
const ch = line[i];
|
||||
if (esc) { esc = false; continue; }
|
||||
if (ch === '\\') { esc = true; continue; }
|
||||
if (!inQuote && (ch === '"' || ch === "'")) { inQuote = true; q = ch; continue; }
|
||||
if (inQuote && ch === q) { inQuote = false; q = ''; continue; }
|
||||
if (!inQuote && ch === ':') return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
function unescapeString(s) {
|
||||
return String(s ?? '')
|
||||
.replace(/\\n/g, '\n')
|
||||
.replace(/\\t/g, '\t')
|
||||
.replace(/\\r/g, '\r')
|
||||
.replace(/\\"/g, '"')
|
||||
.replace(/\\'/g, "'")
|
||||
.replace(/\\\\/g, '\\');
|
||||
}
|
||||
|
||||
export function parseInlineValue(raw) {
|
||||
const t = String(raw ?? '').trim();
|
||||
|
||||
if (t === 'null') return { op: 'del' };
|
||||
|
||||
const parenNum = t.match(/^\((-?\d+(?:\.\d+)?)\)$/);
|
||||
if (parenNum) return { op: 'set', value: Number(parenNum[1]) };
|
||||
|
||||
if (/^\+\d/.test(t) || /^-\d/.test(t)) {
|
||||
const n = Number(t);
|
||||
if (Number.isFinite(n)) return { op: 'inc', delta: n };
|
||||
}
|
||||
|
||||
const pushD = t.match(/^\+"((?:[^"\\]|\\.)*)"\s*$/);
|
||||
if (pushD) return { op: 'push', value: unescapeString(pushD[1]) };
|
||||
const pushS = t.match(/^\+'((?:[^'\\]|\\.)*)'\s*$/);
|
||||
if (pushS) return { op: 'push', value: unescapeString(pushS[1]) };
|
||||
|
||||
if (t.startsWith('+[')) {
|
||||
try {
|
||||
const arr = JSON.parse(t.slice(1));
|
||||
if (Array.isArray(arr)) return { op: 'push', value: arr };
|
||||
} catch {}
|
||||
return { op: 'set', value: t, warning: '+[] 解析失败' };
|
||||
}
|
||||
|
||||
const popD = t.match(/^-"((?:[^"\\]|\\.)*)"\s*$/);
|
||||
if (popD) return { op: 'pop', value: unescapeString(popD[1]) };
|
||||
const popS = t.match(/^-'((?:[^'\\]|\\.)*)'\s*$/);
|
||||
if (popS) return { op: 'pop', value: unescapeString(popS[1]) };
|
||||
|
||||
if (t.startsWith('-[')) {
|
||||
try {
|
||||
const arr = JSON.parse(t.slice(1));
|
||||
if (Array.isArray(arr)) return { op: 'pop', value: arr };
|
||||
} catch {}
|
||||
return { op: 'set', value: t, warning: '-[] 解析失败' };
|
||||
}
|
||||
|
||||
if (/^-?\d+(?:\.\d+)?$/.test(t)) return { op: 'set', value: Number(t) };
|
||||
|
||||
const strD = t.match(/^"((?:[^"\\]|\\.)*)"\s*$/);
|
||||
if (strD) return { op: 'set', value: unescapeString(strD[1]) };
|
||||
const strS = t.match(/^'((?:[^'\\]|\\.)*)'\s*$/);
|
||||
if (strS) return { op: 'set', value: unescapeString(strS[1]) };
|
||||
|
||||
if (t === 'true') return { op: 'set', value: true };
|
||||
if (t === 'false') return { op: 'set', value: false };
|
||||
|
||||
if (t.startsWith('{') || t.startsWith('[')) {
|
||||
try { return { op: 'set', value: JSON.parse(t) }; }
|
||||
catch { return { op: 'set', value: t, warning: 'JSON 解析失败' }; }
|
||||
}
|
||||
|
||||
return { op: 'set', value: t };
|
||||
}
|
||||
41
modules/variables/state2/semantic.js
Normal file
41
modules/variables/state2/semantic.js
Normal file
@@ -0,0 +1,41 @@
|
||||
export function generateSemantic(path, op, oldValue, newValue, delta, operandValue) {
|
||||
const p = String(path ?? '').replace(/\./g, ' > ');
|
||||
|
||||
const fmt = (v) => {
|
||||
if (v === undefined) return '空';
|
||||
if (v === null) return 'null';
|
||||
try {
|
||||
return JSON.stringify(v);
|
||||
} catch {
|
||||
return String(v);
|
||||
}
|
||||
};
|
||||
|
||||
switch (op) {
|
||||
case 'set':
|
||||
return oldValue === undefined
|
||||
? `${p} 设为 ${fmt(newValue)}`
|
||||
: `${p} 从 ${fmt(oldValue)} 变为 ${fmt(newValue)}`;
|
||||
|
||||
case 'inc': {
|
||||
const sign = (delta ?? 0) >= 0 ? '+' : '';
|
||||
return `${p} ${sign}${delta}（${fmt(oldValue)} → ${fmt(newValue)}）`;
|
||||
}
|
||||
|
||||
case 'push': {
|
||||
const items = Array.isArray(operandValue) ? operandValue : [operandValue];
|
||||
return `${p} 加入 ${items.map(fmt).join('、')}`;
|
||||
}
|
||||
|
||||
case 'pop': {
|
||||
const items = Array.isArray(operandValue) ? operandValue : [operandValue];
|
||||
return `${p} 移除 ${items.map(fmt).join('、')}`;
|
||||
}
|
||||
|
||||
case 'del':
|
||||
return `${p} 被删除（原值 ${fmt(oldValue)}）`;
|
||||
|
||||
default:
|
||||
return `${p} 操作 ${op}`;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user