dsh-plugin-om 0.0.55 → 0.0.57
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/README.md +74 -18
- package/dist/client/OmCompactionCard.d.ts.map +1 -1
- package/dist/client/OmEvalModelPanel.d.ts +22 -0
- package/dist/client/OmEvalModelPanel.d.ts.map +1 -0
- package/dist/client/OmRecompressMenu.d.ts +3 -3
- package/dist/client/OmRecompressMenu.d.ts.map +1 -1
- package/dist/client/compaction-eval-jump.d.ts +20 -0
- package/dist/client/compaction-eval-jump.d.ts.map +1 -0
- package/dist/client/definition.d.ts +2 -2
- package/dist/client/definition.d.ts.map +1 -1
- package/dist/client/eval-model-panel.d.ts +57 -0
- package/dist/client/eval-model-panel.d.ts.map +1 -0
- package/dist/client/eval-model-register.d.ts +10 -0
- package/dist/client/eval-model-register.d.ts.map +1 -0
- package/dist/client/index.d.ts +2 -1
- package/dist/client/index.d.ts.map +1 -1
- package/dist/client/locales.d.ts +13 -2
- package/dist/client/locales.d.ts.map +1 -1
- package/dist/client/om-config-controller.d.ts +4 -1
- package/dist/client/om-config-controller.d.ts.map +1 -1
- package/dist/client/recompress-run.d.ts +23 -2
- package/dist/client/recompress-run.d.ts.map +1 -1
- package/dist/client.js +675 -116
- package/dist/client.js.map +1 -1
- package/dist/compaction-eval-command.d.ts +54 -0
- package/dist/compaction-eval-command.d.ts.map +1 -0
- package/dist/compaction-log.d.ts +31 -9
- package/dist/compaction-log.d.ts.map +1 -1
- package/dist/compress-loop.d.ts +21 -10
- package/dist/compress-loop.d.ts.map +1 -1
- package/dist/compress-tools.d.ts +16 -8
- package/dist/compress-tools.d.ts.map +1 -1
- package/dist/compress-view.d.ts +1 -3
- package/dist/compress-view.d.ts.map +1 -1
- package/dist/compress.d.ts +117 -8
- package/dist/compress.d.ts.map +1 -1
- package/dist/config.d.ts +4 -0
- package/dist/config.d.ts.map +1 -1
- package/dist/constants.d.ts +3 -1
- package/dist/constants.d.ts.map +1 -1
- package/dist/eval-session-text.d.ts +28 -0
- package/dist/eval-session-text.d.ts.map +1 -0
- package/dist/index.d.ts +4 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +1392 -480
- package/dist/log-index.d.ts +2 -2
- package/dist/log-index.d.ts.map +1 -1
- package/dist/om-event.d.ts +26 -2
- package/dist/om-event.d.ts.map +1 -1
- package/dist/precompress.d.ts +100 -0
- package/dist/precompress.d.ts.map +1 -0
- package/dist/recall-xml.d.ts +2 -1
- package/dist/recall-xml.d.ts.map +1 -1
- package/dist/recompress-gate.d.ts +11 -0
- package/dist/recompress-gate.d.ts.map +1 -0
- package/dist/recompress.d.ts +20 -4
- package/dist/recompress.d.ts.map +1 -1
- package/dist/skill/compaction-eval/SKILL.md +72 -0
- package/dist/skill/compaction-eval/references/facts-prompt.md +42 -0
- package/dist/skill/compaction-eval/references/judge-prompt.md +48 -0
- package/dist/skill/compaction-eval/references/rules.md +56 -0
- package/dist/skill/compaction-eval/scripts/aggregate.mjs +372 -0
- package/dist/skill/compaction-eval/scripts/compress.mjs +15675 -0
- package/dist/skill/compaction-eval/scripts/merge.mjs +287 -0
- package/dist/skill/compaction-eval/scripts/prepare.mjs +1620 -0
- package/dist/skill/compaction-eval/scripts/view.mjs +15983 -0
- package/dist/system-reminder.d.ts.map +1 -1
- package/dist/thinking-binding.d.ts +28 -0
- package/dist/thinking-binding.d.ts.map +1 -0
- package/dist/types.d.ts +9 -6
- package/dist/types.d.ts.map +1 -1
- package/package.json +10 -3
|
@@ -0,0 +1,1620 @@
|
|
|
1
|
+
import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
|
|
2
|
+
import { dirname, join, resolve } from "node:path";
|
|
3
|
+
import { fileURLToPath } from "node:url";
|
|
4
|
+
import { parseArgs } from "node:util";
|
|
5
|
+
import { homedir, tmpdir } from "node:os";
|
|
6
|
+
import { Session, SessionId } from "@deepseek-ai/dsh-session";
|
|
7
|
+
import { createRequire } from "module";
|
|
8
|
+
/**
|
|
9
|
+
* 判定 user/message 的 source 是否为本插件自产或宿主压缩 checkpoint(压缩日志消息与
|
|
10
|
+
* 宿主压缩替换消息)。这类消息不占完整消息 index。宿主迁移前的 v3 信封形态
|
|
11
|
+
* (kind 'plugin' + plugin 字段)仅作读取防御保留。
|
|
12
|
+
*/
|
|
13
|
+
function isPluginOwnedSource(source) {
|
|
14
|
+
if (source?.kind === "compact-checkpoint") return true;
|
|
15
|
+
if (source?.kind === "plugin:dsh-plugin-om") return true;
|
|
16
|
+
if (source?.kind !== "plugin") return false;
|
|
17
|
+
return source.plugin === "dsh-plugin-om" || source.plugin === "compact";
|
|
18
|
+
}
|
|
19
|
+
//#endregion
|
|
20
|
+
//#region src/log-index.ts
|
|
21
|
+
/**
|
|
22
|
+
* 会话日志索引:完整消息索引与渲染。
|
|
23
|
+
* 导出 indexCompleteMessages(完整消息三类折叠索引,recall 与摘要共用同一套编号)、
|
|
24
|
+
* indexMessages / surfaceIndexOf / messageIdOfEvent(消息级定位辅助)、
|
|
25
|
+
* collectImageRefs / toolCallBlockOf / toolResultMessageOf / renderToolResultText /
|
|
26
|
+
* renderCompleteMessageParts /
|
|
27
|
+
* renderCompleteMessage(完整消息渲染与图片附件收集)。事件日志仅追加(被遮蔽的事件仍可读,
|
|
28
|
+
* recall 依赖此性质)。
|
|
29
|
+
*
|
|
30
|
+
* 完整消息分四类:user(用户消息)、assistant(模型输出文本)、
|
|
31
|
+
* toolcall(单个工具调用及其结果,result 按 callId 匹配并入)、
|
|
32
|
+
* skill(手动加载的 skill,source.kind 为 skill-invocation 的系统消息)。其余系统消息不占位。
|
|
33
|
+
* index 从 0 起、按日志顺序递增、只追加不重排(压缩后旧摘要条目引用的 index 仍然有效)。
|
|
34
|
+
*/
|
|
35
|
+
/**
|
|
36
|
+
* 手动加载 skill 的名称:source.kind 为 skill-invocation 且 name 为非空字符串时返回,否则 undefined。
|
|
37
|
+
* 当前宿主类型未声明该 kind,故以宽松结构读取。
|
|
38
|
+
*/
|
|
39
|
+
function skillInvocationName(source) {
|
|
40
|
+
if (source?.kind !== "skill-invocation") return void 0;
|
|
41
|
+
const name = source.name;
|
|
42
|
+
return typeof name === "string" && name !== "" ? name : void 0;
|
|
43
|
+
}
|
|
44
|
+
/**
|
|
45
|
+
* 完整消息索引:按日志顺序把消息事件折叠为完整消息序列(四类,见文件头)。
|
|
46
|
+
* 工具调用结果按 source.callId 匹配其 tool-call 并入该条;未匹配的 result 独立成条(防御)。
|
|
47
|
+
* 本插件自产消息不占位;压缩在 agent/pre-step 触发(call-result 完备),不存在未闭合调用。
|
|
48
|
+
*/
|
|
49
|
+
function indexCompleteMessages(session) {
|
|
50
|
+
const cms = [];
|
|
51
|
+
const pending = /* @__PURE__ */ new Map();
|
|
52
|
+
const events = session.snapshotEvents();
|
|
53
|
+
for (let seq = 0; seq < events.length; seq += 1) {
|
|
54
|
+
const event = events[seq];
|
|
55
|
+
if (!event) continue;
|
|
56
|
+
if (event.type === "user/message") {
|
|
57
|
+
const source = event.data.source;
|
|
58
|
+
if (isPluginOwnedSource(source)) continue;
|
|
59
|
+
const skillName = skillInvocationName(source);
|
|
60
|
+
if (source?.kind === "user") cms.push({
|
|
61
|
+
index: cms.length,
|
|
62
|
+
type: "user",
|
|
63
|
+
seqs: [seq]
|
|
64
|
+
});
|
|
65
|
+
else if (skillName !== void 0) cms.push({
|
|
66
|
+
index: cms.length,
|
|
67
|
+
type: "skill",
|
|
68
|
+
seqs: [seq],
|
|
69
|
+
skillName
|
|
70
|
+
});
|
|
71
|
+
} else if (event.type === "assistant/message") {
|
|
72
|
+
const message = event.data.message;
|
|
73
|
+
if (!message || !Array.isArray(message.content)) continue;
|
|
74
|
+
let hasText = false;
|
|
75
|
+
for (const block of message.content) if (block.type === "text") {
|
|
76
|
+
hasText = true;
|
|
77
|
+
break;
|
|
78
|
+
}
|
|
79
|
+
if (hasText) cms.push({
|
|
80
|
+
index: cms.length,
|
|
81
|
+
type: "assistant",
|
|
82
|
+
seqs: [seq]
|
|
83
|
+
});
|
|
84
|
+
for (const block of message.content) {
|
|
85
|
+
if (block.type !== "tool-call") continue;
|
|
86
|
+
const callId = String(block.id ?? "");
|
|
87
|
+
const cm = {
|
|
88
|
+
index: cms.length,
|
|
89
|
+
type: "toolcall",
|
|
90
|
+
seqs: [seq],
|
|
91
|
+
...callId === "" ? {} : { callId }
|
|
92
|
+
};
|
|
93
|
+
cms.push(cm);
|
|
94
|
+
if (callId !== "") pending.set(callId, cm);
|
|
95
|
+
}
|
|
96
|
+
} else if (event.type === "tool/result") {
|
|
97
|
+
const source = event.data.message?.source;
|
|
98
|
+
const callId = String(source?.callId ?? "");
|
|
99
|
+
const cm = callId === "" ? void 0 : pending.get(callId);
|
|
100
|
+
if (cm) {
|
|
101
|
+
cm.seqs.push(seq);
|
|
102
|
+
pending.delete(callId);
|
|
103
|
+
} else cms.push({
|
|
104
|
+
index: cms.length,
|
|
105
|
+
type: "toolcall",
|
|
106
|
+
seqs: [seq],
|
|
107
|
+
...callId === "" ? {} : { callId }
|
|
108
|
+
});
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
return cms;
|
|
112
|
+
}
|
|
113
|
+
//#endregion
|
|
114
|
+
//#region .agents/skills/compaction-eval/scripts/paths.ts
|
|
115
|
+
/**
|
|
116
|
+
* compaction-eval 的文件位置:评估根目录,以及按会话、阶段、区间命名的视图文件、重压缩目录与评估目录。
|
|
117
|
+
* 各入口共用;不含命令行入口。
|
|
118
|
+
* 导出 bareId / evalRoot / rangeSlug / evalPath / viewPath / recompressPath / selfName 与 RangeKey 类型。
|
|
119
|
+
*/
|
|
120
|
+
/** 会话 id 规范化:parentSession 带 session- 前缀,目录名与头 id 为裸 uuid。 */
|
|
121
|
+
function bareId(id) {
|
|
122
|
+
return id.replace(/^session-/, "");
|
|
123
|
+
}
|
|
124
|
+
/** 评估根目录:系统临时目录下的 om-compaction-eval,每次调用按当前环境解析。 */
|
|
125
|
+
function evalRoot() {
|
|
126
|
+
return join(tmpdir(), "om-compaction-eval");
|
|
127
|
+
}
|
|
128
|
+
/** 区间标识:<会话 id 前 8 位>-<阶段>-<A>-<B>。 */
|
|
129
|
+
function rangeSlug(sessionId, phase, lo, hi) {
|
|
130
|
+
return `${bareId(sessionId).slice(0, 8)}-${phase}-${lo}-${hi}`;
|
|
131
|
+
}
|
|
132
|
+
/** prepare 缺省输出:<根>/eval-<区间标识>/。 */
|
|
133
|
+
function evalPath(sessionId, phase, lo, hi) {
|
|
134
|
+
return join(evalRoot(), `eval-${rangeSlug(sessionId, phase, lo, hi)}`);
|
|
135
|
+
}
|
|
136
|
+
//#endregion
|
|
137
|
+
//#region node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/index.mjs
|
|
138
|
+
var require = createRequire("/");
|
|
139
|
+
try {
|
|
140
|
+
require("worker_threads").Worker;
|
|
141
|
+
} catch (e) {}
|
|
142
|
+
var u8$1 = Uint8Array;
|
|
143
|
+
var u16$1 = Uint16Array;
|
|
144
|
+
var i32$1 = Int32Array;
|
|
145
|
+
var fleb = new u8$1([
|
|
146
|
+
0,
|
|
147
|
+
0,
|
|
148
|
+
0,
|
|
149
|
+
0,
|
|
150
|
+
0,
|
|
151
|
+
0,
|
|
152
|
+
0,
|
|
153
|
+
0,
|
|
154
|
+
1,
|
|
155
|
+
1,
|
|
156
|
+
1,
|
|
157
|
+
1,
|
|
158
|
+
2,
|
|
159
|
+
2,
|
|
160
|
+
2,
|
|
161
|
+
2,
|
|
162
|
+
3,
|
|
163
|
+
3,
|
|
164
|
+
3,
|
|
165
|
+
3,
|
|
166
|
+
4,
|
|
167
|
+
4,
|
|
168
|
+
4,
|
|
169
|
+
4,
|
|
170
|
+
5,
|
|
171
|
+
5,
|
|
172
|
+
5,
|
|
173
|
+
5,
|
|
174
|
+
0,
|
|
175
|
+
0,
|
|
176
|
+
0,
|
|
177
|
+
0
|
|
178
|
+
]);
|
|
179
|
+
var fdeb = new u8$1([
|
|
180
|
+
0,
|
|
181
|
+
0,
|
|
182
|
+
0,
|
|
183
|
+
0,
|
|
184
|
+
1,
|
|
185
|
+
1,
|
|
186
|
+
2,
|
|
187
|
+
2,
|
|
188
|
+
3,
|
|
189
|
+
3,
|
|
190
|
+
4,
|
|
191
|
+
4,
|
|
192
|
+
5,
|
|
193
|
+
5,
|
|
194
|
+
6,
|
|
195
|
+
6,
|
|
196
|
+
7,
|
|
197
|
+
7,
|
|
198
|
+
8,
|
|
199
|
+
8,
|
|
200
|
+
9,
|
|
201
|
+
9,
|
|
202
|
+
10,
|
|
203
|
+
10,
|
|
204
|
+
11,
|
|
205
|
+
11,
|
|
206
|
+
12,
|
|
207
|
+
12,
|
|
208
|
+
13,
|
|
209
|
+
13,
|
|
210
|
+
0,
|
|
211
|
+
0
|
|
212
|
+
]);
|
|
213
|
+
var clim = new u8$1([
|
|
214
|
+
16,
|
|
215
|
+
17,
|
|
216
|
+
18,
|
|
217
|
+
0,
|
|
218
|
+
8,
|
|
219
|
+
7,
|
|
220
|
+
9,
|
|
221
|
+
6,
|
|
222
|
+
10,
|
|
223
|
+
5,
|
|
224
|
+
11,
|
|
225
|
+
4,
|
|
226
|
+
12,
|
|
227
|
+
3,
|
|
228
|
+
13,
|
|
229
|
+
2,
|
|
230
|
+
14,
|
|
231
|
+
1,
|
|
232
|
+
15
|
|
233
|
+
]);
|
|
234
|
+
var freb = function(eb, start) {
|
|
235
|
+
var b = new u16$1(31);
|
|
236
|
+
for (var i = 0; i < 31; ++i) b[i] = start += 1 << eb[i - 1];
|
|
237
|
+
var r = new i32$1(b[30]);
|
|
238
|
+
for (var i = 1; i < 30; ++i) for (var j = b[i]; j < b[i + 1]; ++j) r[j] = j - b[i] << 5 | i;
|
|
239
|
+
return {
|
|
240
|
+
b,
|
|
241
|
+
r
|
|
242
|
+
};
|
|
243
|
+
};
|
|
244
|
+
var _a = freb(fleb, 2);
|
|
245
|
+
var fl = _a.b;
|
|
246
|
+
var revfl = _a.r;
|
|
247
|
+
fl[28] = 258, revfl[258] = 28;
|
|
248
|
+
var _b = freb(fdeb, 0);
|
|
249
|
+
var fd = _b.b;
|
|
250
|
+
_b.r;
|
|
251
|
+
var rev = new u16$1(32768);
|
|
252
|
+
for (var i = 0; i < 32768; ++i) {
|
|
253
|
+
var x = (i & 43690) >> 1 | (i & 21845) << 1;
|
|
254
|
+
x = (x & 52428) >> 2 | (x & 13107) << 2;
|
|
255
|
+
x = (x & 61680) >> 4 | (x & 3855) << 4;
|
|
256
|
+
rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
|
|
257
|
+
}
|
|
258
|
+
var hMap = (function(cd, mb, r) {
|
|
259
|
+
var s = cd.length;
|
|
260
|
+
var i = 0;
|
|
261
|
+
var l = new u16$1(mb);
|
|
262
|
+
for (; i < s; ++i) if (cd[i]) ++l[cd[i] - 1];
|
|
263
|
+
var le = new u16$1(mb);
|
|
264
|
+
for (i = 1; i < mb; ++i) le[i] = le[i - 1] + l[i - 1] << 1;
|
|
265
|
+
var co;
|
|
266
|
+
if (r) {
|
|
267
|
+
co = new u16$1(1 << mb);
|
|
268
|
+
var rvb = 15 - mb;
|
|
269
|
+
for (i = 0; i < s; ++i) if (cd[i]) {
|
|
270
|
+
var sv = i << 4 | cd[i];
|
|
271
|
+
var r_1 = mb - cd[i];
|
|
272
|
+
var v = le[cd[i] - 1]++ << r_1;
|
|
273
|
+
for (var m = v | (1 << r_1) - 1; v <= m; ++v) co[rev[v] >> rvb] = sv;
|
|
274
|
+
}
|
|
275
|
+
} else {
|
|
276
|
+
co = new u16$1(s);
|
|
277
|
+
for (i = 0; i < s; ++i) if (cd[i]) co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
|
|
278
|
+
}
|
|
279
|
+
return co;
|
|
280
|
+
});
|
|
281
|
+
var flt = new u8$1(288);
|
|
282
|
+
for (var i = 0; i < 144; ++i) flt[i] = 8;
|
|
283
|
+
for (var i = 144; i < 256; ++i) flt[i] = 9;
|
|
284
|
+
for (var i = 256; i < 280; ++i) flt[i] = 7;
|
|
285
|
+
for (var i = 280; i < 288; ++i) flt[i] = 8;
|
|
286
|
+
var fdt = new u8$1(32);
|
|
287
|
+
for (var i = 0; i < 32; ++i) fdt[i] = 5;
|
|
288
|
+
var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
|
|
289
|
+
var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
|
|
290
|
+
var max = function(a) {
|
|
291
|
+
var m = a[0];
|
|
292
|
+
for (var i = 1; i < a.length; ++i) if (a[i] > m) m = a[i];
|
|
293
|
+
return m;
|
|
294
|
+
};
|
|
295
|
+
var bits = function(d, p, m) {
|
|
296
|
+
var o = p / 8 | 0;
|
|
297
|
+
return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
|
|
298
|
+
};
|
|
299
|
+
var bits16 = function(d, p) {
|
|
300
|
+
var o = p / 8 | 0;
|
|
301
|
+
return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
|
|
302
|
+
};
|
|
303
|
+
var shft = function(p) {
|
|
304
|
+
return (p + 7) / 8 | 0;
|
|
305
|
+
};
|
|
306
|
+
var slc$1 = function(v, s, e) {
|
|
307
|
+
if (s == null || s < 0) s = 0;
|
|
308
|
+
if (e == null || e > v.length) e = v.length;
|
|
309
|
+
return new u8$1(v.subarray(s, e));
|
|
310
|
+
};
|
|
311
|
+
var ec$1 = [
|
|
312
|
+
"unexpected EOF",
|
|
313
|
+
"invalid block type",
|
|
314
|
+
"invalid length/literal",
|
|
315
|
+
"invalid distance",
|
|
316
|
+
"stream finished",
|
|
317
|
+
"no stream handler",
|
|
318
|
+
,
|
|
319
|
+
"no callback",
|
|
320
|
+
"invalid UTF-8 data",
|
|
321
|
+
"extra field too long",
|
|
322
|
+
"date not in range 1980-2099",
|
|
323
|
+
"filename too long",
|
|
324
|
+
"stream finishing",
|
|
325
|
+
"invalid zip data"
|
|
326
|
+
];
|
|
327
|
+
var err$1 = function(ind, msg, nt) {
|
|
328
|
+
var e = new Error(msg || ec$1[ind]);
|
|
329
|
+
e.code = ind;
|
|
330
|
+
if (Error.captureStackTrace) Error.captureStackTrace(e, err$1);
|
|
331
|
+
if (!nt) throw e;
|
|
332
|
+
return e;
|
|
333
|
+
};
|
|
334
|
+
var inflt = function(dat, st, buf, dict) {
|
|
335
|
+
var sl = dat.length, dl = dict ? dict.length : 0;
|
|
336
|
+
if (!sl || st.f && !st.l) return buf || new u8$1(0);
|
|
337
|
+
var noBuf = !buf;
|
|
338
|
+
var resize = noBuf || st.i != 2;
|
|
339
|
+
var noSt = st.i;
|
|
340
|
+
if (noBuf) buf = new u8$1(sl * 3);
|
|
341
|
+
var cbuf = function(l) {
|
|
342
|
+
var bl = buf.length;
|
|
343
|
+
if (l > bl) {
|
|
344
|
+
var nbuf = new u8$1(Math.max(bl * 2, l));
|
|
345
|
+
nbuf.set(buf);
|
|
346
|
+
buf = nbuf;
|
|
347
|
+
}
|
|
348
|
+
};
|
|
349
|
+
var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
|
|
350
|
+
var tbts = sl * 8;
|
|
351
|
+
do {
|
|
352
|
+
if (!lm) {
|
|
353
|
+
final = bits(dat, pos, 1);
|
|
354
|
+
var type = bits(dat, pos + 1, 3);
|
|
355
|
+
pos += 3;
|
|
356
|
+
if (!type) {
|
|
357
|
+
var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
|
|
358
|
+
if (t > sl) {
|
|
359
|
+
if (noSt) err$1(0);
|
|
360
|
+
break;
|
|
361
|
+
}
|
|
362
|
+
if (resize) cbuf(bt + l);
|
|
363
|
+
buf.set(dat.subarray(s, t), bt);
|
|
364
|
+
st.b = bt += l, st.p = pos = t * 8, st.f = final;
|
|
365
|
+
continue;
|
|
366
|
+
} else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
|
|
367
|
+
else if (type == 2) {
|
|
368
|
+
var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
|
|
369
|
+
var tl = hLit + bits(dat, pos + 5, 31) + 1;
|
|
370
|
+
pos += 14;
|
|
371
|
+
var ldt = new u8$1(tl);
|
|
372
|
+
var clt = new u8$1(19);
|
|
373
|
+
for (var i = 0; i < hcLen; ++i) clt[clim[i]] = bits(dat, pos + i * 3, 7);
|
|
374
|
+
pos += hcLen * 3;
|
|
375
|
+
var clb = max(clt), clbmsk = (1 << clb) - 1;
|
|
376
|
+
var clm = hMap(clt, clb, 1);
|
|
377
|
+
for (var i = 0; i < tl;) {
|
|
378
|
+
var r = clm[bits(dat, pos, clbmsk)];
|
|
379
|
+
pos += r & 15;
|
|
380
|
+
var s = r >> 4;
|
|
381
|
+
if (s < 16) ldt[i++] = s;
|
|
382
|
+
else {
|
|
383
|
+
var c = 0, n = 0;
|
|
384
|
+
if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
|
|
385
|
+
else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
|
|
386
|
+
else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
|
|
387
|
+
while (n--) ldt[i++] = c;
|
|
388
|
+
}
|
|
389
|
+
}
|
|
390
|
+
var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
|
|
391
|
+
lbt = max(lt);
|
|
392
|
+
dbt = max(dt);
|
|
393
|
+
lm = hMap(lt, lbt, 1);
|
|
394
|
+
dm = hMap(dt, dbt, 1);
|
|
395
|
+
} else err$1(1);
|
|
396
|
+
if (pos > tbts) {
|
|
397
|
+
if (noSt) err$1(0);
|
|
398
|
+
break;
|
|
399
|
+
}
|
|
400
|
+
}
|
|
401
|
+
if (resize) cbuf(bt + 131072);
|
|
402
|
+
var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
|
|
403
|
+
var lpos = pos;
|
|
404
|
+
for (;; lpos = pos) {
|
|
405
|
+
var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
|
|
406
|
+
pos += c & 15;
|
|
407
|
+
if (pos > tbts) {
|
|
408
|
+
if (noSt) err$1(0);
|
|
409
|
+
break;
|
|
410
|
+
}
|
|
411
|
+
if (!c) err$1(2);
|
|
412
|
+
if (sym < 256) buf[bt++] = sym;
|
|
413
|
+
else if (sym == 256) {
|
|
414
|
+
lpos = pos, lm = null;
|
|
415
|
+
break;
|
|
416
|
+
} else {
|
|
417
|
+
var add = sym - 254;
|
|
418
|
+
if (sym > 264) {
|
|
419
|
+
var i = sym - 257, b = fleb[i];
|
|
420
|
+
add = bits(dat, pos, (1 << b) - 1) + fl[i];
|
|
421
|
+
pos += b;
|
|
422
|
+
}
|
|
423
|
+
var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
|
|
424
|
+
if (!d) err$1(3);
|
|
425
|
+
pos += d & 15;
|
|
426
|
+
var dt = fd[dsym];
|
|
427
|
+
if (dsym > 3) {
|
|
428
|
+
var b = fdeb[dsym];
|
|
429
|
+
dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
|
|
430
|
+
}
|
|
431
|
+
if (pos > tbts) {
|
|
432
|
+
if (noSt) err$1(0);
|
|
433
|
+
break;
|
|
434
|
+
}
|
|
435
|
+
if (resize) cbuf(bt + 131072);
|
|
436
|
+
var end = bt + add;
|
|
437
|
+
if (bt < dt) {
|
|
438
|
+
var shift = dl - dt, dend = Math.min(dt, end);
|
|
439
|
+
if (shift + bt < 0) err$1(3);
|
|
440
|
+
for (; bt < dend; ++bt) buf[bt] = dict[shift + bt];
|
|
441
|
+
}
|
|
442
|
+
for (; bt < end; ++bt) buf[bt] = buf[bt - dt];
|
|
443
|
+
}
|
|
444
|
+
}
|
|
445
|
+
st.l = lm, st.p = lpos, st.b = bt, st.f = final;
|
|
446
|
+
if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
|
|
447
|
+
} while (!final);
|
|
448
|
+
return bt != buf.length && noBuf ? slc$1(buf, 0, bt) : buf.subarray(0, bt);
|
|
449
|
+
};
|
|
450
|
+
var et = /*#__PURE__*/ new u8$1(0);
|
|
451
|
+
var b2 = function(d, b) {
|
|
452
|
+
return d[b] | d[b + 1] << 8;
|
|
453
|
+
};
|
|
454
|
+
var b4$1 = function(d, b) {
|
|
455
|
+
return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
|
|
456
|
+
};
|
|
457
|
+
var b8 = function(d, b) {
|
|
458
|
+
return b4$1(d, b) + b4$1(d, b + 4) * 4294967296;
|
|
459
|
+
};
|
|
460
|
+
/**
|
|
461
|
+
* Expands DEFLATE data with no wrapper
|
|
462
|
+
* @param data The data to decompress
|
|
463
|
+
* @param opts The decompression options
|
|
464
|
+
* @returns The decompressed version of the data
|
|
465
|
+
*/
|
|
466
|
+
function inflateSync(data, opts) {
|
|
467
|
+
return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
|
|
468
|
+
}
|
|
469
|
+
var td = typeof TextDecoder != "undefined" && /*#__PURE__*/ new TextDecoder();
|
|
470
|
+
try {
|
|
471
|
+
td.decode(et, { stream: true });
|
|
472
|
+
} catch (e) {}
|
|
473
|
+
var dutf8 = function(d) {
|
|
474
|
+
for (var r = "", i = 0;;) {
|
|
475
|
+
var c = d[i++];
|
|
476
|
+
var eb = (c > 127) + (c > 223) + (c > 239);
|
|
477
|
+
if (i + eb > d.length) return {
|
|
478
|
+
s: r,
|
|
479
|
+
r: slc$1(d, i - 1)
|
|
480
|
+
};
|
|
481
|
+
if (!eb) r += String.fromCharCode(c);
|
|
482
|
+
else if (eb == 3) c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
|
|
483
|
+
else if (eb & 1) r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
|
|
484
|
+
else r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
|
|
485
|
+
}
|
|
486
|
+
};
|
|
487
|
+
/**
|
|
488
|
+
* Converts a Uint8Array to a string
|
|
489
|
+
* @param dat The data to decode to string
|
|
490
|
+
* @param latin1 Whether or not to interpret the data as Latin-1. This should
|
|
491
|
+
* not need to be true unless encoding to binary string.
|
|
492
|
+
* @returns The original UTF-8/Latin-1 string
|
|
493
|
+
*/
|
|
494
|
+
function strFromU8(dat, latin1) {
|
|
495
|
+
if (latin1) {
|
|
496
|
+
var r = "";
|
|
497
|
+
for (var i = 0; i < dat.length; i += 16384) r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
|
|
498
|
+
return r;
|
|
499
|
+
} else if (td) return td.decode(dat);
|
|
500
|
+
else {
|
|
501
|
+
var _a = dutf8(dat), s = _a.s, r = _a.r;
|
|
502
|
+
if (r.length) err$1(8);
|
|
503
|
+
return s;
|
|
504
|
+
}
|
|
505
|
+
}
|
|
506
|
+
var slzh = function(d, b) {
|
|
507
|
+
return b + 30 + b2(d, b + 26) + b2(d, b + 28);
|
|
508
|
+
};
|
|
509
|
+
var zh = function(d, b, z) {
|
|
510
|
+
var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4$1(d, b + 20);
|
|
511
|
+
var _a = z && bs == 4294967295 ? z64e(d, es) : [
|
|
512
|
+
bs,
|
|
513
|
+
b4$1(d, b + 24),
|
|
514
|
+
b4$1(d, b + 42)
|
|
515
|
+
], sc = _a[0], su = _a[1], off = _a[2];
|
|
516
|
+
return [
|
|
517
|
+
b2(d, b + 10),
|
|
518
|
+
sc,
|
|
519
|
+
su,
|
|
520
|
+
fn,
|
|
521
|
+
es + b2(d, b + 30) + b2(d, b + 32),
|
|
522
|
+
off
|
|
523
|
+
];
|
|
524
|
+
};
|
|
525
|
+
var z64e = function(d, b) {
|
|
526
|
+
for (; b2(d, b) != 1; b += 4 + b2(d, b + 2));
|
|
527
|
+
return [
|
|
528
|
+
b8(d, b + 12),
|
|
529
|
+
b8(d, b + 4),
|
|
530
|
+
b8(d, b + 20)
|
|
531
|
+
];
|
|
532
|
+
};
|
|
533
|
+
/**
|
|
534
|
+
* Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
|
|
535
|
+
* performance with more than one file.
|
|
536
|
+
* @param data The raw compressed ZIP file
|
|
537
|
+
* @param opts The ZIP extraction options
|
|
538
|
+
* @returns The decompressed files
|
|
539
|
+
*/
|
|
540
|
+
function unzipSync(data, opts) {
|
|
541
|
+
var files = {};
|
|
542
|
+
var e = data.length - 22;
|
|
543
|
+
for (; b4$1(data, e) != 101010256; --e) if (!e || data.length - e > 65558) err$1(13);
|
|
544
|
+
var c = b2(data, e + 8);
|
|
545
|
+
if (!c) return {};
|
|
546
|
+
var o = b4$1(data, e + 16);
|
|
547
|
+
var z = o == 4294967295 || c == 65535;
|
|
548
|
+
if (z) {
|
|
549
|
+
var ze = b4$1(data, e - 12);
|
|
550
|
+
z = b4$1(data, ze) == 101075792;
|
|
551
|
+
if (z) {
|
|
552
|
+
c = b4$1(data, ze + 32);
|
|
553
|
+
o = b4$1(data, ze + 48);
|
|
554
|
+
}
|
|
555
|
+
}
|
|
556
|
+
var fltr = opts && opts.filter;
|
|
557
|
+
for (var i = 0; i < c; ++i) {
|
|
558
|
+
var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
|
|
559
|
+
o = no;
|
|
560
|
+
if (!fltr || fltr({
|
|
561
|
+
name: fn,
|
|
562
|
+
size: sc,
|
|
563
|
+
originalSize: su,
|
|
564
|
+
compression: c_2
|
|
565
|
+
})) {
|
|
566
|
+
if (!c_2) files[fn] = slc$1(data, b, b + sc);
|
|
567
|
+
else if (c_2 == 8) files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8$1(su) });
|
|
568
|
+
else err$1(14, "unknown compression type " + c_2);
|
|
569
|
+
}
|
|
570
|
+
}
|
|
571
|
+
return files;
|
|
572
|
+
}
|
|
573
|
+
//#endregion
|
|
574
|
+
//#region node_modules/.pnpm/fzstd@0.1.1/node_modules/fzstd/esm/index.mjs
|
|
575
|
+
var ab = ArrayBuffer;
|
|
576
|
+
var u8 = Uint8Array;
|
|
577
|
+
var u16 = Uint16Array;
|
|
578
|
+
var i16 = Int16Array;
|
|
579
|
+
var i32 = Int32Array;
|
|
580
|
+
var slc = function(v, s, e) {
|
|
581
|
+
if (u8.prototype.slice) return u8.prototype.slice.call(v, s, e);
|
|
582
|
+
if (s == null || s < 0) s = 0;
|
|
583
|
+
if (e == null || e > v.length) e = v.length;
|
|
584
|
+
var n = new u8(e - s);
|
|
585
|
+
n.set(v.subarray(s, e));
|
|
586
|
+
return n;
|
|
587
|
+
};
|
|
588
|
+
var fill = function(v, n, s, e) {
|
|
589
|
+
if (u8.prototype.fill) return u8.prototype.fill.call(v, n, s, e);
|
|
590
|
+
if (s == null || s < 0) s = 0;
|
|
591
|
+
if (e == null || e > v.length) e = v.length;
|
|
592
|
+
for (; s < e; ++s) v[s] = n;
|
|
593
|
+
return v;
|
|
594
|
+
};
|
|
595
|
+
var cpw = function(v, t, s, e) {
|
|
596
|
+
if (u8.prototype.copyWithin) return u8.prototype.copyWithin.call(v, t, s, e);
|
|
597
|
+
if (s == null || s < 0) s = 0;
|
|
598
|
+
if (e == null || e > v.length) e = v.length;
|
|
599
|
+
while (s < e) v[t++] = v[s++];
|
|
600
|
+
};
|
|
601
|
+
var ec = [
|
|
602
|
+
"invalid zstd data",
|
|
603
|
+
"window size too large (>2046MB)",
|
|
604
|
+
"invalid block type",
|
|
605
|
+
"FSE accuracy too high",
|
|
606
|
+
"match distance too far back",
|
|
607
|
+
"unexpected EOF"
|
|
608
|
+
];
|
|
609
|
+
var err = function(ind, msg, nt) {
|
|
610
|
+
var e = new Error(msg || ec[ind]);
|
|
611
|
+
e.code = ind;
|
|
612
|
+
if (Error.captureStackTrace) Error.captureStackTrace(e, err);
|
|
613
|
+
if (!nt) throw e;
|
|
614
|
+
return e;
|
|
615
|
+
};
|
|
616
|
+
var rb = function(d, b, n) {
|
|
617
|
+
var i = 0, o = 0;
|
|
618
|
+
for (; i < n; ++i) o |= d[b++] << (i << 3);
|
|
619
|
+
return o;
|
|
620
|
+
};
|
|
621
|
+
var b4 = function(d, b) {
|
|
622
|
+
return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
|
|
623
|
+
};
|
|
624
|
+
var rzfh = function(dat, w) {
|
|
625
|
+
var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
|
|
626
|
+
if (n3 == 3126568 && dat[3] == 253) {
|
|
627
|
+
var flg = dat[4];
|
|
628
|
+
var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
|
|
629
|
+
if (flg & 8) err(0);
|
|
630
|
+
var bt = 6 - ss;
|
|
631
|
+
var db = df == 3 ? 4 : df;
|
|
632
|
+
var di = rb(dat, bt, db);
|
|
633
|
+
bt += db;
|
|
634
|
+
var fsb = fcf ? 1 << fcf : ss;
|
|
635
|
+
var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
|
|
636
|
+
var ws = fss;
|
|
637
|
+
if (!ss) {
|
|
638
|
+
var wb = 1 << 10 + (dat[5] >> 3);
|
|
639
|
+
ws = wb + (wb >> 3) * (dat[5] & 7);
|
|
640
|
+
}
|
|
641
|
+
if (ws > 2145386496) err(1);
|
|
642
|
+
var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
|
|
643
|
+
buf[0] = 1, buf[4] = 4, buf[8] = 8;
|
|
644
|
+
return {
|
|
645
|
+
b: bt + fsb,
|
|
646
|
+
y: 0,
|
|
647
|
+
l: 0,
|
|
648
|
+
d: di,
|
|
649
|
+
w: w && w != 1 ? w : buf.subarray(12),
|
|
650
|
+
e: ws,
|
|
651
|
+
o: new i32(buf.buffer, 0, 3),
|
|
652
|
+
u: fss,
|
|
653
|
+
c: cc,
|
|
654
|
+
m: Math.min(131072, ws)
|
|
655
|
+
};
|
|
656
|
+
} else if ((n3 >> 4 | dat[3] << 20) == 25481893) return b4(dat, 4) + 8;
|
|
657
|
+
err(0);
|
|
658
|
+
};
|
|
659
|
+
var msb = function(val) {
|
|
660
|
+
var bits = 0;
|
|
661
|
+
for (; 1 << bits <= val; ++bits);
|
|
662
|
+
return bits - 1;
|
|
663
|
+
};
|
|
664
|
+
var rfse = function(dat, bt, mal) {
|
|
665
|
+
var tpos = (bt << 3) + 4;
|
|
666
|
+
var al = (dat[bt] & 15) + 5;
|
|
667
|
+
if (al > mal) err(3);
|
|
668
|
+
var sz = 1 << al;
|
|
669
|
+
var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
|
|
670
|
+
var buf = new ab(512 + (sz << 2));
|
|
671
|
+
var freq = new i16(buf, 0, 256);
|
|
672
|
+
var dstate = new u16(buf, 0, 256);
|
|
673
|
+
var nstate = new u16(buf, 512, sz);
|
|
674
|
+
var bb1 = 512 + (sz << 1);
|
|
675
|
+
var syms = new u8(buf, bb1, sz);
|
|
676
|
+
var nbits = new u8(buf, bb1 + sz);
|
|
677
|
+
while (sym < 255 && probs > 0) {
|
|
678
|
+
var bits = msb(probs + 1);
|
|
679
|
+
var cbt = tpos >> 3;
|
|
680
|
+
var msk = (1 << bits + 1) - 1;
|
|
681
|
+
var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
|
|
682
|
+
var msk1fb = (1 << bits) - 1;
|
|
683
|
+
var msv = msk - probs - 1;
|
|
684
|
+
var sval = val & msk1fb;
|
|
685
|
+
if (sval < msv) tpos += bits, val = sval;
|
|
686
|
+
else {
|
|
687
|
+
tpos += bits + 1;
|
|
688
|
+
if (val > msk1fb) val -= msv;
|
|
689
|
+
}
|
|
690
|
+
freq[++sym] = --val;
|
|
691
|
+
if (val == -1) {
|
|
692
|
+
probs += val;
|
|
693
|
+
syms[--ht] = sym;
|
|
694
|
+
} else probs -= val;
|
|
695
|
+
if (!val) do {
|
|
696
|
+
var rbt = tpos >> 3;
|
|
697
|
+
re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
|
|
698
|
+
tpos += 2;
|
|
699
|
+
sym += re;
|
|
700
|
+
} while (re == 3);
|
|
701
|
+
}
|
|
702
|
+
if (sym > 255 || probs) err(0);
|
|
703
|
+
var sympos = 0;
|
|
704
|
+
var sstep = (sz >> 1) + (sz >> 3) + 3;
|
|
705
|
+
var smask = sz - 1;
|
|
706
|
+
for (var s = 0; s <= sym; ++s) {
|
|
707
|
+
var sf = freq[s];
|
|
708
|
+
if (sf < 1) {
|
|
709
|
+
dstate[s] = -sf;
|
|
710
|
+
continue;
|
|
711
|
+
}
|
|
712
|
+
for (i = 0; i < sf; ++i) {
|
|
713
|
+
syms[sympos] = s;
|
|
714
|
+
do
|
|
715
|
+
sympos = sympos + sstep & smask;
|
|
716
|
+
while (sympos >= ht);
|
|
717
|
+
}
|
|
718
|
+
}
|
|
719
|
+
if (sympos) err(0);
|
|
720
|
+
for (i = 0; i < sz; ++i) {
|
|
721
|
+
var ns = dstate[syms[i]]++;
|
|
722
|
+
var nb = nbits[i] = al - msb(ns);
|
|
723
|
+
nstate[i] = (ns << nb) - sz;
|
|
724
|
+
}
|
|
725
|
+
return [tpos + 7 >> 3, {
|
|
726
|
+
b: al,
|
|
727
|
+
s: syms,
|
|
728
|
+
n: nbits,
|
|
729
|
+
t: nstate
|
|
730
|
+
}];
|
|
731
|
+
};
|
|
732
|
+
var rhu = function(dat, bt) {
|
|
733
|
+
var i = 0, wc = -1;
|
|
734
|
+
var buf = new u8(292), hb = dat[bt];
|
|
735
|
+
var hw = buf.subarray(0, 256);
|
|
736
|
+
var rc = buf.subarray(256, 268);
|
|
737
|
+
var ri = new u16(buf.buffer, 268);
|
|
738
|
+
if (hb < 128) {
|
|
739
|
+
var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
|
|
740
|
+
bt += hb;
|
|
741
|
+
var epos = ebt << 3;
|
|
742
|
+
var lb = dat[bt];
|
|
743
|
+
if (!lb) err(0);
|
|
744
|
+
var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
|
|
745
|
+
var fpos = (++bt << 3) - 8 + msb(lb);
|
|
746
|
+
for (;;) {
|
|
747
|
+
fpos -= btr1;
|
|
748
|
+
if (fpos < epos) break;
|
|
749
|
+
var cbt = fpos >> 3;
|
|
750
|
+
st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
|
|
751
|
+
hw[++wc] = fdt.s[st1];
|
|
752
|
+
fpos -= btr2;
|
|
753
|
+
if (fpos < epos) break;
|
|
754
|
+
cbt = fpos >> 3;
|
|
755
|
+
st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
|
|
756
|
+
hw[++wc] = fdt.s[st2];
|
|
757
|
+
btr1 = fdt.n[st1];
|
|
758
|
+
st1 = fdt.t[st1];
|
|
759
|
+
btr2 = fdt.n[st2];
|
|
760
|
+
st2 = fdt.t[st2];
|
|
761
|
+
}
|
|
762
|
+
if (++wc > 255) err(0);
|
|
763
|
+
} else {
|
|
764
|
+
wc = hb - 127;
|
|
765
|
+
for (; i < wc; i += 2) {
|
|
766
|
+
var byte = dat[++bt];
|
|
767
|
+
hw[i] = byte >> 4;
|
|
768
|
+
hw[i + 1] = byte & 15;
|
|
769
|
+
}
|
|
770
|
+
++bt;
|
|
771
|
+
}
|
|
772
|
+
var wes = 0;
|
|
773
|
+
for (i = 0; i < wc; ++i) {
|
|
774
|
+
var wt = hw[i];
|
|
775
|
+
if (wt > 11) err(0);
|
|
776
|
+
wes += wt && 1 << wt - 1;
|
|
777
|
+
}
|
|
778
|
+
var mb = msb(wes) + 1;
|
|
779
|
+
var ts = 1 << mb;
|
|
780
|
+
var rem = ts - wes;
|
|
781
|
+
if (rem & rem - 1) err(0);
|
|
782
|
+
hw[wc++] = msb(rem) + 1;
|
|
783
|
+
for (i = 0; i < wc; ++i) {
|
|
784
|
+
var wt = hw[i];
|
|
785
|
+
++rc[hw[i] = wt && mb + 1 - wt];
|
|
786
|
+
}
|
|
787
|
+
var hbuf = new u8(ts << 1);
|
|
788
|
+
var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
|
|
789
|
+
ri[mb] = 0;
|
|
790
|
+
for (i = mb; i > 0; --i) {
|
|
791
|
+
var pv = ri[i];
|
|
792
|
+
fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
|
|
793
|
+
}
|
|
794
|
+
if (ri[0] != ts) err(0);
|
|
795
|
+
for (i = 0; i < wc; ++i) {
|
|
796
|
+
var bits = hw[i];
|
|
797
|
+
if (bits) {
|
|
798
|
+
var code = ri[bits];
|
|
799
|
+
fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
|
|
800
|
+
}
|
|
801
|
+
}
|
|
802
|
+
return [bt, {
|
|
803
|
+
n: nb,
|
|
804
|
+
b: mb,
|
|
805
|
+
s: syms
|
|
806
|
+
}];
|
|
807
|
+
};
|
|
808
|
+
var dllt = (/*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
|
|
809
|
+
81,
|
|
810
|
+
16,
|
|
811
|
+
99,
|
|
812
|
+
140,
|
|
813
|
+
49,
|
|
814
|
+
198,
|
|
815
|
+
24,
|
|
816
|
+
99,
|
|
817
|
+
12,
|
|
818
|
+
33,
|
|
819
|
+
196,
|
|
820
|
+
24,
|
|
821
|
+
99,
|
|
822
|
+
102,
|
|
823
|
+
102,
|
|
824
|
+
134,
|
|
825
|
+
70,
|
|
826
|
+
146,
|
|
827
|
+
4
|
|
828
|
+
]), 0, 6))[1];
|
|
829
|
+
var dmlt = (/*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
|
|
830
|
+
33,
|
|
831
|
+
20,
|
|
832
|
+
196,
|
|
833
|
+
24,
|
|
834
|
+
99,
|
|
835
|
+
140,
|
|
836
|
+
33,
|
|
837
|
+
132,
|
|
838
|
+
16,
|
|
839
|
+
66,
|
|
840
|
+
8,
|
|
841
|
+
33,
|
|
842
|
+
132,
|
|
843
|
+
16,
|
|
844
|
+
66,
|
|
845
|
+
8,
|
|
846
|
+
33,
|
|
847
|
+
68,
|
|
848
|
+
68,
|
|
849
|
+
68,
|
|
850
|
+
68,
|
|
851
|
+
68,
|
|
852
|
+
68,
|
|
853
|
+
68,
|
|
854
|
+
68,
|
|
855
|
+
36,
|
|
856
|
+
9
|
|
857
|
+
]), 0, 6))[1];
|
|
858
|
+
var doct = (/*#__PURE__ */ rfse(/*#__PURE__*/ new u8([
|
|
859
|
+
32,
|
|
860
|
+
132,
|
|
861
|
+
16,
|
|
862
|
+
66,
|
|
863
|
+
102,
|
|
864
|
+
70,
|
|
865
|
+
68,
|
|
866
|
+
68,
|
|
867
|
+
68,
|
|
868
|
+
68,
|
|
869
|
+
36,
|
|
870
|
+
73,
|
|
871
|
+
2
|
|
872
|
+
]), 0, 5))[1];
|
|
873
|
+
var b2bl = function(b, s) {
|
|
874
|
+
var len = b.length, bl = new i32(len);
|
|
875
|
+
for (var i = 0; i < len; ++i) {
|
|
876
|
+
bl[i] = s;
|
|
877
|
+
s += 1 << b[i];
|
|
878
|
+
}
|
|
879
|
+
return bl;
|
|
880
|
+
};
|
|
881
|
+
var llb = /*#__PURE__ */ new u8((/*#__PURE__ */ new i32([
|
|
882
|
+
0,
|
|
883
|
+
0,
|
|
884
|
+
0,
|
|
885
|
+
0,
|
|
886
|
+
16843009,
|
|
887
|
+
50528770,
|
|
888
|
+
134678020,
|
|
889
|
+
202050057,
|
|
890
|
+
269422093
|
|
891
|
+
])).buffer, 0, 36);
|
|
892
|
+
var llbl = /*#__PURE__ */ b2bl(llb, 0);
|
|
893
|
+
var mlb = /*#__PURE__ */ new u8((/*#__PURE__ */ new i32([
|
|
894
|
+
0,
|
|
895
|
+
0,
|
|
896
|
+
0,
|
|
897
|
+
0,
|
|
898
|
+
0,
|
|
899
|
+
0,
|
|
900
|
+
0,
|
|
901
|
+
0,
|
|
902
|
+
16843009,
|
|
903
|
+
50528770,
|
|
904
|
+
117769220,
|
|
905
|
+
185207048,
|
|
906
|
+
252579084,
|
|
907
|
+
16
|
|
908
|
+
])).buffer, 0, 53);
|
|
909
|
+
var mlbl = /*#__PURE__ */ b2bl(mlb, 3);
|
|
910
|
+
var dhu = function(dat, out, hu) {
|
|
911
|
+
var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
|
|
912
|
+
if (!lb) err(0);
|
|
913
|
+
var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
|
|
914
|
+
for (; pos > eb && i < ss;) {
|
|
915
|
+
var cbt = pos >> 3;
|
|
916
|
+
var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
|
|
917
|
+
st = (st << btr | val) & msk;
|
|
918
|
+
out[++i] = hu.s[st];
|
|
919
|
+
pos -= btr = hu.n[st];
|
|
920
|
+
}
|
|
921
|
+
if (pos != eb || i + 1 != ss) err(0);
|
|
922
|
+
};
|
|
923
|
+
var dhu4 = function(dat, out, hu) {
|
|
924
|
+
var bt = 6;
|
|
925
|
+
var sz1 = out.length + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
|
|
926
|
+
dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
|
|
927
|
+
dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
|
|
928
|
+
dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
|
|
929
|
+
dhu(dat.subarray(bt), out.subarray(sz3), hu);
|
|
930
|
+
};
|
|
931
|
+
var rzb = function(dat, st, out) {
|
|
932
|
+
var _a;
|
|
933
|
+
var bt = st.b;
|
|
934
|
+
var b0 = dat[bt], btype = b0 >> 1 & 3;
|
|
935
|
+
st.l = b0 & 1;
|
|
936
|
+
var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
|
|
937
|
+
var ebt = (bt += 3) + sz;
|
|
938
|
+
if (btype == 1) {
|
|
939
|
+
if (bt >= dat.length) return;
|
|
940
|
+
st.b = bt + 1;
|
|
941
|
+
if (out) {
|
|
942
|
+
fill(out, dat[bt], st.y, st.y += sz);
|
|
943
|
+
return out;
|
|
944
|
+
}
|
|
945
|
+
return fill(new u8(sz), dat[bt]);
|
|
946
|
+
}
|
|
947
|
+
if (ebt > dat.length) return;
|
|
948
|
+
if (btype == 0) {
|
|
949
|
+
st.b = ebt;
|
|
950
|
+
if (out) {
|
|
951
|
+
out.set(dat.subarray(bt, ebt), st.y);
|
|
952
|
+
st.y += sz;
|
|
953
|
+
return out;
|
|
954
|
+
}
|
|
955
|
+
return slc(dat, bt, ebt);
|
|
956
|
+
}
|
|
957
|
+
if (btype == 2) {
|
|
958
|
+
var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
|
|
959
|
+
var lss = b3 >> 4, lcs = 0, s4 = 0;
|
|
960
|
+
if (lbt < 2) {
|
|
961
|
+
if (sf & 1) lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
|
|
962
|
+
else lss = b3 >> 3;
|
|
963
|
+
} else {
|
|
964
|
+
s4 = sf;
|
|
965
|
+
if (sf < 2) lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
|
|
966
|
+
else if (sf == 2) lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
|
|
967
|
+
else lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
|
|
968
|
+
}
|
|
969
|
+
++bt;
|
|
970
|
+
var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
|
|
971
|
+
var spl = buf.length - lss;
|
|
972
|
+
if (lbt == 0) buf.set(dat.subarray(bt, bt += lss), spl);
|
|
973
|
+
else if (lbt == 1) fill(buf, dat[bt++], spl);
|
|
974
|
+
else {
|
|
975
|
+
var hu = st.h;
|
|
976
|
+
if (lbt == 2) {
|
|
977
|
+
var hud = rhu(dat, bt);
|
|
978
|
+
lcs += bt - (bt = hud[0]);
|
|
979
|
+
st.h = hu = hud[1];
|
|
980
|
+
} else if (!hu) err(0);
|
|
981
|
+
(s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
|
|
982
|
+
}
|
|
983
|
+
var ns = dat[bt++];
|
|
984
|
+
if (ns) {
|
|
985
|
+
if (ns == 255) ns = (dat[bt++] | dat[bt++] << 8) + 32512;
|
|
986
|
+
else if (ns > 127) ns = ns - 128 << 8 | dat[bt++];
|
|
987
|
+
var scm = dat[bt++];
|
|
988
|
+
if (scm & 3) err(0);
|
|
989
|
+
var dts = [
|
|
990
|
+
dmlt,
|
|
991
|
+
doct,
|
|
992
|
+
dllt
|
|
993
|
+
];
|
|
994
|
+
for (var i = 2; i > -1; --i) {
|
|
995
|
+
var md = scm >> (i << 1) + 2 & 3;
|
|
996
|
+
if (md == 1) {
|
|
997
|
+
var rbuf = new u8([
|
|
998
|
+
0,
|
|
999
|
+
0,
|
|
1000
|
+
dat[bt++]
|
|
1001
|
+
]);
|
|
1002
|
+
dts[i] = {
|
|
1003
|
+
s: rbuf.subarray(2, 3),
|
|
1004
|
+
n: rbuf.subarray(0, 1),
|
|
1005
|
+
t: new u16(rbuf.buffer, 0, 1),
|
|
1006
|
+
b: 0
|
|
1007
|
+
};
|
|
1008
|
+
} else if (md == 2) _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
|
|
1009
|
+
else if (md == 3) {
|
|
1010
|
+
if (!st.t) err(0);
|
|
1011
|
+
dts[i] = st.t[i];
|
|
1012
|
+
}
|
|
1013
|
+
}
|
|
1014
|
+
var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
|
|
1015
|
+
var lb = dat[ebt - 1];
|
|
1016
|
+
if (!lb) err(0);
|
|
1017
|
+
var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
|
|
1018
|
+
var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
|
|
1019
|
+
cbt = (spos -= oct.b) >> 3;
|
|
1020
|
+
var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
|
|
1021
|
+
cbt = (spos -= mlt.b) >> 3;
|
|
1022
|
+
var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
|
|
1023
|
+
for (++ns; --ns;) {
|
|
1024
|
+
var llc = llt.s[lst];
|
|
1025
|
+
var lbtr = llt.n[lst];
|
|
1026
|
+
var mlc = mlt.s[mst];
|
|
1027
|
+
var mbtr = mlt.n[mst];
|
|
1028
|
+
var ofc = oct.s[ost];
|
|
1029
|
+
var obtr = oct.n[ost];
|
|
1030
|
+
cbt = (spos -= ofc) >> 3;
|
|
1031
|
+
var ofp = 1 << ofc;
|
|
1032
|
+
var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
|
|
1033
|
+
cbt = (spos -= mlb[mlc]) >> 3;
|
|
1034
|
+
var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
|
|
1035
|
+
cbt = (spos -= llb[llc]) >> 3;
|
|
1036
|
+
var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
|
|
1037
|
+
cbt = (spos -= lbtr) >> 3;
|
|
1038
|
+
lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
|
|
1039
|
+
cbt = (spos -= mbtr) >> 3;
|
|
1040
|
+
mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
|
|
1041
|
+
cbt = (spos -= obtr) >> 3;
|
|
1042
|
+
ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
|
|
1043
|
+
if (off > 3) {
|
|
1044
|
+
st.o[2] = st.o[1];
|
|
1045
|
+
st.o[1] = st.o[0];
|
|
1046
|
+
st.o[0] = off -= 3;
|
|
1047
|
+
} else {
|
|
1048
|
+
var idx = off - (ll != 0);
|
|
1049
|
+
if (idx) {
|
|
1050
|
+
off = idx == 3 ? st.o[0] - 1 : st.o[idx];
|
|
1051
|
+
if (idx > 1) st.o[2] = st.o[1];
|
|
1052
|
+
st.o[1] = st.o[0];
|
|
1053
|
+
st.o[0] = off;
|
|
1054
|
+
} else off = st.o[0];
|
|
1055
|
+
}
|
|
1056
|
+
for (var i = 0; i < ll; ++i) buf[oubt + i] = buf[spl + i];
|
|
1057
|
+
oubt += ll, spl += ll;
|
|
1058
|
+
var stin = oubt - off;
|
|
1059
|
+
if (stin < 0) {
|
|
1060
|
+
var len = -stin;
|
|
1061
|
+
var bs = st.e + stin;
|
|
1062
|
+
if (len > ml) len = ml;
|
|
1063
|
+
for (var i = 0; i < len; ++i) buf[oubt + i] = st.w[bs + i];
|
|
1064
|
+
oubt += len, ml -= len, stin = 0;
|
|
1065
|
+
}
|
|
1066
|
+
for (var i = 0; i < ml; ++i) buf[oubt + i] = buf[stin + i];
|
|
1067
|
+
oubt += ml;
|
|
1068
|
+
}
|
|
1069
|
+
if (oubt != spl) while (spl < buf.length) buf[oubt++] = buf[spl++];
|
|
1070
|
+
else oubt = buf.length;
|
|
1071
|
+
if (out) st.y += oubt;
|
|
1072
|
+
else buf = slc(buf, 0, oubt);
|
|
1073
|
+
} else if (out) {
|
|
1074
|
+
st.y += lss;
|
|
1075
|
+
if (spl) for (var i = 0; i < lss; ++i) buf[i] = buf[spl + i];
|
|
1076
|
+
} else if (spl) buf = slc(buf, spl);
|
|
1077
|
+
st.b = ebt;
|
|
1078
|
+
return buf;
|
|
1079
|
+
}
|
|
1080
|
+
err(2);
|
|
1081
|
+
};
|
|
1082
|
+
var cct = function(bufs, ol) {
|
|
1083
|
+
if (bufs.length == 1) return bufs[0];
|
|
1084
|
+
var buf = new u8(ol);
|
|
1085
|
+
for (var i = 0, b = 0; i < bufs.length; ++i) {
|
|
1086
|
+
var chk = bufs[i];
|
|
1087
|
+
buf.set(chk, b);
|
|
1088
|
+
b += chk.length;
|
|
1089
|
+
}
|
|
1090
|
+
return buf;
|
|
1091
|
+
};
|
|
1092
|
+
/**
|
|
1093
|
+
* Decompresses Zstandard data
|
|
1094
|
+
* @param dat The input data
|
|
1095
|
+
* @param buf The output buffer. If unspecified, the function will allocate
|
|
1096
|
+
* exactly enough memory to fit the decompressed data. If your
|
|
1097
|
+
* data has multiple frames and you know the output size, specifying
|
|
1098
|
+
* it will yield better performance.
|
|
1099
|
+
* @returns The decompressed data
|
|
1100
|
+
*/
|
|
1101
|
+
function decompress(dat, buf) {
|
|
1102
|
+
var bufs = [], nb = +!buf;
|
|
1103
|
+
var bt = 0, ol = 0;
|
|
1104
|
+
for (; dat.length;) {
|
|
1105
|
+
var st = rzfh(dat, nb || buf);
|
|
1106
|
+
if (typeof st == "object") {
|
|
1107
|
+
if (nb) {
|
|
1108
|
+
buf = null;
|
|
1109
|
+
if (st.w.length == st.u) {
|
|
1110
|
+
bufs.push(buf = st.w);
|
|
1111
|
+
ol += st.u;
|
|
1112
|
+
}
|
|
1113
|
+
} else {
|
|
1114
|
+
bufs.push(buf);
|
|
1115
|
+
st.e = 0;
|
|
1116
|
+
}
|
|
1117
|
+
for (; !st.l;) {
|
|
1118
|
+
var blk = rzb(dat, st, buf);
|
|
1119
|
+
if (!blk) err(5);
|
|
1120
|
+
if (buf) st.e = st.y;
|
|
1121
|
+
else {
|
|
1122
|
+
bufs.push(blk);
|
|
1123
|
+
ol += blk.length;
|
|
1124
|
+
cpw(st.w, 0, blk.length);
|
|
1125
|
+
st.w.set(blk, st.w.length - blk.length);
|
|
1126
|
+
}
|
|
1127
|
+
}
|
|
1128
|
+
bt = st.b + st.c * 4;
|
|
1129
|
+
} else bt = st;
|
|
1130
|
+
dat = dat.subarray(bt);
|
|
1131
|
+
}
|
|
1132
|
+
return cct(bufs, ol);
|
|
1133
|
+
}
|
|
1134
|
+
//#endregion
|
|
1135
|
+
//#region .agents/skills/compaction-eval/scripts/session-source.ts
|
|
1136
|
+
/**
|
|
1137
|
+
* 读取压缩评估的会话来源:本地 ~/.dsh/sessions、DSH 导出的会话日志 zip 与重压缩日志目录,
|
|
1138
|
+
* 并由日志重建宿主 Session。prepare 与 view 共用;不含命令行入口。
|
|
1139
|
+
* 导出 Content / Usage / EventData / SessionEvent / SessionBundle 类型与
|
|
1140
|
+
* loadLog / readZip / loadVariants / loadBundle / toSession。
|
|
1141
|
+
*/
|
|
1142
|
+
/** 会话根目录。 */
|
|
1143
|
+
const SESSIONS = join(homedir(), ".dsh", "sessions");
|
|
1144
|
+
/** 导出 zip 中的根会话日志。 */
|
|
1145
|
+
const ZIP_MAIN_RE = /^session(\.v\d+)?\.jsonl$/;
|
|
1146
|
+
/** 导出 zip 中的压缩日志。 */
|
|
1147
|
+
const ZIP_LOG_RE = /^subagents\/om-compaction-log-[^/]+\/session(\.v\d+)?\.jsonl$/;
|
|
1148
|
+
/** 变体目录中的压缩日志相对路径:om-compaction-log-<id>/session[.vN].jsonl[.zstd]。 */
|
|
1149
|
+
const VARIANT_LOG_RE = /(^|\/)om-compaction-log-[^/]+\/session(\.v\d+)?\.jsonl(\.zstd)?$/;
|
|
1150
|
+
/** 解析 jsonl 文本为事件列表。 */
|
|
1151
|
+
function parseJsonl(text) {
|
|
1152
|
+
return text.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
|
|
1153
|
+
}
|
|
1154
|
+
/** 读取会话日志:多帧 zstd 追加写入或已解压 jsonl。 */
|
|
1155
|
+
function loadLog(path) {
|
|
1156
|
+
const raw = readFileSync(path);
|
|
1157
|
+
return parseJsonl(path.endsWith(".zstd") ? new TextDecoder().decode(decompress(raw)) : raw.toString("utf8"));
|
|
1158
|
+
}
|
|
1159
|
+
/** 读取 DSH 导出的会话日志 zip:根日志为主会话,subagents 下的 om-compaction-log-* 为压缩日志。 */
|
|
1160
|
+
function readZip(path) {
|
|
1161
|
+
const files = unzipSync(readFileSync(path), { filter: (f) => ZIP_MAIN_RE.test(f.name) || ZIP_LOG_RE.test(f.name) });
|
|
1162
|
+
const entries = Object.entries(files);
|
|
1163
|
+
const decode = (bytes) => parseJsonl(new TextDecoder().decode(bytes));
|
|
1164
|
+
const main = entries.find(([name]) => ZIP_MAIN_RE.test(name));
|
|
1165
|
+
if (!main) throw new Error(`zip 中未找到根会话日志:${path}`);
|
|
1166
|
+
const logs = entries.filter(([name]) => ZIP_LOG_RE.test(name)).map(([, bytes]) => decode(bytes));
|
|
1167
|
+
if (!logs.length) throw new Error(`zip 中没有压缩日志,导出时需包含 subagents:${path}`);
|
|
1168
|
+
return {
|
|
1169
|
+
main: decode(main[1]),
|
|
1170
|
+
logs
|
|
1171
|
+
};
|
|
1172
|
+
}
|
|
1173
|
+
/** 会话目录下的日志文件。 */
|
|
1174
|
+
function logFile(sessionDir) {
|
|
1175
|
+
const name = readdirSync(sessionDir).find((f) => /^session\..*\.jsonl/.test(f));
|
|
1176
|
+
if (!name) throw new Error(`未找到日志文件:${sessionDir}`);
|
|
1177
|
+
return join(sessionDir, name);
|
|
1178
|
+
}
|
|
1179
|
+
/** 在全部工作区中按 id 前缀定位主会话目录。 */
|
|
1180
|
+
function findMain(prefix) {
|
|
1181
|
+
const p = bareId(prefix);
|
|
1182
|
+
const hits = readdirSync(SESSIONS).flatMap((ws) => {
|
|
1183
|
+
const dir = join(SESSIONS, ws);
|
|
1184
|
+
if (!statSync(dir).isDirectory()) return [];
|
|
1185
|
+
return readdirSync(dir).filter((d) => bareId(d).startsWith(p) && !d.startsWith("om-compaction-log")).map((d) => join(dir, d)).filter((d) => statSync(d).isDirectory());
|
|
1186
|
+
});
|
|
1187
|
+
const [hit] = hits;
|
|
1188
|
+
if (hits.length !== 1 || !hit) throw new Error(`会话前缀 ${prefix} 匹配 ${hits.length} 个目录:${hits.join(", ")}`);
|
|
1189
|
+
return hit;
|
|
1190
|
+
}
|
|
1191
|
+
/** 读取本地会话:按 id 前缀定位主会话,压缩日志取同一工作区目录。 */
|
|
1192
|
+
function loadLocal(prefix) {
|
|
1193
|
+
const mainDir = findMain(prefix);
|
|
1194
|
+
const wsDir = dirname(mainDir);
|
|
1195
|
+
const logs = readdirSync(wsDir).filter((d) => d.startsWith("om-compaction-log-")).map((d) => loadLog(logFile(join(wsDir, d))));
|
|
1196
|
+
return {
|
|
1197
|
+
main: loadLog(logFile(mainDir)),
|
|
1198
|
+
logs
|
|
1199
|
+
};
|
|
1200
|
+
}
|
|
1201
|
+
/** 读取目录下全部压缩日志:递归匹配 om-compaction-log-* 会话目录中的日志文件。 */
|
|
1202
|
+
function loadVariants(dir) {
|
|
1203
|
+
const root = resolve(dir);
|
|
1204
|
+
const files = readdirSync(root, {
|
|
1205
|
+
recursive: true,
|
|
1206
|
+
encoding: "utf8"
|
|
1207
|
+
}).filter((p) => VARIANT_LOG_RE.test(p.replaceAll("\\", "/")));
|
|
1208
|
+
if (!files.length) throw new Error(`目录中没有压缩日志:${root}`);
|
|
1209
|
+
return files.map((p) => loadLog(join(root, p)));
|
|
1210
|
+
}
|
|
1211
|
+
/** 按 --session 前缀或 --zip 路径读取会话,二者恰选其一。 */
|
|
1212
|
+
function loadBundle(source) {
|
|
1213
|
+
if (!source.session === !source.zip) throw new Error("需指定 --session 或 --zip 之一");
|
|
1214
|
+
return source.zip ? readZip(resolve(source.zip)) : loadLocal(source.session ?? "");
|
|
1215
|
+
}
|
|
1216
|
+
/**
|
|
1217
|
+
* 由会话日志重建会话;可截到某个 seq(含)为止,得到当时的表层。
|
|
1218
|
+
* 日志来自 DSH 落盘的 jsonl,首行为会话头、其后 seq 与下标一致;Session.create 会校验事件与头字段。
|
|
1219
|
+
*/
|
|
1220
|
+
function toSession(events, lastSeq) {
|
|
1221
|
+
const [head, ...body] = events;
|
|
1222
|
+
if (!head?.id) throw new Error("日志缺少会话头");
|
|
1223
|
+
const { type: _type, ...header } = head;
|
|
1224
|
+
const seed = lastSeq === void 0 ? body : body.slice(0, lastSeq + 1);
|
|
1225
|
+
return Session.create(SessionId(head.id), seed, header);
|
|
1226
|
+
}
|
|
1227
|
+
//#endregion
|
|
1228
|
+
//#region .agents/skills/compaction-eval/scripts/prepare.ts
|
|
1229
|
+
/**
|
|
1230
|
+
* 准备压缩质量评估数据:定位主会话的压缩日志,按区间分组,导出盲化变体、原文、后续轨迹与规则。
|
|
1231
|
+
*
|
|
1232
|
+
* 用法:node prepare.ts (--session <主会话 id 或前缀> | --zip <会话日志 zip>)
|
|
1233
|
+
* [--variants 目录]... [--range A..B] [--phase observe|reflect] [--out 目录] [--seed N]
|
|
1234
|
+
* [--after-max N] [--list]
|
|
1235
|
+
* 输入:本地 ~/.dsh/sessions,或 DSH 导出的会话日志 zip,需含 subagents;
|
|
1236
|
+
* --variants 可重复,并入 compress.ts 产出目录中的压缩日志。
|
|
1237
|
+
* --list 只列出各区间的候选与 token,不写评估目录;正常运行也先打印同一列表。
|
|
1238
|
+
* 产出:V*.xml、source.xml、after.md、rules.md、_blind_key.json、meta.json;
|
|
1239
|
+
* after.md 为区间终点完整消息之后的轨迹,只含用户消息、手动加载的 skill、
|
|
1240
|
+
* 助手正文、工具调用与压缩标记;缺省写入系统临时目录下的
|
|
1241
|
+
* om-compaction-eval/eval-<会话 id 前 8 位>-<阶段>-<A>-<B>/。
|
|
1242
|
+
*/
|
|
1243
|
+
/** 压缩指令中的区间。 */
|
|
1244
|
+
const RANGE_RE = /区间 \[(\d+)\.\.(\d+)\]/;
|
|
1245
|
+
/** 压缩日志尾部的模型说明;思考等级可为中文(如「默认思考等级」)。 */
|
|
1246
|
+
const MODEL_RE = /压缩使用模型 (\S+?)(([^)]+))/;
|
|
1247
|
+
/** 评估目录中表明评审已开始的产物:重写候选会让它们对上新的编号。 */
|
|
1248
|
+
const REVIEW_RE = /^(facts\.json|judge-.+\.json|parts)$/;
|
|
1249
|
+
/** 重写候选前清除的旧产物:候选变少时残留的 V*.xml 与旧评分。 */
|
|
1250
|
+
const STALE_RE = /^(V\d+\.xml|scores\.(json|md))$/;
|
|
1251
|
+
/** 准备评估目录:已有事实清单、评审或分段产物时报错;否则建目录并清除旧候选与评分。 */
|
|
1252
|
+
function prepareEvalDir(dir) {
|
|
1253
|
+
mkdirSync(dir, { recursive: true });
|
|
1254
|
+
const names = readdirSync(dir);
|
|
1255
|
+
const reviewed = names.filter((n) => REVIEW_RE.test(n)).sort();
|
|
1256
|
+
if (reviewed.length) throw new Error(`评估目录已有评审产物 ${reviewed.join("、")}:${dir}。重评同一区间前先删除该目录`);
|
|
1257
|
+
for (const n of names) if (STALE_RE.test(n)) rmSync(join(dir, n));
|
|
1258
|
+
}
|
|
1259
|
+
/** 拼接消息 content 中的文本。 */
|
|
1260
|
+
function textOf(content) {
|
|
1261
|
+
return (content ?? []).map((c) => c.text ?? "").join("");
|
|
1262
|
+
}
|
|
1263
|
+
/** callId → tool/result data。 */
|
|
1264
|
+
function resultsByCall(events) {
|
|
1265
|
+
const out = /* @__PURE__ */ new Map();
|
|
1266
|
+
for (const e of events) {
|
|
1267
|
+
if (e.type !== "tool/result" || !e.data) continue;
|
|
1268
|
+
const id = e.data.callId ?? e.data.message?.toolCallId;
|
|
1269
|
+
if (id) out.set(id, e.data);
|
|
1270
|
+
}
|
|
1271
|
+
return out;
|
|
1272
|
+
}
|
|
1273
|
+
/** 逐轮模型请求耗时之和:step/start 到该轮 assistant/message,限流等待不计入。 */
|
|
1274
|
+
function modelSeconds(body) {
|
|
1275
|
+
let ms = 0;
|
|
1276
|
+
let start;
|
|
1277
|
+
for (const e of body) if (e.type === "step/start") start = e.time;
|
|
1278
|
+
else if (e.type === "assistant/message" && start !== void 0 && typeof e.time === "number") {
|
|
1279
|
+
ms += e.time - start;
|
|
1280
|
+
start = void 0;
|
|
1281
|
+
}
|
|
1282
|
+
return Math.round(ms / 100) / 10;
|
|
1283
|
+
}
|
|
1284
|
+
/** 解析单个压缩日志:阶段、区间、模型、耗时、token、产物与原文视图。 */
|
|
1285
|
+
function parseLog(events) {
|
|
1286
|
+
const [head, ...body] = events;
|
|
1287
|
+
if (!head?.id) throw new Error("日志缺少会话头");
|
|
1288
|
+
const label = body.find((e) => e.type === "subagent/descriptor")?.data?.label ?? "";
|
|
1289
|
+
const firstUser = textOf(body.find((e) => e.type === "user/message")?.data?.content);
|
|
1290
|
+
const rng = RANGE_RE.exec(firstUser);
|
|
1291
|
+
const assistants = body.filter((e) => e.type === "assistant/message");
|
|
1292
|
+
const model = assistants.map((e) => MODEL_RE.exec(textOf(e.data?.message?.content))).filter((m) => m !== null).at(-1);
|
|
1293
|
+
const usage = assistants.flatMap((e) => e.data?.usage ? [e.data.usage] : []);
|
|
1294
|
+
const times = body.flatMap((e) => typeof e.time === "number" ? [e.time] : []);
|
|
1295
|
+
const res = resultsByCall(body);
|
|
1296
|
+
const cc = body.find((e) => e.type === "tool/call" && e.data?.name === "completeCompression" && e.data.callId);
|
|
1297
|
+
const ccRes = cc?.data?.callId ? res.get(cc.data.callId) : void 0;
|
|
1298
|
+
const product = ccRes && !ccRes.message?.isError ? textOf(ccRes.message?.content) : "";
|
|
1299
|
+
const views = [];
|
|
1300
|
+
for (const e of body) {
|
|
1301
|
+
if (e.type !== "tool/call" || !e.data?.callId) continue;
|
|
1302
|
+
const r = res.get(e.data.callId);
|
|
1303
|
+
if (!r || r.message?.isError) continue;
|
|
1304
|
+
if (e.data.name === "compressHistory") break;
|
|
1305
|
+
if (e.data.name === "getHistory") views.push([JSON.parse(e.data.arguments || "{}"), textOf(r.message?.content)]);
|
|
1306
|
+
}
|
|
1307
|
+
return {
|
|
1308
|
+
id: head.id,
|
|
1309
|
+
parent: head.parentSession,
|
|
1310
|
+
range: rng ? [Number(rng[1]), Number(rng[2])] : void 0,
|
|
1311
|
+
phase: label.includes("观察") ? "observe" : label.includes("反思") ? "reflect" : "unknown",
|
|
1312
|
+
failed: label.includes("失败"),
|
|
1313
|
+
model: model?.[1] ?? "unknown",
|
|
1314
|
+
effort: model?.[2] ?? "unknown",
|
|
1315
|
+
recompress: label.includes("重压缩"),
|
|
1316
|
+
wall_sec: times.length ? Math.round((Math.max(...times) - Math.min(...times)) / 100) / 10 : 0,
|
|
1317
|
+
model_sec: modelSeconds(body),
|
|
1318
|
+
requests: usage.length,
|
|
1319
|
+
tokens_in: usage.reduce((s, u) => s + (u.inputTokens ?? 0) + (u.cacheReadTokens ?? 0) + (u.cacheWriteTokens ?? 0), 0),
|
|
1320
|
+
tokens_cache_read: usage.reduce((s, u) => s + (u.cacheReadTokens ?? 0), 0),
|
|
1321
|
+
tokens_cache_write: usage.reduce((s, u) => s + (u.cacheWriteTokens ?? 0), 0),
|
|
1322
|
+
tokens_out: usage.reduce((s, u) => s + (u.outputTokens ?? 0), 0),
|
|
1323
|
+
product,
|
|
1324
|
+
views,
|
|
1325
|
+
created: head.createdAt ?? 0
|
|
1326
|
+
};
|
|
1327
|
+
}
|
|
1328
|
+
/** 取覆盖整个区间的 getHistory 视图作为原文,优先原始压缩日志。 */
|
|
1329
|
+
function pickSource(logs, lo, hi) {
|
|
1330
|
+
const ordered = [...logs].sort((a, b) => Number(a.recompress) - Number(b.recompress));
|
|
1331
|
+
for (const log of ordered) for (const [args, view] of log.views) if ((args.start ?? lo) === lo && (args.end ?? hi) === hi) return view;
|
|
1332
|
+
const size = (l) => l.views.reduce((s, [, v]) => s + v.length, 0);
|
|
1333
|
+
return ordered.reduce((a, b) => size(b) > size(a) ? b : a).views.map(([, v]) => v).join("\n");
|
|
1334
|
+
}
|
|
1335
|
+
/** 去掉注释,省略逐字保留的 skill 原文。 */
|
|
1336
|
+
function blindProduct(text) {
|
|
1337
|
+
return text.replace(/<!--[\s\S]*?-->/g, "").replace(/(<skill_content[^>]*>)[\s\S]*?(<\/skill_content>)/g, "$1[skill 原文逐字保留,已省略]$2");
|
|
1338
|
+
}
|
|
1339
|
+
/** 主会话中区间终点完整消息之后的真实轨迹,超过 limit 字符截断。 */
|
|
1340
|
+
function buildAfter(main, hi, limit) {
|
|
1341
|
+
const target = indexCompleteMessages(toSession(main))[hi];
|
|
1342
|
+
if (!target) throw new Error(`主会话中找不到完整消息 ${hi},无法定位后续轨迹起点`);
|
|
1343
|
+
const start = Math.max(...target.seqs) + 1;
|
|
1344
|
+
const res = resultsByCall(main);
|
|
1345
|
+
const out = [];
|
|
1346
|
+
let size = 0;
|
|
1347
|
+
for (const e of main.slice(start + 1)) {
|
|
1348
|
+
const d = e.data;
|
|
1349
|
+
let line = "";
|
|
1350
|
+
if (e.type === "user/message") {
|
|
1351
|
+
const txt = textOf(d?.content).slice(0, 1500);
|
|
1352
|
+
if (d?.source?.kind === "user") line = `[USER] ${txt}`;
|
|
1353
|
+
else if (d?.source?.kind === "skill-invocation" && d.source.name) line = `[SKILL ${d.source.name}] ${txt}`;
|
|
1354
|
+
} else if (e.type === "assistant/message") {
|
|
1355
|
+
const txt = (d?.message?.content ?? []).filter((b) => b.type === "text").map((b) => b.text ?? "").join("").trim();
|
|
1356
|
+
if (txt) line = `[ASSISTANT] ${txt.slice(0, 2500)}`;
|
|
1357
|
+
} else if (e.type === "tool/call" && d?.callId) {
|
|
1358
|
+
const rt = textOf(res.get(d.callId)?.message?.content);
|
|
1359
|
+
line = `[TOOL ${d.name}] args=${(d.arguments ?? "").slice(0, 300)}\n result=${rt.slice(0, 600)}`;
|
|
1360
|
+
} else if (e.type.startsWith("compaction/") && e.type !== "compaction/summary") line = `===== ${e.type} =====`;
|
|
1361
|
+
if (!line) continue;
|
|
1362
|
+
out.push(line);
|
|
1363
|
+
size += line.length;
|
|
1364
|
+
if (size > limit) {
|
|
1365
|
+
out.push(`[后续轨迹超过 ${limit} 字符,已截断]`);
|
|
1366
|
+
break;
|
|
1367
|
+
}
|
|
1368
|
+
}
|
|
1369
|
+
return {
|
|
1370
|
+
text: out.join("\n"),
|
|
1371
|
+
start
|
|
1372
|
+
};
|
|
1373
|
+
}
|
|
1374
|
+
/** 各位置分段在 source.xml 中的行区间(1 起、含端点);分段无条目时为 null。 */
|
|
1375
|
+
function segmentLines(source, bk) {
|
|
1376
|
+
const lines = source.split("\n");
|
|
1377
|
+
const bucketOf = (index) => index <= bk.head[1] ? "head" : index <= bk.mid[1] ? "mid" : "tail";
|
|
1378
|
+
const entries = [];
|
|
1379
|
+
let inCdata = false;
|
|
1380
|
+
lines.forEach((line, i) => {
|
|
1381
|
+
if (!inCdata) {
|
|
1382
|
+
const tag = /^<([a-zA-Z_-]+)[^>]*>/.exec(line);
|
|
1383
|
+
if (tag) {
|
|
1384
|
+
const idx = /\b(?:index|start)="(\d+)"/.exec(tag[0]);
|
|
1385
|
+
entries.push({
|
|
1386
|
+
line: i + 1,
|
|
1387
|
+
index: idx ? Number(idx[1]) : void 0
|
|
1388
|
+
});
|
|
1389
|
+
}
|
|
1390
|
+
}
|
|
1391
|
+
for (const m of line.matchAll(/<!\[CDATA\[|\]\]>/g)) inCdata = m[0] === "<![CDATA[";
|
|
1392
|
+
});
|
|
1393
|
+
const bucketsArr = new Array(entries.length);
|
|
1394
|
+
let carry;
|
|
1395
|
+
for (let i = entries.length - 1; i >= 0; i--) {
|
|
1396
|
+
const index = entries[i]?.index;
|
|
1397
|
+
if (index !== void 0) carry = bucketOf(index);
|
|
1398
|
+
bucketsArr[i] = carry;
|
|
1399
|
+
}
|
|
1400
|
+
carry = "head";
|
|
1401
|
+
for (let i = 0; i < entries.length; i++) {
|
|
1402
|
+
const b = bucketsArr[i];
|
|
1403
|
+
if (b === void 0) bucketsArr[i] = carry;
|
|
1404
|
+
else carry = b;
|
|
1405
|
+
}
|
|
1406
|
+
const firsts = /* @__PURE__ */ new Map();
|
|
1407
|
+
entries.forEach((e, i) => {
|
|
1408
|
+
const b = bucketsArr[i];
|
|
1409
|
+
if (b && !firsts.has(b)) firsts.set(b, e.line);
|
|
1410
|
+
});
|
|
1411
|
+
const order = [
|
|
1412
|
+
"head",
|
|
1413
|
+
"mid",
|
|
1414
|
+
"tail"
|
|
1415
|
+
];
|
|
1416
|
+
const lastLine = lines.length - (lines.at(-1) === "" ? 1 : 0);
|
|
1417
|
+
const out = {};
|
|
1418
|
+
order.forEach((p, i) => {
|
|
1419
|
+
const first = firsts.get(p);
|
|
1420
|
+
if (first === void 0) {
|
|
1421
|
+
out[p] = null;
|
|
1422
|
+
return;
|
|
1423
|
+
}
|
|
1424
|
+
let end = lastLine;
|
|
1425
|
+
for (const q of order.slice(i + 1)) {
|
|
1426
|
+
const nf = firsts.get(q);
|
|
1427
|
+
if (nf !== void 0) {
|
|
1428
|
+
end = nf - 1;
|
|
1429
|
+
break;
|
|
1430
|
+
}
|
|
1431
|
+
}
|
|
1432
|
+
out[p] = [first, end];
|
|
1433
|
+
});
|
|
1434
|
+
return out;
|
|
1435
|
+
}
|
|
1436
|
+
/** 把区间按 index 三等分为 head/mid/tail。 */
|
|
1437
|
+
function buckets(lo, hi) {
|
|
1438
|
+
const n = hi - lo + 1;
|
|
1439
|
+
const third = Math.ceil(n / 3);
|
|
1440
|
+
const h = lo + third - 1;
|
|
1441
|
+
const m = h + Math.floor((n - third) / 2);
|
|
1442
|
+
return {
|
|
1443
|
+
head: [lo, h],
|
|
1444
|
+
mid: [h + 1, m],
|
|
1445
|
+
tail: [m + 1, hi]
|
|
1446
|
+
};
|
|
1447
|
+
}
|
|
1448
|
+
/** 带种子的 Fisher-Yates 洗牌,保证盲化编号可复现。 */
|
|
1449
|
+
function shuffle(items, seed) {
|
|
1450
|
+
const out = [...items];
|
|
1451
|
+
let s = seed >>> 0;
|
|
1452
|
+
const rand = () => {
|
|
1453
|
+
s = s + 1831565813 >>> 0;
|
|
1454
|
+
let t = s;
|
|
1455
|
+
t = Math.imul(t ^ t >>> 15, t | 1);
|
|
1456
|
+
t ^= t + Math.imul(t ^ t >>> 7, t | 61);
|
|
1457
|
+
return ((t ^ t >>> 14) >>> 0) / 4294967296;
|
|
1458
|
+
};
|
|
1459
|
+
for (let i = out.length - 1; i > 0; i--) {
|
|
1460
|
+
const j = Math.floor(rand() * (i + 1));
|
|
1461
|
+
[out[i], out[j]] = [out[j], out[i]];
|
|
1462
|
+
}
|
|
1463
|
+
return out;
|
|
1464
|
+
}
|
|
1465
|
+
/** 按「阶段|区间」分组。 */
|
|
1466
|
+
function groupLogs(logs) {
|
|
1467
|
+
const groups = /* @__PURE__ */ new Map();
|
|
1468
|
+
for (const x of logs) {
|
|
1469
|
+
const k = `${x.phase}|${x.range?.join("..") ?? "?"}`;
|
|
1470
|
+
groups.set(k, [...groups.get(k) ?? [], x]);
|
|
1471
|
+
}
|
|
1472
|
+
return groups;
|
|
1473
|
+
}
|
|
1474
|
+
/** 候选列表文本:每组一行标题,组内每候选一行(来源、模型、等级、token、耗时、产物长度)。 */
|
|
1475
|
+
function formatCandidates(logs) {
|
|
1476
|
+
const lines = [];
|
|
1477
|
+
for (const g of groupLogs(logs).values()) {
|
|
1478
|
+
const head = g.at(0);
|
|
1479
|
+
if (!head?.range) continue;
|
|
1480
|
+
lines.push(`区间 [${head.range.join("..")}] ${head.phase}:${g.length} 个候选`);
|
|
1481
|
+
for (const x of g) {
|
|
1482
|
+
const cache = x.tokens_cache_read || x.tokens_cache_write ? `(缓存读 ${x.tokens_cache_read}/写 ${x.tokens_cache_write})` : "";
|
|
1483
|
+
lines.push(` ${x.recompress ? "重压缩" : "原始"} ${x.model}(${x.effort})in=${x.tokens_in}${cache} out=${x.tokens_out} 模型 ${x.model_sec}s 产物 ${x.product.length} 字符`);
|
|
1484
|
+
}
|
|
1485
|
+
}
|
|
1486
|
+
return lines;
|
|
1487
|
+
}
|
|
1488
|
+
/** 规范化 --phase 取值,接受中英文。 */
|
|
1489
|
+
function normPhase(v) {
|
|
1490
|
+
if (v === void 0) return void 0;
|
|
1491
|
+
if (v === "observe" || v === "观察") return "observe";
|
|
1492
|
+
if (v === "reflect" || v === "反思") return "reflect";
|
|
1493
|
+
throw new Error(`--phase 仅支持 observe/reflect:${v}`);
|
|
1494
|
+
}
|
|
1495
|
+
/**
|
|
1496
|
+
* 按 --range/--phase 选择评估组;缺省选变体最多(并列取最新)的组。
|
|
1497
|
+
* 同一区间同时存在观察与反思日志时必须指定 --phase:两者输入不同,不可同组比较。
|
|
1498
|
+
*/
|
|
1499
|
+
function selectGroup(logs, range, phaseArg) {
|
|
1500
|
+
const phase = normPhase(phaseArg);
|
|
1501
|
+
const match = [...groupLogs(logs)].filter(([k, g]) => {
|
|
1502
|
+
const [p, r] = k.split("|");
|
|
1503
|
+
return g.length > 0 && (!range || r === range) && (!phase || p === phase);
|
|
1504
|
+
});
|
|
1505
|
+
if (!match.length) throw new Error(`没有匹配的压缩日志${range ? `(区间 ${range}${phase ? `,阶段 ${phase}` : ""})` : ""}`);
|
|
1506
|
+
if (range && !phase) {
|
|
1507
|
+
const phases = new Set(match.map(([k]) => k.split("|")[0]));
|
|
1508
|
+
if (phases.size > 1) throw new Error(`区间 [${range}] 同时有 ${[...phases].join("、")} 阶段日志,请用 --phase 指定`);
|
|
1509
|
+
}
|
|
1510
|
+
const latest = (g) => Math.max(...g.map((x) => x.created));
|
|
1511
|
+
const [, group] = match.reduce((a, b) => b[1].length > a[1].length || b[1].length === a[1].length && latest(b[1]) > latest(a[1]) ? b : a);
|
|
1512
|
+
const first = group.at(0);
|
|
1513
|
+
if (!first?.range) throw new Error("选中的组缺少区间信息");
|
|
1514
|
+
const [lo, hi] = first.range;
|
|
1515
|
+
return {
|
|
1516
|
+
phase: first.phase,
|
|
1517
|
+
lo,
|
|
1518
|
+
hi,
|
|
1519
|
+
logs: group
|
|
1520
|
+
};
|
|
1521
|
+
}
|
|
1522
|
+
/** 写 UTF-8 文本文件。 */
|
|
1523
|
+
function write(dir, name, text) {
|
|
1524
|
+
writeFileSync(join(dir, name), text, "utf8");
|
|
1525
|
+
}
|
|
1526
|
+
/** 命令行入口。 */
|
|
1527
|
+
function main() {
|
|
1528
|
+
const { values } = parseArgs({ options: {
|
|
1529
|
+
session: { type: "string" },
|
|
1530
|
+
zip: { type: "string" },
|
|
1531
|
+
variants: {
|
|
1532
|
+
type: "string",
|
|
1533
|
+
multiple: true
|
|
1534
|
+
},
|
|
1535
|
+
range: { type: "string" },
|
|
1536
|
+
phase: { type: "string" },
|
|
1537
|
+
out: { type: "string" },
|
|
1538
|
+
seed: {
|
|
1539
|
+
type: "string",
|
|
1540
|
+
default: "20261015"
|
|
1541
|
+
},
|
|
1542
|
+
"after-max": {
|
|
1543
|
+
type: "string",
|
|
1544
|
+
default: "60000"
|
|
1545
|
+
},
|
|
1546
|
+
list: { type: "boolean" }
|
|
1547
|
+
} });
|
|
1548
|
+
const bundle = loadBundle(values);
|
|
1549
|
+
const mainEv = bundle.main;
|
|
1550
|
+
const mainHead = mainEv[0];
|
|
1551
|
+
if (!mainHead?.id) throw new Error("主会话缺少会话头");
|
|
1552
|
+
const mainId = bareId(mainHead.id);
|
|
1553
|
+
const logs = [...bundle.logs, ...(values.variants ?? []).flatMap(loadVariants)].map(parseLog).filter((x) => !x.failed && bareId(x.parent ?? "") === mainId && x.range);
|
|
1554
|
+
if (!logs.length) throw new Error("该会话没有可用的压缩日志");
|
|
1555
|
+
for (const line of formatCandidates(logs)) console.log(line);
|
|
1556
|
+
if (values.list) return;
|
|
1557
|
+
const sel = selectGroup(logs, values.range, values.phase);
|
|
1558
|
+
const { lo, hi, logs: group } = sel;
|
|
1559
|
+
for (const x of group) if (!x.product) throw new Error(`变体 ${x.id} 缺少 completeCompression 产物`);
|
|
1560
|
+
const out = values.out ? resolve(values.out) : evalPath(mainId, sel.phase, lo, hi);
|
|
1561
|
+
prepareEvalDir(out);
|
|
1562
|
+
const source = pickSource(group, lo, hi);
|
|
1563
|
+
write(out, "source.xml", source);
|
|
1564
|
+
const key = {};
|
|
1565
|
+
shuffle(group, Number(values.seed)).forEach((x, i) => {
|
|
1566
|
+
const v = `V${i + 1}`;
|
|
1567
|
+
write(out, `${v}.xml`, blindProduct(x.product));
|
|
1568
|
+
const { id, model, effort, recompress, wall_sec, model_sec, requests, tokens_in, tokens_cache_read, tokens_cache_write, tokens_out } = x;
|
|
1569
|
+
key[v] = {
|
|
1570
|
+
id,
|
|
1571
|
+
model,
|
|
1572
|
+
effort,
|
|
1573
|
+
recompress,
|
|
1574
|
+
wall_sec,
|
|
1575
|
+
model_sec,
|
|
1576
|
+
requests,
|
|
1577
|
+
tokens_in,
|
|
1578
|
+
tokens_cache_read,
|
|
1579
|
+
tokens_cache_write,
|
|
1580
|
+
tokens_out
|
|
1581
|
+
};
|
|
1582
|
+
});
|
|
1583
|
+
write(out, "_blind_key.json", JSON.stringify(key, null, 1));
|
|
1584
|
+
const after = buildAfter(mainEv, hi, Number(values["after-max"]));
|
|
1585
|
+
write(out, "after.md", after.text);
|
|
1586
|
+
const bk = buckets(lo, hi);
|
|
1587
|
+
const seg = segmentLines(source, bk);
|
|
1588
|
+
const lineRange = (r) => r ? `${r[0]}–${r[1]}` : "-";
|
|
1589
|
+
const task = /<user_message[^>]*><!\[CDATA\[([\s\S]*?)\]\]>/.exec(source)?.[1]?.trim().slice(0, 500);
|
|
1590
|
+
const tplPath = join(import.meta.dirname, "..", "references", "rules.md");
|
|
1591
|
+
if (!existsSync(tplPath)) throw new Error(`缺少规则模板:${tplPath}`);
|
|
1592
|
+
const fill = {
|
|
1593
|
+
lo: String(lo),
|
|
1594
|
+
hi: String(hi),
|
|
1595
|
+
phase: sel.phase === "reflect" ? "反思" : sel.phase === "observe" ? "观察" : "压缩",
|
|
1596
|
+
task: task ?? "(见 source.xml)",
|
|
1597
|
+
head: bk.head.join("–"),
|
|
1598
|
+
mid: bk.mid.join("–"),
|
|
1599
|
+
tail: bk.tail.join("–"),
|
|
1600
|
+
head_lines: lineRange(seg.head),
|
|
1601
|
+
mid_lines: lineRange(seg.mid),
|
|
1602
|
+
tail_lines: lineRange(seg.tail)
|
|
1603
|
+
};
|
|
1604
|
+
write(out, "rules.md", readFileSync(tplPath, "utf8").replace(/\{(\w+)\}/g, (m, k) => fill[k] ?? m));
|
|
1605
|
+
const meta = {
|
|
1606
|
+
session: mainId,
|
|
1607
|
+
phase: sel.phase,
|
|
1608
|
+
range: [lo, hi],
|
|
1609
|
+
buckets: bk,
|
|
1610
|
+
segment_lines: seg,
|
|
1611
|
+
variants: Object.keys(key),
|
|
1612
|
+
after_start_seq: after.start
|
|
1613
|
+
};
|
|
1614
|
+
write(out, "meta.json", JSON.stringify(meta, null, 1));
|
|
1615
|
+
console.log(`输出目录:${out}`);
|
|
1616
|
+
console.log(`变体 ${group.length} 个,原文 ${source.length} 字符,后续轨迹 ${after.text.length} 字符,分段 ${JSON.stringify(bk)}`);
|
|
1617
|
+
}
|
|
1618
|
+
if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main();
|
|
1619
|
+
//#endregion
|
|
1620
|
+
export { blindProduct, buckets, buildAfter, formatCandidates, groupLogs, parseLog, pickSource, prepareEvalDir, segmentLines, selectGroup, shuffle };
|