@xiaobuyu/nodesign 0.0.6 → 0.0.8

package/server/lib/state-triggers.js

@@ -0,0 +1,199 @@
+/**
+ * server/lib/state-triggers.js —— 状态表的条件触发器（2026-08-30）
+ *
+ * 「把会变的东西写在板上，设条件，需要的时候被动拿回来」的后半截。
+ * 前半截（值住在一张 markdown 表里）见 state-table.js。
+ *
+ * ## 声明住在正文里，不住在第二个存储里
+ *
+ * 触发器写成一段 ```nd:triggers 围栏，就在状态表那条板书的正文里 ——
+ * 跟 `nd:controls`（画布控件的声明）是同一个范式：**机器可读的声明住在用户看得见、
+ * 编得动的散文里**。这样用户能看到「现在挂着哪些条件」，也能自己删掉一条。
+ *
+ * 语法（一行一条，故意窄）：
+ *
+ *   ```nd:triggers
+ *   - [好感度_苏绵 >= 5] once -> 她开始主动找你说话了，这一拍给她一个开口的机会
+ *   - [体力 <= 2 && 时间 == 夜] on_cross -> 体力见底又是夜里：这一拍必须有代价
+ *   ```
+ *
+ * `&&` 是唯一的连接词（全都成立才算命中）。没有 `||`、没有括号 —— 那两样一进来
+ * 就得写真正的表达式解析器，而**模型拼错一个变量名时静默求值成 false** 是这条线
+ * 最怕的那种失效。窄语法换来的是：每一种写错都能当场指出来。
+ *
+ * ## 触发的是「穿越」，不是「为真」
+ *
+ * `好感度 >= 5` 一旦满足，之后每一拍都满足。按「为真就触发」写，它会每拍注一遍，
+ * 上线当天就变成噪音源。所以只有两档：
+ *   - `once`     命中一次就退休（一次性的剧情钩子）
+ *   - `on_cross` 每次**从假变真**才触发（会来回摆的条件，比如昼夜、体力）
+ *
+ * ## 沿状态（上一次是真是假）放 `.nd/`，这次是对的
+ *
+ * `.nd/` 在 gitignore 里，所以**玩法真相不能放那儿**（那是 state-table.js 头注
+ * 否掉 `.nd/vars.json` 的理由）。但沿状态是**派生记账**：丢了的代价只是一次
+ * 「上膛不击发」，不是丢故事状态。语义写死：
+ *   - 文件缺失 / 解析失败 → 按当前值重新上膛、**不击发**、log 一行
+ *   - `revertWorkspace` 不回滚它（gitignore），后果是回滚后已触发过的不会重触发 —— 可接受
+ *
+ * ## 求值点 = 注入点
+ *
+ * 只在 UserPromptSubmit 里求值（读盘上的表 + 盘上的沿状态，命中就写进这一轮的
+ * 状态块）。不在 set_vars 里求值攒到下一轮 —— 那样中间一次进程重启就静默吞掉一次
+ * 触发，正是「哑掉的机制不报错」那族病。
+ */
+
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { fingerprint } from '../engine/agent/hooks/turn-state-memory.js';
+
+const FENCE_RE = /^[ \t]*```[ \t]*nd:triggers[ \t]*$/;
+const FENCE_END_RE = /^[ \t]*```[ \t]*$/;
+/** - [<条件>] <mode> -> <话> */
+const LINE_RE = /^\s*-\s*\[([^\]]+)\]\s*(once|on_cross)\s*->\s*(.+?)\s*$/;
+const OPS = ['>=', '<=', '!=', '==', '>', '<'];
+
+export const LATCH_REL = '.nd/vars-latch.json';
+/** 一条触发器的话最多这么长：它是注给模型的一句提醒，不是一段剧本 */
+export const MESSAGE_MAX = 200;
+export const MAX_TRIGGERS = 24;
+
+/** 把一条条件文本拆成若干个比较（`&&` 连接，全都成立才算命中） */
+function parseCond(text) {
+  const parts = String(text).split('&&').map((p) => p.trim()).filter(Boolean);
+  if (!parts.length) return { error: '条件是空的' };
+  const cmps = [];
+  for (const p of parts) {
+    const op = OPS.find((o) => p.includes(o));
+    if (!op) return { error: `「${p}」里没有比较符（用 >= <= > < == != 其中之一）` };
+    const idx = p.indexOf(op);
+    const key = p.slice(0, idx).trim();
+    const value = p.slice(idx + op.length).trim();
+    if (!key) return { error: `「${p}」缺左边的键名` };
+    if (!value) return { error: `「${p}」缺右边的值` };
+    cmps.push({ key, op, value });
+  }
+  return { cmps };
+}
+
+/**
+ * 从正文里解析 ```nd:triggers 围栏。
+ * @returns {{ triggers: Array<{id,cmps,mode,message,raw}>, errors: string[] }}
+ *   errors 里每条都指得出是哪一行错在哪 —— 写错要能被看见，不能静默丢。
+ */
+export function parseTriggers(body) {
+  const lines = String(body || '').split(/\r?\n/);
+  const triggers = []; const errors = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const l = lines[i];
+    if (!inFence) { if (FENCE_RE.test(l)) inFence = true; continue; }
+    if (FENCE_END_RE.test(l)) { inFence = false; continue; }
+    if (!l.trim()) continue;
+    const m = LINE_RE.exec(l);
+    if (!m) {
+      errors.push(`第 ${i + 1} 行看不懂：${l.trim().slice(0, 60)}\n    （格式是 \`- [键 >= 值] once -> 要说的话\`，mode 只能是 once 或 on_cross）`);
+      continue;
+    }
+    const [, condText, mode, messageRaw] = m;
+    const { cmps, error } = parseCond(condText);
+    if (error) { errors.push(`第 ${i + 1} 行条件写错了：${error}`); continue; }
+    const message = messageRaw.slice(0, MESSAGE_MAX);
+    // id 只由「条件 + 档」决定：改那句提醒的措辞不该把沿状态重置掉
+    const id = fingerprint(`${cmps.map((c) => `${c.key}${c.op}${c.value}`).join('&&')}|${mode}`);
+    triggers.push({ id, cmps, mode, message, raw: l.trim() });
+    if (triggers.length >= MAX_TRIGGERS) {
+      errors.push(`触发器超过 ${MAX_TRIGGERS} 条，后面的没读 —— 挂太多等于没挂。`);
+      break;
+    }
+  }
+  if (inFence) errors.push('```nd:triggers 围栏没闭合，后面的行都没读。');
+  return { triggers, errors };
+}
+
+const NUM_RE = /^-?\d+(\.\d+)?$/;
+
+/**
+ * 求一个比较的值。
+ * @returns {{ v:boolean } | { error:string }}
+ *
+ * ⛔ 跨类型的大小比较**大声拒绝**，不隐式转换：`时间 >= 戌时` 按字典序比出来的
+ * 结果看着像那么回事，但它不是任何人想要的语义。钳住但要说 —— 这是 B+ 没有类型
+ * 系统换来的代价，只能在求值时付。
+ */
+function compare(cmp, rows) {
+  const row = rows.find((r) => r.key === cmp.key);
+  if (!row) return { error: `表里没有「${cmp.key}」这个键` };
+  const l = String(row.value).trim(); const r = String(cmp.value).trim();
+  const bothNum = NUM_RE.test(l) && NUM_RE.test(r);
+  if (cmp.op === '==') return { v: bothNum ? Number(l) === Number(r) : l === r };
+  if (cmp.op === '!=') return { v: bothNum ? Number(l) !== Number(r) : l !== r };
+  if (!bothNum) {
+    return { error: `「${cmp.key} ${cmp.op} ${cmp.value}」比不了：${NUM_RE.test(l) ? '右边' : '左边'}不是数字（大小比较只对数字生效；想比文字用 == 或 !=）` };
+  }
+  const a = Number(l); const b = Number(r);
+  if (cmp.op === '>=') return { v: a >= b };
+  if (cmp.op === '<=') return { v: a <= b };
+  if (cmp.op === '>') return { v: a > b };
+  return { v: a < b };
+}
+
+/**
+ * 求值一批触发器。**纯函数** —— 落盘由调用方做，好测。
+ *
+ * @param triggers parseTriggers 的产物
+ * @param rows     状态表的现值
+ * @param latch    上一次的沿状态 { [id]: { last:boolean, fired:number } }
+ * @param opts.fresh  true = 这是本项目第一次求值（沿状态文件不存在/坏了）
+ *                    → **上膛不击发**：按当前值记下来，一条都不触发
+ * @returns {{ fired:Array<{id,message,raw}>, latch:object, errors:string[], armed:number, retired:number }}
+ */
+export function evalTriggers(triggers, rows, latch = {}, { fresh = false } = {}) {
+  const next = {}; const fired = []; const errors = [];
+  let armed = 0; let retired = 0;
+  for (const t of triggers) {
+    const prev = latch[t.id] || null;
+    const firedCount = prev?.fired || 0;
+    if (t.mode === 'once' && firedCount > 0) { next[t.id] = prev; retired += 1; continue; }
+
+    let v = true; let bad = null;
+    for (const c of t.cmps) {
+      const r = compare(c, rows);
+      if (r.error) { bad = r.error; break; }
+      if (!r.v) { v = false; break; }
+    }
+    if (bad) {
+      errors.push(`${t.raw}\n    → ${bad}`);
+      next[t.id] = prev || { last: false, fired: firedCount };   // 求不出来不动沿状态
+      armed += 1;
+      continue;
+    }
+
+    const was = prev ? !!prev.last : false;
+    // 上膛不击发：第一次见到这条触发器（或沿状态丢了）只记录，不触发 ——
+    // 否则每次进程重启都会把所有当前为真的条件重放一遍
+    const shouldFire = !fresh && !!prev && v && !was;
+    if (shouldFire) fired.push({ id: t.id, message: t.message, raw: t.raw });
+    next[t.id] = { last: v, fired: firedCount + (shouldFire ? 1 : 0) };
+    if (t.mode === 'once' && next[t.id].fired > 0) retired += 1; else armed += 1;
+  }
+  return { fired, latch: next, errors, armed, retired };
+}
+
+export async function readLatch(sharedRoot) {
+  try {
+    const raw = await fs.readFile(path.join(sharedRoot, LATCH_REL), 'utf8');
+    const j = JSON.parse(raw);
+    if (!j || typeof j !== 'object') return { latch: {}, fresh: true };
+    return { latch: j, fresh: false };
+  } catch {
+    // 缺失或坏了都走 fresh：按当前值重新上膛、不击发
+    return { latch: {}, fresh: true };
+  }
+}
+
+export async function writeLatch(sharedRoot, latch) {
+  const abs = path.join(sharedRoot, LATCH_REL);
+  await fs.mkdir(path.dirname(abs), { recursive: true });
+  await fs.writeFile(abs, JSON.stringify(latch, null, 2), 'utf8');
+}

