dsh-memorytree-rule 0.0.0-stage → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +42 -0
- package/LICENSE +21 -0
- package/README.md +144 -3
- package/bin/mt.mjs +589 -0
- package/client.js +227 -0
- package/cordis.patch.yml +16 -0
- package/docs/DETAIL.md +69 -0
- package/docs/DETAIL.svg +85 -0
- package/docs/EMOTION.md +101 -0
- package/examples/AGENTS.demo.md +22 -0
- package/examples/AGENTS.template.md +212 -0
- package/icon.svg +17 -0
- package/index.js +418 -0
- package/lib/board.mjs +1113 -0
- package/lib/cards.mjs +56 -0
- package/lib/daily.mjs +140 -0
- package/lib/db.mjs +84 -0
- package/lib/demo.mjs +161 -0
- package/lib/diary.mjs +92 -0
- package/lib/emotion.mjs +474 -0
- package/lib/import-legacy.mjs +167 -0
- package/lib/ingest.mjs +279 -0
- package/lib/levels.mjs +40 -0
- package/lib/paths.mjs +85 -0
- package/lib/report.mjs +2130 -0
- package/lib/rules.mjs +635 -0
- package/lib/runtime.mjs +232 -0
- package/lib/schema.mjs +363 -0
- package/lib/search.mjs +264 -0
- package/lib/store.mjs +1334 -0
- package/lib/text.mjs +161 -0
- package/lib/tools.mjs +962 -0
- package/lib/vector.mjs +51 -0
- package/locale/en.json +7 -0
- package/locale/zh.json +7 -0
- package/package.json +81 -6
- package/tests/emotion.test.mjs +230 -0
- package/tests/memory-tree.test.mjs +620 -0
- package/tests/regressions.test.mjs +834 -0
- package/tests/renumber.test.mjs +276 -0
- package/tests/trunk-bucket.test.mjs +225 -0
|
@@ -0,0 +1,834 @@
|
|
|
1
|
+
// tests/regressions.test.mjs — 发布前查漏补缺的回归测试。
|
|
2
|
+
// 覆盖:跨工作区隔离、作用域过滤、事务回滚、正文上限、halfLife、主干 active 封堵、正本逐字写入。
|
|
3
|
+
import test from "node:test";
|
|
4
|
+
import assert from "node:assert/strict";
|
|
5
|
+
import fs from "node:fs";
|
|
6
|
+
import os from "node:os";
|
|
7
|
+
import path from "node:path";
|
|
8
|
+
import { execFileSync, spawnSync } from "node:child_process";
|
|
9
|
+
import { fileURLToPath } from "node:url";
|
|
10
|
+
import { DatabaseSync } from "node:sqlite";
|
|
11
|
+
import { migrate, SCHEMA_VERSION } from "../lib/schema.mjs";
|
|
12
|
+
import { openMemoryDb } from "../lib/db.mjs";
|
|
13
|
+
import { MemoryStore } from "../lib/store.mjs";
|
|
14
|
+
import { syncTrunk, parseAgents } from "../lib/ingest.mjs";
|
|
15
|
+
import { runBoardAction } from "../lib/board.mjs";
|
|
16
|
+
import { applyDailyDecisions } from "../lib/daily.mjs";
|
|
17
|
+
import { exportTaskCards } from "../lib/cards.mjs";
|
|
18
|
+
|
|
19
|
+
function makeStore() {
|
|
20
|
+
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mt-reg-"));
|
|
21
|
+
const db = openMemoryDb(path.join(dir, "memory.db"));
|
|
22
|
+
const store = new MemoryStore(db, { clock: () => Date.now() });
|
|
23
|
+
return {
|
|
24
|
+
dir,
|
|
25
|
+
db,
|
|
26
|
+
store,
|
|
27
|
+
cleanup() {
|
|
28
|
+
try {
|
|
29
|
+
db.close();
|
|
30
|
+
} catch {
|
|
31
|
+
/* 忽略 */
|
|
32
|
+
}
|
|
33
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
34
|
+
},
|
|
35
|
+
};
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
test("跨工作区隔离:同 subject 任务卡互不取代", () => {
|
|
39
|
+
const { store, cleanup } = makeStore();
|
|
40
|
+
try {
|
|
41
|
+
const a = store.add({ layer: "task", scope: "workspace:aaa", subject: "same", text: "A 的卡" }).node;
|
|
42
|
+
const b = store.add({ layer: "task", scope: "workspace:bbb", subject: "same", text: "B 的卡" }).node;
|
|
43
|
+
assert.equal(store.get(a.id).status, "active");
|
|
44
|
+
assert.equal(store.get(b.id).status, "active");
|
|
45
|
+
} finally {
|
|
46
|
+
cleanup();
|
|
47
|
+
}
|
|
48
|
+
});
|
|
49
|
+
|
|
50
|
+
test("appendToTaskCard 只追加到同作用域", () => {
|
|
51
|
+
const { store, cleanup } = makeStore();
|
|
52
|
+
try {
|
|
53
|
+
const a = store.appendToTaskCard({ scope: "workspace:aaa", subject: "same", text: "A1" }).node;
|
|
54
|
+
const b = store.appendToTaskCard({ scope: "workspace:bbb", subject: "same", text: "B1" }).node;
|
|
55
|
+
assert.match(store.get(a.id).text, /A1/);
|
|
56
|
+
assert.doesNotMatch(store.get(a.id).text, /B1/);
|
|
57
|
+
assert.match(store.get(b.id).text, /B1/);
|
|
58
|
+
} finally {
|
|
59
|
+
cleanup();
|
|
60
|
+
}
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
test("replaceCard 缺省作用域只动 user 卡", () => {
|
|
64
|
+
const { store, cleanup } = makeStore();
|
|
65
|
+
try {
|
|
66
|
+
const user = store.add({ layer: "task", scope: "user", subject: "same", text: "user 旧卡" }).node;
|
|
67
|
+
const ws = store.add({ layer: "task", scope: "workspace:aaa", subject: "same", text: "ws 旧卡" }).node;
|
|
68
|
+
const replaced = store.replaceCard("same", { scope: "workspace:aaa", layer: "task", text: "ws 新卡" }).node;
|
|
69
|
+
assert.equal(store.get(user.id).status, "active");
|
|
70
|
+
assert.equal(store.get(ws.id).status, "superseded");
|
|
71
|
+
assert.equal(store.get(replaced.id).scope, "workspace:aaa");
|
|
72
|
+
} finally {
|
|
73
|
+
cleanup();
|
|
74
|
+
}
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
test("get 支持作用域过滤;supersede 拒绝跨作用域", () => {
|
|
78
|
+
const { store, cleanup } = makeStore();
|
|
79
|
+
try {
|
|
80
|
+
const ws = store.add({ layer: "leaf", scope: "workspace:aaa", text: "私有配置" }).node;
|
|
81
|
+
assert.equal(store.get(ws.id, { scope: ["user"] }), null);
|
|
82
|
+
assert.equal(store.get(ws.id, { scope: ["workspace:aaa"] }).id, ws.id);
|
|
83
|
+
assert.throws(
|
|
84
|
+
() => store.supersede([ws.id], { layer: "leaf", scope: "workspace:bbb", text: "别的区" }),
|
|
85
|
+
/跨作用域/,
|
|
86
|
+
);
|
|
87
|
+
} finally {
|
|
88
|
+
cleanup();
|
|
89
|
+
}
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
test("超过 20000 字的正文报错且不落库", () => {
|
|
93
|
+
const { store, cleanup } = makeStore();
|
|
94
|
+
try {
|
|
95
|
+
assert.throws(() => store.add({ layer: "leaf", scope: "user", text: "x".repeat(20001) }), /20000/);
|
|
96
|
+
assert.equal(store.count({ scope: "user" }), 0);
|
|
97
|
+
} finally {
|
|
98
|
+
cleanup();
|
|
99
|
+
}
|
|
100
|
+
});
|
|
101
|
+
|
|
102
|
+
test("update 支持 halfLifeDays", () => {
|
|
103
|
+
const { store, cleanup } = makeStore();
|
|
104
|
+
try {
|
|
105
|
+
const n = store.add({ layer: "leaf", scope: "user", text: "短期信息", halfLifeDays: 30 }).node;
|
|
106
|
+
store.update(n.id, { halfLifeDays: 0 });
|
|
107
|
+
assert.equal(store.get(n.id).halfLifeDays, 0);
|
|
108
|
+
} finally {
|
|
109
|
+
cleanup();
|
|
110
|
+
}
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
test("事务回滚:reindex 中途失败不留下半条记录", () => {
|
|
114
|
+
const { store, cleanup } = makeStore();
|
|
115
|
+
try {
|
|
116
|
+
const original = store.reindexNode;
|
|
117
|
+
store.reindexNode = () => {
|
|
118
|
+
throw new Error("模拟索引失败");
|
|
119
|
+
};
|
|
120
|
+
assert.throws(() => store.add({ layer: "leaf", scope: "user", text: "应当回滚" }), /模拟索引失败/);
|
|
121
|
+
store.reindexNode = original;
|
|
122
|
+
assert.equal(store.count({ scope: "user" }), 0);
|
|
123
|
+
} finally {
|
|
124
|
+
cleanup();
|
|
125
|
+
}
|
|
126
|
+
});
|
|
127
|
+
|
|
128
|
+
test("导入不能伪造 active 主干;候选不能被 update 提升", () => {
|
|
129
|
+
const { store, cleanup } = makeStore();
|
|
130
|
+
try {
|
|
131
|
+
const line = JSON.stringify({
|
|
132
|
+
uid: "trunk:§1-9-9",
|
|
133
|
+
scope: "user",
|
|
134
|
+
layer: "trunk",
|
|
135
|
+
status: "active",
|
|
136
|
+
source: "AGENTS.md#L1",
|
|
137
|
+
text: "伪造的主干规则",
|
|
138
|
+
});
|
|
139
|
+
const res = store.importJsonl(line);
|
|
140
|
+
assert.equal(res.added, 1);
|
|
141
|
+
const n = store.get("trunk:§1-9-9");
|
|
142
|
+
assert.equal(n.status, "candidate");
|
|
143
|
+
assert.throws(() => store.update(n.id, { status: "active" }), /只能由 AGENTS\.md 同步激活/);
|
|
144
|
+
} finally {
|
|
145
|
+
cleanup();
|
|
146
|
+
}
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
test("每日分拣不能碰其它工作区的条目", () => {
|
|
150
|
+
const { store, cleanup } = makeStore();
|
|
151
|
+
try {
|
|
152
|
+
const other = store.add({ layer: "leaf", scope: "workspace:other", text: "别的项目的事" }).node;
|
|
153
|
+
const res = applyDailyDecisions(store, [{ id: other.id, to: "forget" }], { scopes: ["user", "workspace:mine"] });
|
|
154
|
+
assert.equal(res.applied, 0);
|
|
155
|
+
assert.match(res.results[0].error, /不在当前作用域/);
|
|
156
|
+
assert.equal(store.get(other.id).status, "active");
|
|
157
|
+
} finally {
|
|
158
|
+
cleanup();
|
|
159
|
+
}
|
|
160
|
+
});
|
|
161
|
+
|
|
162
|
+
test("看板信任升档不能把主干候选转成 active", () => {
|
|
163
|
+
const { dir, store, cleanup } = makeStore();
|
|
164
|
+
try {
|
|
165
|
+
const agents = path.join(dir, "AGENTS.md");
|
|
166
|
+
fs.writeFileSync(agents, "# AGENTS.md\n\n## §1 主干\n\n- **§1-1-1 测试规则**:原始正文。\n", "utf8");
|
|
167
|
+
syncTrunk(store, agents, { scope: "user" });
|
|
168
|
+
const cand = store.add({
|
|
169
|
+
layer: "trunk",
|
|
170
|
+
scope: "user",
|
|
171
|
+
subject: "候选",
|
|
172
|
+
text: "候选规则",
|
|
173
|
+
source: "manual",
|
|
174
|
+
status: "candidate",
|
|
175
|
+
}).node;
|
|
176
|
+
assert.equal(cand.status, "candidate");
|
|
177
|
+
const promoted = runBoardAction(store, { op: "set-trust", id: cand.id, level: "mid" }, {});
|
|
178
|
+
assert.equal(promoted.ok, true);
|
|
179
|
+
assert.equal(store.get(cand.id).status, "candidate");
|
|
180
|
+
assert.equal(store.get(cand.id).trust, 80);
|
|
181
|
+
} finally {
|
|
182
|
+
cleanup();
|
|
183
|
+
}
|
|
184
|
+
});
|
|
185
|
+
|
|
186
|
+
test("写 AGENTS.md 不脱敏:邮箱与长数字逐字保留", () => {
|
|
187
|
+
const { dir, store, cleanup } = makeStore();
|
|
188
|
+
try {
|
|
189
|
+
const agents = path.join(dir, "AGENTS.md");
|
|
190
|
+
fs.writeFileSync(agents, "# AGENTS.md\n\n## §1 主干\n\n- **§1-1-1 测试规则**:原始正文。\n", "utf8");
|
|
191
|
+
const options = { agentsPath: agents, backupDir: path.join(dir, "backups") };
|
|
192
|
+
syncTrunk(store, agents, { scope: "user" });
|
|
193
|
+
const tr = store.list({ layers: ["trunk"], status: "active" })[0];
|
|
194
|
+
const body = "联系 owner@example.com,工单 1380013800000。";
|
|
195
|
+
const written = runBoardAction(store, { op: "write-trunk", id: tr.id, text: body, confirm: true }, options);
|
|
196
|
+
assert.equal(written.ok, true);
|
|
197
|
+
assert.match(fs.readFileSync(agents, "utf8"), /owner@example\.com/);
|
|
198
|
+
assert.match(fs.readFileSync(agents, "utf8"), /1380013800000/);
|
|
199
|
+
assert.match(store.get(tr.id).text, /owner@example\.com/);
|
|
200
|
+
assert.match(store.get(tr.id).text, /1380013800000/);
|
|
201
|
+
assert.doesNotMatch(fs.readFileSync(agents, "utf8"), /\*\*\*/);
|
|
202
|
+
} finally {
|
|
203
|
+
cleanup();
|
|
204
|
+
}
|
|
205
|
+
});
|
|
206
|
+
|
|
207
|
+
test("脱敏不误伤路径与 13 位时间戳,仍拦手机号/云密钥", () => {
|
|
208
|
+
const { store, cleanup } = makeStore();
|
|
209
|
+
try {
|
|
210
|
+
const text = "路径 C:\\Users\\example\\a.txt,时间 1763300000000,电话 13800138000,AWS AKIAABCDEFGHIJKLMNOP。";
|
|
211
|
+
const node = store.add({ layer: "leaf", scope: "user", text }).node;
|
|
212
|
+
assert.match(node.text, /C:\\Users\\example\\a\.txt/);
|
|
213
|
+
assert.match(node.text, /1763300000000/);
|
|
214
|
+
assert.doesNotMatch(node.text, /13800138000/);
|
|
215
|
+
assert.doesNotMatch(node.text, /AKIAABCDEFGHIJKLMNOP/);
|
|
216
|
+
} finally {
|
|
217
|
+
cleanup();
|
|
218
|
+
}
|
|
219
|
+
});
|
|
220
|
+
|
|
221
|
+
test("标题参与检索:正文不含查询词也能命中", async () => {
|
|
222
|
+
const { store, cleanup } = makeStore();
|
|
223
|
+
try {
|
|
224
|
+
const { searchMemory } = await import("../lib/search.mjs");
|
|
225
|
+
store.add({ layer: "leaf", scope: "user", title: "独有标题词", text: "正文完全没有那个词。" });
|
|
226
|
+
const res = searchMemory(store, { query: "独有标题词", scopes: ["user"], limit: 5 });
|
|
227
|
+
assert.equal(res.hits.length >= 1, true);
|
|
228
|
+
assert.match(res.hits[0].title, /独有标题词/);
|
|
229
|
+
} finally {
|
|
230
|
+
cleanup();
|
|
231
|
+
}
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
test("日记写入也会脱敏手机号与邮箱", () => {
|
|
235
|
+
const a = makeStore();
|
|
236
|
+
try {
|
|
237
|
+
a.store.diaryAdd("2026-11-17", "联系 13800138000 或 owner@example.com", "manual");
|
|
238
|
+
const row = a.store.diaryGet("2026-11-17");
|
|
239
|
+
assert.doesNotMatch(row.text, /13800138000/);
|
|
240
|
+
assert.doesNotMatch(row.text, /owner@example\.com/);
|
|
241
|
+
assert.match(row.text, /\*\*\*/);
|
|
242
|
+
} finally {
|
|
243
|
+
a.cleanup();
|
|
244
|
+
}
|
|
245
|
+
});
|
|
246
|
+
|
|
247
|
+
test("导出/导入包含日记与主干大标题", () => {
|
|
248
|
+
const a = makeStore();
|
|
249
|
+
const b = makeStore();
|
|
250
|
+
try {
|
|
251
|
+
a.store.add({ layer: "leaf", scope: "user", text: "一条记忆" });
|
|
252
|
+
a.store.diaryAdd("2026-11-17", "今天的日记", "auto");
|
|
253
|
+
a.store.setTrunkBucket("trunk:§1-1-1", "机械组");
|
|
254
|
+
const jsonl = a.store.exportJsonl();
|
|
255
|
+
const res = b.store.importJsonl(jsonl, { mode: "merge" });
|
|
256
|
+
assert.equal(res.added, 1);
|
|
257
|
+
assert.equal(res.diary, 1);
|
|
258
|
+
assert.equal(res.buckets, 1);
|
|
259
|
+
assert.equal(b.store.diaryGet("2026-11-17").text, "今天的日记");
|
|
260
|
+
assert.equal(b.store.trunkBuckets()["trunk:§1-1-1"], "机械组");
|
|
261
|
+
const again = b.store.importJsonl(jsonl, { mode: "merge" });
|
|
262
|
+
assert.equal(again.diary, 0);
|
|
263
|
+
assert.equal(again.buckets, 1);
|
|
264
|
+
} finally {
|
|
265
|
+
a.cleanup();
|
|
266
|
+
b.cleanup();
|
|
267
|
+
}
|
|
268
|
+
});
|
|
269
|
+
|
|
270
|
+
test("导出/导入恢复 supersededBy 链", () => {
|
|
271
|
+
const a = makeStore();
|
|
272
|
+
const b = makeStore();
|
|
273
|
+
try {
|
|
274
|
+
const old = a.store.add({ layer: "leaf", scope: "user", text: "旧口径正文" }).node;
|
|
275
|
+
const merged = a.store.supersede([old.id], { layer: "leaf", scope: "user", text: "新口径正文" }).node;
|
|
276
|
+
const res = b.store.importJsonl(a.store.exportJsonl(), { mode: "merge" });
|
|
277
|
+
assert.equal(res.added, 2);
|
|
278
|
+
const importedOld = b.store.get(old.uid);
|
|
279
|
+
const importedNew = b.store.get(merged.uid);
|
|
280
|
+
assert.equal(importedOld.status, "superseded");
|
|
281
|
+
assert.equal(importedOld.supersededBy, importedNew.id);
|
|
282
|
+
assert.equal(importedOld.createdAt, a.store.get(old.uid).createdAt);
|
|
283
|
+
} finally {
|
|
284
|
+
a.cleanup();
|
|
285
|
+
b.cleanup();
|
|
286
|
+
}
|
|
287
|
+
});
|
|
288
|
+
|
|
289
|
+
test("统计支持作用域过滤", () => {
|
|
290
|
+
const { store, cleanup } = makeStore();
|
|
291
|
+
try {
|
|
292
|
+
store.add({ layer: "leaf", scope: "user", text: "用户的" });
|
|
293
|
+
store.add({ layer: "leaf", scope: "workspace:x", text: "工作区的" });
|
|
294
|
+
assert.equal(store.stats(["user"]).total, 1);
|
|
295
|
+
assert.equal(store.stats(["workspace:x"]).total, 1);
|
|
296
|
+
assert.equal(store.stats().total, 2);
|
|
297
|
+
} finally {
|
|
298
|
+
cleanup();
|
|
299
|
+
}
|
|
300
|
+
});
|
|
301
|
+
|
|
302
|
+
test("active 主干只能由 AGENTS.md 同步修改/遗忘", () => {
|
|
303
|
+
const { dir, store, cleanup } = makeStore();
|
|
304
|
+
try {
|
|
305
|
+
const agents = path.join(dir, "AGENTS.md");
|
|
306
|
+
fs.writeFileSync(agents, "# AGENTS.md\n\n## §1 主干\n\n- **§1-1-1 测试规则**:原始正文。\n", "utf8");
|
|
307
|
+
syncTrunk(store, agents, { scope: "user" });
|
|
308
|
+
const tr = store.list({ layers: ["trunk"], status: "active" })[0];
|
|
309
|
+
assert.throws(() => store.update(tr.id, { text: "偷偷改正文" }), /只能由 AGENTS\.md 同步修改/);
|
|
310
|
+
assert.throws(() => store.forget(tr.id), /不能直接遗忘 active 主干/);
|
|
311
|
+
assert.throws(() => store.supersede([tr.id], { layer: "leaf", scope: "user", text: "取代" }), /不能取代 active 主干/);
|
|
312
|
+
assert.equal(store.get(tr.id).text, "测试规则:原始正文。");
|
|
313
|
+
store.update(tr.id, { text: "同步改正文" }, { allowActiveTrunk: true });
|
|
314
|
+
assert.equal(store.get(tr.id).text, "同步改正文");
|
|
315
|
+
} finally {
|
|
316
|
+
cleanup();
|
|
317
|
+
}
|
|
318
|
+
});
|
|
319
|
+
|
|
320
|
+
test("导入拒绝 layer 与 uid 前缀不一致的条目", () => {
|
|
321
|
+
const { store, cleanup } = makeStore();
|
|
322
|
+
try {
|
|
323
|
+
const res = store.importJsonl(
|
|
324
|
+
JSON.stringify({ uid: "trunk:§1-1-1", layer: "leaf", scope: "user", text: "伪造编号" }) + "\n",
|
|
325
|
+
{ mode: "merge" },
|
|
326
|
+
);
|
|
327
|
+
assert.equal(res.added, 0);
|
|
328
|
+
assert.equal(res.skipped, 1);
|
|
329
|
+
assert.equal(store.get("trunk:§1-1-1"), null);
|
|
330
|
+
} finally {
|
|
331
|
+
cleanup();
|
|
332
|
+
}
|
|
333
|
+
});
|
|
334
|
+
|
|
335
|
+
test("AGENTS.md 编号重复时拒绝同步,不覆盖现有规则", () => {
|
|
336
|
+
const { dir, store, cleanup } = makeStore();
|
|
337
|
+
try {
|
|
338
|
+
const agents = path.join(dir, "AGENTS.md");
|
|
339
|
+
const body =
|
|
340
|
+
"# AGENTS.md\n\n## §1 主干\n\n- **§1-1-1 规则甲**:甲甲甲甲。\n- **§1-1-1 规则乙**:乙乙乙乙。\n";
|
|
341
|
+
fs.writeFileSync(agents, body, "utf8");
|
|
342
|
+
const res = syncTrunk(store, agents, { scope: "user" });
|
|
343
|
+
assert.equal(res.ok, false);
|
|
344
|
+
assert.match(res.error, /编号重复/);
|
|
345
|
+
assert.equal(store.list({ layers: ["trunk"], status: "active" }).length, 0);
|
|
346
|
+
} finally {
|
|
347
|
+
cleanup();
|
|
348
|
+
}
|
|
349
|
+
});
|
|
350
|
+
|
|
351
|
+
test("空作用域检索返回空结果而不是 SQL 报错", async () => {
|
|
352
|
+
const { store, cleanup } = makeStore();
|
|
353
|
+
try {
|
|
354
|
+
const { searchMemory } = await import("../lib/search.mjs");
|
|
355
|
+
const res = searchMemory(store, { query: "任意", scopes: [], limit: 5 });
|
|
356
|
+
assert.equal(res.hits.length, 0);
|
|
357
|
+
assert.match(res.reason, /没有指定任何作用域/);
|
|
358
|
+
assert.deepEqual(store.list({ scope: [] }), []);
|
|
359
|
+
assert.equal(store.count({ scope: [] }), 0);
|
|
360
|
+
} finally {
|
|
361
|
+
cleanup();
|
|
362
|
+
}
|
|
363
|
+
});
|
|
364
|
+
|
|
365
|
+
test("workspaceScope:Linux 保留大小写,Windows/macOS 归一", async () => {
|
|
366
|
+
const { workspaceScope } = await import("../lib/paths.mjs");
|
|
367
|
+
const a = workspaceScope("/tmp/Alpha");
|
|
368
|
+
const b = workspaceScope("/tmp/alpha");
|
|
369
|
+
if (process.platform === "linux") {
|
|
370
|
+
assert.notEqual(a, b);
|
|
371
|
+
} else {
|
|
372
|
+
assert.equal(a, b);
|
|
373
|
+
}
|
|
374
|
+
});
|
|
375
|
+
|
|
376
|
+
test("导入备份不会覆盖已激活的主干规则(跳过而不是整批失败)", () => {
|
|
377
|
+
const { store, cleanup } = makeStore();
|
|
378
|
+
try {
|
|
379
|
+
const node = store.add({ layer: "trunk", scope: "user", text: "主干规则正文,至少四个字。", title: "主干规则" }).node;
|
|
380
|
+
store.update(node.id, { status: "active" }, { allowActiveTrunk: true });
|
|
381
|
+
const jsonl = store.exportJsonl();
|
|
382
|
+
const res = store.importJsonl(jsonl, { mode: "update" });
|
|
383
|
+
assert.equal(res.skipped >= 1, true, JSON.stringify(res));
|
|
384
|
+
assert.equal(store.get(node.id).status, "active");
|
|
385
|
+
} finally {
|
|
386
|
+
cleanup();
|
|
387
|
+
}
|
|
388
|
+
});
|
|
389
|
+
|
|
390
|
+
test("显式取代:允许 user 与当前工作区互换,仍挡住其它工作区", () => {
|
|
391
|
+
const { store, cleanup } = makeStore();
|
|
392
|
+
try {
|
|
393
|
+
const note = store.add({ layer: "leaf", scope: "user", text: "用户级观察,后续并进任务卡。" }).node;
|
|
394
|
+
const created = store.supersede(
|
|
395
|
+
[note.id],
|
|
396
|
+
{ layer: "task", scope: "workspace:mine", subject: "merge", text: "合并后的任务卡正文。" },
|
|
397
|
+
{ scopes: ["user", "workspace:mine"] },
|
|
398
|
+
);
|
|
399
|
+
assert.equal(created.node.scope, "workspace:mine");
|
|
400
|
+
assert.equal(store.get(note.id).status, "superseded");
|
|
401
|
+
|
|
402
|
+
const foreign = store.add({ layer: "leaf", scope: "workspace:other", text: "别的工作区的条目。" }).node;
|
|
403
|
+
assert.throws(
|
|
404
|
+
() => store.supersede([foreign.id], { layer: "task", scope: "workspace:mine", text: "不该成功。" }, { scopes: ["user", "workspace:mine"] }),
|
|
405
|
+
/不能跨作用域取代/,
|
|
406
|
+
);
|
|
407
|
+
assert.equal(store.get(foreign.id).status, "active");
|
|
408
|
+
} finally {
|
|
409
|
+
cleanup();
|
|
410
|
+
}
|
|
411
|
+
});
|
|
412
|
+
|
|
413
|
+
test("每日分拣:工作区判断叶可以提升为 user 主干候选", () => {
|
|
414
|
+
const { store, cleanup } = makeStore();
|
|
415
|
+
try {
|
|
416
|
+
const leaf = store.add({ layer: "leaf", scope: "workspace:mine", text: "这条观察值得进主干候选。" }).node;
|
|
417
|
+
const res = applyDailyDecisions(
|
|
418
|
+
store,
|
|
419
|
+
[{ id: leaf.id, to: "trunk", title: "候选规则", text: "候选规则正文,至少四个字。" }],
|
|
420
|
+
{ scopes: ["workspace:mine"] },
|
|
421
|
+
);
|
|
422
|
+
assert.equal(res.applied, 1, JSON.stringify(res.results));
|
|
423
|
+
assert.equal(res.results[0].ok, true, res.results[0].error);
|
|
424
|
+
const created = store.get(res.results[0].newId);
|
|
425
|
+
assert.equal(created.layer, "trunk");
|
|
426
|
+
assert.equal(created.scope, "user");
|
|
427
|
+
assert.equal(created.status, "candidate");
|
|
428
|
+
} finally {
|
|
429
|
+
cleanup();
|
|
430
|
+
}
|
|
431
|
+
});
|
|
432
|
+
|
|
433
|
+
test("v0 旧库缺列:migrate 补齐 node 列并设置当前版本", () => { const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mt-v0-"));
|
|
434
|
+
const db = new DatabaseSync(path.join(dir, "old.db"));
|
|
435
|
+
try {
|
|
436
|
+
db.exec("CREATE TABLE node (id INTEGER PRIMARY KEY AUTOINCREMENT, text TEXT NOT NULL)");
|
|
437
|
+
db.exec("INSERT INTO node (text) VALUES ('旧库里的第一条记忆'), ('旧库里的第二条记忆')");
|
|
438
|
+
const version = migrate(db);
|
|
439
|
+
assert.equal(version, SCHEMA_VERSION);
|
|
440
|
+
const cols = new Set(db.prepare("PRAGMA table_info(node)").all().map((c) => c.name));
|
|
441
|
+
for (const name of ["uid", "scope", "layer", "status", "checksum", "ts", "created_at", "updated_at"]) {
|
|
442
|
+
assert.ok(cols.has(name), "缺少列 " + name);
|
|
443
|
+
}
|
|
444
|
+
const uids = db.prepare("SELECT uid FROM node ORDER BY id").all().map((r) => r.uid);
|
|
445
|
+
assert.equal(new Set(uids).size, uids.length, "补齐后的 uid 必须唯一");
|
|
446
|
+
assert.equal(db.prepare("PRAGMA user_version").get().user_version, SCHEMA_VERSION);
|
|
447
|
+
} finally {
|
|
448
|
+
db.close();
|
|
449
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
450
|
+
}
|
|
451
|
+
});
|
|
452
|
+
|
|
453
|
+
test("脱敏补充:GitHub PAT 与 Slack webhook 不落明文", () => {
|
|
454
|
+
const { store, cleanup } = makeStore();
|
|
455
|
+
try {
|
|
456
|
+
const pat = "github_pat_" + "A".repeat(24);
|
|
457
|
+
const hook = "https://hooks.slack.com/services/T000/B000/XXXXYYYYZZZZ";
|
|
458
|
+
const node = store.add({ layer: "leaf", text: "凭据 " + pat + " 和 " + hook + "。" }).node;
|
|
459
|
+
assert.ok(!node.text.includes(pat), node.text);
|
|
460
|
+
assert.ok(!node.text.includes("hooks.slack.com/services"), node.text);
|
|
461
|
+
} finally {
|
|
462
|
+
cleanup();
|
|
463
|
+
}
|
|
464
|
+
});
|
|
465
|
+
|
|
466
|
+
test("scope 为空或过长时拒绝写入", () => {
|
|
467
|
+
const { store, cleanup } = makeStore();
|
|
468
|
+
try {
|
|
469
|
+
assert.throws(() => store.add({ layer: "leaf", scope: " ", text: "没有作用域。" }), /scope 不能为空/);
|
|
470
|
+
assert.throws(() => store.add({ layer: "leaf", scope: "x".repeat(201), text: "作用域太长。" }), /scope 超过 200 字/);
|
|
471
|
+
} finally {
|
|
472
|
+
cleanup();
|
|
473
|
+
}
|
|
474
|
+
});
|
|
475
|
+
|
|
476
|
+
test("格式像 §1 规则但解析失败时拒绝同步,不归档旧主干", () => {
|
|
477
|
+
const { dir, store, cleanup } = makeStore();
|
|
478
|
+
try {
|
|
479
|
+
const agents = path.join(dir, "AGENTS.md");
|
|
480
|
+
fs.writeFileSync(agents, "# AGENTS.md\n\n## §1 主干\n\n- **§1-1-1 规则甲**:甲甲甲甲。\n", "utf8");
|
|
481
|
+
assert.equal(syncTrunk(store, agents, { scope: "user" }).ok, true);
|
|
482
|
+
fs.writeFileSync(
|
|
483
|
+
agents,
|
|
484
|
+
"# AGENTS.md\n\n## §1 主干\n\n- **§1-1-1 规则甲**:甲甲甲甲。\n- **§1-1-2 坏规则** 少了冒号\n",
|
|
485
|
+
"utf8",
|
|
486
|
+
);
|
|
487
|
+
const res = syncTrunk(store, agents, { scope: "user" });
|
|
488
|
+
assert.equal(res.ok, false);
|
|
489
|
+
assert.match(res.reason, /无法解析/);
|
|
490
|
+
assert.equal(store.get("trunk:§1-1-1").status, "active", "旧规则不能被当成已删除而归档");
|
|
491
|
+
} finally {
|
|
492
|
+
cleanup();
|
|
493
|
+
}
|
|
494
|
+
});
|
|
495
|
+
|
|
496
|
+
test("cards 跨作用域同 subject 都保留,不互相隐藏", () => {
|
|
497
|
+
const { store, cleanup } = makeStore();
|
|
498
|
+
try {
|
|
499
|
+
store.add({ layer: "task", scope: "user", subject: "same", text: "user 卡", title: "user" });
|
|
500
|
+
store.add({ layer: "task", scope: "workspace:aaa", subject: "same", text: "ws 卡", title: "ws" });
|
|
501
|
+
const list = store.cards(["user", "workspace:aaa"]);
|
|
502
|
+
assert.equal(list.length, 2);
|
|
503
|
+
assert.deepEqual(new Set(list.map((n) => n.scope)), new Set(["user", "workspace:aaa"]));
|
|
504
|
+
assert.equal(store.cards(["workspace:aaa"]).length, 1);
|
|
505
|
+
} finally {
|
|
506
|
+
cleanup();
|
|
507
|
+
}
|
|
508
|
+
});
|
|
509
|
+
|
|
510
|
+
test("replaceCard 正文相同但标题变化时刷新元数据", () => {
|
|
511
|
+
const { store, cleanup } = makeStore();
|
|
512
|
+
try {
|
|
513
|
+
const first = store.replaceCard("same", { scope: "user", layer: "task", text: "同一段正文" }).node;
|
|
514
|
+
const second = store.replaceCard("same", { scope: "user", layer: "task", text: "同一段正文", title: "新标题" }).node;
|
|
515
|
+
assert.equal(second.id, first.id);
|
|
516
|
+
assert.equal(second.title, "新标题");
|
|
517
|
+
assert.equal(store.get(first.id).status, "active");
|
|
518
|
+
} finally {
|
|
519
|
+
cleanup();
|
|
520
|
+
}
|
|
521
|
+
});
|
|
522
|
+
|
|
523
|
+
test("replaceCard 命中已取代的同文卡时恢复 active 并降级当前卡", () => {
|
|
524
|
+
const { store, cleanup } = makeStore();
|
|
525
|
+
try {
|
|
526
|
+
const first = store.replaceCard("same", { scope: "user", layer: "task", text: "第一版正文" }).node;
|
|
527
|
+
const second = store.replaceCard("same", { scope: "user", layer: "task", text: "第二版正文" }).node;
|
|
528
|
+
assert.equal(store.get(first.id).status, "superseded");
|
|
529
|
+
const revived = store.replaceCard("same", { scope: "user", layer: "task", text: "第一版正文" }).node;
|
|
530
|
+
assert.equal(revived.id, first.id);
|
|
531
|
+
assert.equal(store.get(first.id).status, "active");
|
|
532
|
+
assert.equal(store.get(second.id).status, "superseded");
|
|
533
|
+
assert.equal(store.cards(["user"]).length, 1);
|
|
534
|
+
} finally {
|
|
535
|
+
cleanup();
|
|
536
|
+
}
|
|
537
|
+
});
|
|
538
|
+
|
|
539
|
+
test("forget hard 清除其它条目的 superseded_by 悬空引用", () => {
|
|
540
|
+
const { store, cleanup } = makeStore();
|
|
541
|
+
try {
|
|
542
|
+
const old = store.add({ layer: "leaf", text: "旧条目正文。" }).node;
|
|
543
|
+
const fresh = store.add({ layer: "leaf", text: "新条目正文。" }).node;
|
|
544
|
+
store.supersede([old.id], { layer: "leaf", text: "新条目正文。", scope: "user" });
|
|
545
|
+
const marked = store.get(old.id);
|
|
546
|
+
assert.equal(marked.status, "superseded");
|
|
547
|
+
assert.ok(marked.supersededBy !== null);
|
|
548
|
+
store.forget(fresh.id, { hard: true, reason: "测试" });
|
|
549
|
+
assert.equal(store.get(old.id).supersededBy, null);
|
|
550
|
+
} finally {
|
|
551
|
+
cleanup();
|
|
552
|
+
}
|
|
553
|
+
});
|
|
554
|
+
|
|
555
|
+
test("diaryAuto 只统计指定作用域的写入", () => {
|
|
556
|
+
const { store, cleanup } = makeStore();
|
|
557
|
+
try {
|
|
558
|
+
store.add({ layer: "leaf", scope: "user", title: "用户区标题", text: "用户区正文。" });
|
|
559
|
+
store.add({ layer: "leaf", scope: "workspace:aaa", title: "工作区标题", text: "工作区正文。" });
|
|
560
|
+
store.audit("search", { scope: "user", query: "用户搜索词", hits: 1 });
|
|
561
|
+
store.audit("search", { scope: "workspace:aaa", query: "工作区搜索词", hits: 1 });
|
|
562
|
+
const res = store.diaryAuto(undefined, { scopes: ["user"] });
|
|
563
|
+
assert.equal(res.skipped, false);
|
|
564
|
+
assert.match(res.record.text, /用户区标题/);
|
|
565
|
+
assert.doesNotMatch(res.record.text, /工作区标题/);
|
|
566
|
+
assert.match(res.record.text, /用户搜索词/);
|
|
567
|
+
assert.doesNotMatch(res.record.text, /工作区搜索词/);
|
|
568
|
+
} finally {
|
|
569
|
+
cleanup();
|
|
570
|
+
}
|
|
571
|
+
});
|
|
572
|
+
|
|
573
|
+
test("count 遇到空 layers/status 返回 0,不拼非法 SQL", () => {
|
|
574
|
+
const { store, cleanup } = makeStore();
|
|
575
|
+
try {
|
|
576
|
+
assert.equal(store.count({ layers: [] }), 0);
|
|
577
|
+
assert.equal(store.count({ status: [] }), 0);
|
|
578
|
+
assert.deepEqual(store.list({ layers: [] }), []);
|
|
579
|
+
} finally {
|
|
580
|
+
cleanup();
|
|
581
|
+
}
|
|
582
|
+
});
|
|
583
|
+
|
|
584
|
+
test("导入超大 trunk_bucket 行被跳过而不是整批回滚", () => {
|
|
585
|
+
const { store, cleanup } = makeStore();
|
|
586
|
+
try {
|
|
587
|
+
const line = JSON.stringify({ _kind: "trunk_bucket", uid: "trunk:§1-1-1", bucket: "x".repeat(61) }) + "\n";
|
|
588
|
+
const res = store.importJsonl(line + JSON.stringify({ text: "正常条目正文。", layer: "leaf", scope: "user" }) + "\n", { mode: "merge" });
|
|
589
|
+
assert.equal(res.buckets, 0);
|
|
590
|
+
assert.equal(res.skipped, 1);
|
|
591
|
+
assert.equal(res.added, 1);
|
|
592
|
+
assert.equal(store.trunkBuckets()["trunk:§1-1-1"], undefined);
|
|
593
|
+
} finally {
|
|
594
|
+
cleanup();
|
|
595
|
+
}
|
|
596
|
+
});
|
|
597
|
+
|
|
598
|
+
test("旧库 legacy:<id> 记忆能导出并重新导入", () => {
|
|
599
|
+
const { store, cleanup } = makeStore();
|
|
600
|
+
const other = makeStore();
|
|
601
|
+
try {
|
|
602
|
+
store.add({ uid: "legacy:7", layer: "task", scope: "user", subject: "旧卡", text: "旧库任务卡正文。" });
|
|
603
|
+
const jsonl = store.exportJsonl();
|
|
604
|
+
const res = other.store.importJsonl(jsonl, { mode: "merge" });
|
|
605
|
+
assert.equal(res.added, 1);
|
|
606
|
+
assert.equal(other.store.get("legacy:7").layer, "task");
|
|
607
|
+
} finally {
|
|
608
|
+
cleanup();
|
|
609
|
+
other.cleanup();
|
|
610
|
+
}
|
|
611
|
+
});
|
|
612
|
+
|
|
613
|
+
test("导入未知 layer 被跳过,不静默改成 leaf", () => {
|
|
614
|
+
const { store, cleanup } = makeStore();
|
|
615
|
+
try {
|
|
616
|
+
const line = JSON.stringify({ uid: "weird:1", layer: "weird", scope: "user", text: "未知层正文。" }) + "\n";
|
|
617
|
+
const res = store.importJsonl(line, { mode: "merge" });
|
|
618
|
+
assert.equal(res.added, 0);
|
|
619
|
+
assert.equal(res.skipped, 1);
|
|
620
|
+
} finally {
|
|
621
|
+
cleanup();
|
|
622
|
+
}
|
|
623
|
+
});
|
|
624
|
+
|
|
625
|
+
test("脱敏保留 QQ/微信字段名,只替换值", () => {
|
|
626
|
+
const { store, cleanup } = makeStore();
|
|
627
|
+
try {
|
|
628
|
+
const node = store.add({ layer: "leaf", text: "联系 QQ:123456789,微信=abcdefg。" }).node;
|
|
629
|
+
assert.ok(!node.text.includes("123456789"), node.text);
|
|
630
|
+
assert.ok(!node.text.includes("abcdefg"), node.text);
|
|
631
|
+
assert.match(node.text, /QQ=\*\*\*/);
|
|
632
|
+
assert.match(node.text, /微信=\*\*\*/);
|
|
633
|
+
} finally {
|
|
634
|
+
cleanup();
|
|
635
|
+
}
|
|
636
|
+
});
|
|
637
|
+
|
|
638
|
+
test("cards.json 不会被 __proto__ 这类 subject 污染,卡片仍然写出", () => {
|
|
639
|
+
const { store, dir, cleanup } = makeStore();
|
|
640
|
+
try {
|
|
641
|
+
store.add({ layer: "task", scope: "user", subject: "__proto__", title: "原型卡", text: "原型正文。" });
|
|
642
|
+
exportTaskCards(store, dir);
|
|
643
|
+
const payload = JSON.parse(fs.readFileSync(path.join(dir, "cards.json"), "utf8"));
|
|
644
|
+
assert.equal(Object.getPrototypeOf(payload.cards), Object.prototype);
|
|
645
|
+
assert.equal(payload.cards["__proto__"].title, "原型卡");
|
|
646
|
+
} finally {
|
|
647
|
+
cleanup();
|
|
648
|
+
}
|
|
649
|
+
});
|
|
650
|
+
|
|
651
|
+
test("cards.json 顶层 user 优先,其它工作区同 subject 仍保留在 scoped", () => {
|
|
652
|
+
const { store, dir, cleanup } = makeStore();
|
|
653
|
+
try {
|
|
654
|
+
store.add({ layer: "task", scope: "user", subject: "same", title: "用户卡", text: "用户正文。" });
|
|
655
|
+
store.add({ layer: "task", scope: "workspace:aaa", subject: "same", title: "工作区卡", text: "工作区正文。" });
|
|
656
|
+
exportTaskCards(store, dir);
|
|
657
|
+
const payload = JSON.parse(fs.readFileSync(path.join(dir, "cards.json"), "utf8"));
|
|
658
|
+
assert.equal(payload.cards.same.scope, "user");
|
|
659
|
+
assert.equal(payload.scoped["workspace:aaa"].same.title, "工作区卡");
|
|
660
|
+
} finally {
|
|
661
|
+
cleanup();
|
|
662
|
+
}
|
|
663
|
+
});
|
|
664
|
+
|
|
665
|
+
test("CLI migrate --db 把旧库当迁移源,不把当前记忆库指到旧库", () => {
|
|
666
|
+
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mt-cli-"));
|
|
667
|
+
const oldFile = path.join(dir, "old-memories.db");
|
|
668
|
+
const dataDir = path.join(dir, "data");
|
|
669
|
+
const legacy = new DatabaseSync(oldFile);
|
|
670
|
+
try {
|
|
671
|
+
legacy.exec(
|
|
672
|
+
"CREATE TABLE memory (id INTEGER PRIMARY KEY, text TEXT, layer TEXT, subject TEXT, tags TEXT, summary TEXT, importance REAL, created_at INTEGER, updated_at INTEGER)",
|
|
673
|
+
);
|
|
674
|
+
legacy.prepare("INSERT INTO memory (id,text,layer,subject,tags,summary,importance,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)")
|
|
675
|
+
.run(1, "旧库里的任务卡正文。", "task", "旧卡", "[]", "旧卡", 0.8, Date.now(), Date.now());
|
|
676
|
+
} finally {
|
|
677
|
+
legacy.close();
|
|
678
|
+
}
|
|
679
|
+
const bin = fileURLToPath(new URL("../bin/mt.mjs", import.meta.url));
|
|
680
|
+
const raw = execFileSync(process.execPath, [bin, "migrate", "--db", oldFile, "--data-dir", dataDir, "--apply", "--json"], {
|
|
681
|
+
encoding: "utf8",
|
|
682
|
+
});
|
|
683
|
+
const res = JSON.parse(raw);
|
|
684
|
+
assert.equal(res.ok, true);
|
|
685
|
+
assert.equal(res.added, 1);
|
|
686
|
+
const current = new DatabaseSync(path.join(dataDir, "memory.db"), { readOnly: true });
|
|
687
|
+
try {
|
|
688
|
+
const row = current.prepare("SELECT uid, text, layer FROM node WHERE uid='legacy:1'").get();
|
|
689
|
+
assert.equal(row.layer, "task");
|
|
690
|
+
assert.match(row.text, /旧库里的任务卡正文/);
|
|
691
|
+
} finally {
|
|
692
|
+
current.close();
|
|
693
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
694
|
+
}
|
|
695
|
+
});
|
|
696
|
+
|
|
697
|
+
test("CLI init 创建 AGENTS.md;已存在拒绝;--force 先备份", () => {
|
|
698
|
+
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mt-init-"));
|
|
699
|
+
const agents = path.join(dir, "AGENTS.md");
|
|
700
|
+
const dataDir = path.join(dir, "data");
|
|
701
|
+
const bin = fileURLToPath(new URL("../bin/mt.mjs", import.meta.url));
|
|
702
|
+
try {
|
|
703
|
+
const first = spawnSync(process.execPath, [bin, "init", "--agents", agents, "--data-dir", dataDir, "--json"], { encoding: "utf8" });
|
|
704
|
+
assert.equal(first.status, 0, first.stderr || first.stdout);
|
|
705
|
+
const created = JSON.parse(first.stdout);
|
|
706
|
+
assert.equal(created.ok, true);
|
|
707
|
+
assert.equal(created.sync.ok, true);
|
|
708
|
+
assert.ok(fs.existsSync(agents));
|
|
709
|
+
assert.match(fs.readFileSync(agents, "utf8"), /§1-1/);
|
|
710
|
+
|
|
711
|
+
const again = spawnSync(process.execPath, [bin, "init", "--agents", agents, "--data-dir", dataDir, "--json"], { encoding: "utf8" });
|
|
712
|
+
assert.equal(again.status, 1);
|
|
713
|
+
assert.match(JSON.parse(again.stdout).error, /已存在/);
|
|
714
|
+
|
|
715
|
+
fs.writeFileSync(agents, "旧正本内容\n");
|
|
716
|
+
const forced = spawnSync(process.execPath, [bin, "init", "--agents", agents, "--data-dir", dataDir, "--force", "--json"], { encoding: "utf8" });
|
|
717
|
+
assert.equal(forced.status, 0, forced.stderr || forced.stdout);
|
|
718
|
+
const replaced = JSON.parse(forced.stdout);
|
|
719
|
+
assert.ok(replaced.backup);
|
|
720
|
+
assert.match(fs.readFileSync(replaced.backup, "utf8"), /旧正本内容/);
|
|
721
|
+
assert.match(fs.readFileSync(agents, "utf8"), /§1-1/);
|
|
722
|
+
} finally {
|
|
723
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
724
|
+
}
|
|
725
|
+
});
|
|
726
|
+
|
|
727
|
+
test("CLI 非法 --scope/--status 明确报错,不静默当 all", () => {
|
|
728
|
+
const bin = fileURLToPath(new URL("../bin/mt.mjs", import.meta.url));
|
|
729
|
+
const scope = spawnSync(process.execPath, [bin, "list", "--scope", "bogus"], { encoding: "utf8" });
|
|
730
|
+
assert.notEqual(scope.status, 0);
|
|
731
|
+
assert.match(scope.stderr, /--scope 只能是/);
|
|
732
|
+
const status = spawnSync(process.execPath, [bin, "list", "--status", "bogus", "--json"], { encoding: "utf8" });
|
|
733
|
+
assert.notEqual(status.status, 0);
|
|
734
|
+
assert.match(status.stdout, /未知 status/);
|
|
735
|
+
});
|
|
736
|
+
|
|
737
|
+
test("看板 approve active 主干只改信任,不走 candidate→active 守卫", () => {
|
|
738
|
+
const { store, cleanup } = makeStore();
|
|
739
|
+
try {
|
|
740
|
+
const created = store.add({
|
|
741
|
+
layer: "trunk",
|
|
742
|
+
scope: "user",
|
|
743
|
+
status: "active",
|
|
744
|
+
subject: "§1-1-1",
|
|
745
|
+
title: "规则",
|
|
746
|
+
text: "规则正文。",
|
|
747
|
+
source: "AGENTS.md#L1-L2",
|
|
748
|
+
});
|
|
749
|
+
const res = runBoardAction(store, { op: "approve", id: created.node.id });
|
|
750
|
+
assert.equal(res.ok, true);
|
|
751
|
+
assert.equal(res.mode, "approved");
|
|
752
|
+
const fresh = store.get(created.node.id);
|
|
753
|
+
assert.equal(fresh.status, "active");
|
|
754
|
+
assert.equal(fresh.trust, 100);
|
|
755
|
+
} finally {
|
|
756
|
+
cleanup();
|
|
757
|
+
}
|
|
758
|
+
});
|
|
759
|
+
|
|
760
|
+
test("归档主干候选时清掉它的大标题覆盖", () => {
|
|
761
|
+
const { store, cleanup } = makeStore();
|
|
762
|
+
try {
|
|
763
|
+
const created = store.add({
|
|
764
|
+
layer: "trunk",
|
|
765
|
+
scope: "user",
|
|
766
|
+
uid: "trunk:§1-1-1",
|
|
767
|
+
subject: "§1-1-1",
|
|
768
|
+
title: "候选",
|
|
769
|
+
text: "候选正文。",
|
|
770
|
+
source: "board:manual",
|
|
771
|
+
});
|
|
772
|
+
store.setTrunkBucket(created.node.uid, "临时组");
|
|
773
|
+
store.forget(created.node.id, { hard: false, reason: "测试归档" });
|
|
774
|
+
assert.equal(store.trunkBuckets()[created.node.uid], undefined);
|
|
775
|
+
} finally {
|
|
776
|
+
cleanup();
|
|
777
|
+
}
|
|
778
|
+
});
|
|
779
|
+
|
|
780
|
+
test("§1 下错位编号与空正文规则进入 unparsed,不被静默吞掉", () => {
|
|
781
|
+
const parsed = parseAgents(
|
|
782
|
+
["## §1 主干", "### §1-1 核心规则", "- **§2-1 错位编号**:正文。", "- **§1-1-1 空正文**:"].join("\n"),
|
|
783
|
+
);
|
|
784
|
+
assert.equal(parsed.rules.length, 0);
|
|
785
|
+
assert.ok(parsed.unparsed.some((x) => /非 §1 编号/.test(x.text)));
|
|
786
|
+
assert.ok(parsed.unparsed.some((x) => /正文为空/.test(x.text)));
|
|
787
|
+
});
|
|
788
|
+
|
|
789
|
+
test("看板归枝/待写入/写主干对超长正文给出可读错误", () => {
|
|
790
|
+
const { store, cleanup } = makeStore();
|
|
791
|
+
try {
|
|
792
|
+
const leaf = store.add({ layer: "leaf", scope: "user", text: "短叶。" }).node;
|
|
793
|
+
const huge = "x".repeat(20001);
|
|
794
|
+
const emo = runBoardAction(store, { op: "branch-emotion", id: leaf.id, text: huge });
|
|
795
|
+
assert.equal(emo.ok, false);
|
|
796
|
+
assert.match(emo.error, /20000/);
|
|
797
|
+
const placement = runBoardAction(store, { op: "placement-create", id: leaf.id, text: huge });
|
|
798
|
+
assert.equal(placement.ok, false);
|
|
799
|
+
assert.match(placement.error, /20000/);
|
|
800
|
+
const trunk = runBoardAction(store, {
|
|
801
|
+
op: "write-trunk-new",
|
|
802
|
+
id: leaf.id,
|
|
803
|
+
text: huge,
|
|
804
|
+
confirm: true,
|
|
805
|
+
checks: [true, true, true, true, true],
|
|
806
|
+
});
|
|
807
|
+
assert.equal(trunk.ok, false);
|
|
808
|
+
assert.match(trunk.error, /20000/);
|
|
809
|
+
} finally {
|
|
810
|
+
cleanup();
|
|
811
|
+
}
|
|
812
|
+
});
|
|
813
|
+
|
|
814
|
+
test("CLI apply 决定文件坏 JSON 返回可读错误而不是堆栈", () => {
|
|
815
|
+
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mt-apply-"));
|
|
816
|
+
const file = path.join(dir, "bad.json");
|
|
817
|
+
fs.writeFileSync(file, "{ not json", "utf8");
|
|
818
|
+
const bin = fileURLToPath(new URL("../bin/mt.mjs", import.meta.url));
|
|
819
|
+
const res = spawnSync(process.execPath, [bin, "apply", "--file", file, "--json", "--data-dir", path.join(dir, "data")], {
|
|
820
|
+
encoding: "utf8",
|
|
821
|
+
});
|
|
822
|
+
try {
|
|
823
|
+
assert.notEqual(res.status, 0);
|
|
824
|
+
assert.match(res.stdout, /读取或解析决定文件失败/);
|
|
825
|
+
assert.doesNotMatch(res.stderr, /at .*\.mjs/);
|
|
826
|
+
} finally {
|
|
827
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
828
|
+
}
|
|
829
|
+
});
|
|
830
|
+
|
|
831
|
+
|
|
832
|
+
|
|
833
|
+
|
|
834
|
+
|