package/server/lib/task-scan.js

@@ -54,6 +54,11 @@ export const RESERVED_FILES = new Set([
   '.nd-project.json',  // 产物标记（形态兜底）
   '.gitignore',
   '.ndignore',
+  // 下面三个是基础设施不是用户产物，上墙就是「画布把自己的存档画在自己身上」
+  // 家族（08-24 清账补齐；ui-config.json 是黑板模式开关，曾以 .json 卡上墙）
+  'ui-config.json',
+  'spec.json',
+  'pending-changes.json',
 ]);
 
 /** 永远不扫的目录名（任何深度命中即剪枝） */
@@ -68,6 +73,19 @@ export const DRAFTS_DIR = '_drafts';
 
 export const NDIGNORE_FILE = '.ndignore';
 
+/**
+ * 读产物标记（`.nd-project.json`）。没有 / 读不动 → null。
+ * 2026-08-24 从 kinds/index.js 迁来：site.js 现在要按子目录读 marker（构建型
+ * 子目录站），住 kinds/index.js 会循环 import。kinds/index.js 原样 re-export。
+ */
+export async function readTaskMarker(root) {
+  try {
+    const raw = await fs.readFile(path.join(root, '.nd-project.json'), 'utf8');
+    const parsed = JSON.parse(raw);
+    return (parsed && typeof parsed === 'object') ? parsed : null;
+  } catch { return null; }
+}
+
 /** gitignore 子集 → RegExp。认不出的行按字面量处理（转义后精确匹配）。 */
 function compilePattern(line) {
   let pat = line.trim();

package/server/lib/tavern-json.js

@@ -152,3 +152,51 @@ export function fetchEntries(doc, 选) {
   }
   return 出;
 }
+
+/**
+ * PNG 角色卡（2026-08-25，四方世界卡案：iss 上报「不是合法 JSON：�PNG」）。
+ * 酒馆的卡就是一张 PNG，角色数据 base64 后塞在 tEXt 块里：V3 用键 `ccv3`，
+ * V2 用键 `chara`。两个都在时 ccv3 赢（V3 是超集）。不是卡的普通 PNG 返回 null。
+ */
+export function extractCardFromPng(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 16) return null;
+  if (buf.readUInt32BE(0) !== 0x89504e47) return null;   // \x89PNG
+  let off = 8;
+  const found = {};
+  while (off + 12 <= buf.length) {
+    const len = buf.readUInt32BE(off);
+    const type = buf.toString('latin1', off + 4, off + 8);
+    if (type === 'tEXt' && len > 0 && off + 8 + len <= buf.length) {
+      const data = buf.subarray(off + 8, off + 8 + len);
+      const nul = data.indexOf(0);
+      if (nul > 0) {
+        const key = data.toString('latin1', 0, nul);
+        if (key === 'ccv3' || key === 'chara') found[key] = data.subarray(nul + 1).toString('latin1');
+      }
+    }
+    off += 12 + len;
+    if (type === 'IEND') break;
+  }
+  const payload = found.ccv3 || found.chara;
+  if (!payload) return null;
+  try { return JSON.parse(Buffer.from(payload, 'base64').toString('utf8')); } catch { return null; }
+}
+
+/**
+ * 世界书条目全量（带正文）——给 export_book 机械搬运用。判断归 agent（常驻挑选、
+ * 引擎条目丢弃），搬运归机器（375 条 61.8 万字符不该流经上下文）。
+ */
+export function listBookEntries(doc) {
+  const kind = detectKind(doc);
+  const book = kind === 'lorebook' ? doc : (doc?.data?.character_book || doc?.character_book);
+  if (!book) return [];
+  const list = Array.isArray(book.entries) ? book.entries : Object.values(book.entries || {});
+  return list.map((e, i) => ({
+    id: String(e.uid ?? e.id ?? i),
+    名字: e.comment || e.name || (Array.isArray(e.key) ? e.key.join('/') : '') || `条目${i + 1}`,
+    触发: Array.isArray(e.key) ? e.key : (Array.isArray(e.keys) ? e.keys : []),
+    常驻: !!(e.constant),
+    停用: e.enabled === false || e.disable === true,
+    正文: String(e.content || ''),
+  }));
+}

package/server/lib/user-uploads.js

@@ -0,0 +1,88 @@
+/**
+ * lib/user-uploads.js —— 用户上传件的落点与增删查（2026-08-28）
+ *
+ * ## 为什么单独挪出来
+ *
+ * 以前上传一律落 `shared/assets/`，而 `assets/` 在画布的文件夹清单里是**基础设施
+ * 目录**（RESERVED_DIRS / NOT_A_FOLDER），于是每个上传件都 homeOf 到根 —— 用户拖
+ * 一张参考图进来，它就直接摊在桌面上跟产物混作一堆。用户原话：「有一件事很膈应」。
+ *
+ * ## 修法：给它一个真目录，不是在画布上造一个虚拟分组
+ *
+ * 文件夹在这套体系里从来就等于磁盘上的真目录（见 api/assets.js 的收纳文件夹注释）。
+ * 凭空多一种只存在于画布上的分组，「文件系统即真相」这条就破了。真目录还白拿了
+ * 整套现成能力：文件夹卡、拖进拖出、改名、MoveTo、agent 的 mv。
+ *
+ * ⚠️ 老项目 `assets/` 里已有的上传件**不迁**：物件 id 就是路径，搬家等于改 id，
+ * 得连 board.json 绑定一起转发。它们照旧扫成 upload 摊在根上 —— 所以这里的列举和
+ * 删除都**两个落点都认**，新的优先。
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+/** 上传落点（工作区相对）。画布上就显示成这个名字的文件夹 */
+export const USER_UPLOAD_DIR = '用户内容';
+
+/** 两个落点，新的在前 —— 列举顺序、删除尝试顺序都按它 */
+const LOOKUP_DIRS = [USER_UPLOAD_DIR, 'assets'];
+
+/** 上传写到哪（不存在就建） */
+export async function ensureUploadDir(sharedRoot) {
+  const dir = path.join(sharedRoot, USER_UPLOAD_DIR);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+/** agent / 前端拿到的引用路径。cwd 是 sessions/<sid>/，所以 `../../shared/<dir>/<name>` */
+export function uploadRefPath(dirRel, filename) {
+  return `../../shared/${dirRel}/${filename}`;
+}
+
+/**
+ * 列两个落点下的上传件（只看顶层文件，子目录归画布的文件夹机制管）。
+ * @returns {Promise<Array<{path, name, dir, size, mtime}>>} 按 mtime 新→旧
+ */
+export async function listUploadedAssets(sharedRoot) {
+  const out = [];
+  for (const dirRel of LOOKUP_DIRS) {
+    let entries;
+    try {
+      entries = await fs.readdir(path.join(sharedRoot, dirRel), { withFileTypes: true });
+    } catch (err) {
+      if (err.code === 'ENOENT') continue;
+      throw err;
+    }
+    for (const e of entries) {
+      if (!e.isFile()) continue;
+      let stat;
+      try { stat = await fs.stat(path.join(sharedRoot, dirRel, e.name)); } catch { continue; }
+      out.push({
+        path: uploadRefPath(dirRel, e.name), name: e.name, dir: dirRel,
+        size: stat.size, mtime: stat.mtime.toISOString(),
+      });
+    }
+  }
+  out.sort((a, b) => (a.mtime < b.mtime ? 1 : -1));
+  return out;
+}
+
+/**
+ * 删一个上传件。两个落点依次试，**每个目录各自 resolve 复核**（别拿一个目录的
+ * 判据去删另一个目录的文件）。
+ * @returns {Promise<'deleted'|'not_found'|'invalid'>}
+ */
+export async function deleteUploadedAsset(sharedRoot, filename) {
+  for (const dirRel of LOOKUP_DIRS) {
+    const dirAbs = path.join(sharedRoot, dirRel);
+    const filePath = path.resolve(dirAbs, filename);
+    if (!filePath.startsWith(dirAbs + path.sep)) return 'invalid';
+    try {
+      await fs.unlink(filePath);
+      return 'deleted';
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+  }
+  return 'not_found';
+}

package/server/projects/board-limits.js

@@ -3,10 +3,12 @@
  * board-store（写盘前查字节数）和 board-sanitize（逐类计数）都要，单独一份免循环依赖。
  */
 export const DEFAULT_BOARD_SIZE = { w: 4000, h: 2600 };
-export const MAX_BOARD_BYTES = 512 * 1024;
-export const MAX_OBJECTS = 2000;
+export const MAX_BOARD_BYTES = 2 * 1024 * 1024;   // 08-25 放大（板是整读整写 JSON，这是失控兜底不是风格闸）
+export const MAX_OBJECTS = 8000;
 export const MAX_ZONES = 200;
 // 关系线上限。取值理由：一块板上人能看懂的线远少于这个数，1000 是防脱缰
 // （agent 循环里连画）的闸门，不是设计目标。超了直接不收，不做淘汰 ——
 // 静默丢最旧的会让"我明明画了"变成玄学。
-export const MAX_BINDINGS = 1000;
+export const MAX_BINDINGS = 4000;
+export const MAX_LANES = 60;      // 线（lane 注册表）：几十条线的脑图已是极限读感
+export const MAX_SHEETS = 200;    // 纸（sheet 注册表，2026-08-29 纸范式）：一纸一屏，200 张已是长篇连载量级