opencode-tokscope 0.0.0-stage → 0.2.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/LICENSE +21 -0
- package/README.md +61 -2
- package/dist/tui.js +2867 -0
- package/package.json +51 -4
- package/tui.js +1 -0
package/dist/tui.js
ADDED
|
@@ -0,0 +1,2867 @@
|
|
|
1
|
+
// src/tui.tsx
|
|
2
|
+
import {createComponent as _$createComponent5} from "@opentui/solid";
|
|
3
|
+
import {Plugin} from "@opencode/plugin/tui";
|
|
4
|
+
import {createSignal as createSignal4} from "solid-js";
|
|
5
|
+
|
|
6
|
+
// src/history/records.ts
|
|
7
|
+
var fieldsOf = function(value) {
|
|
8
|
+
if (typeof value !== "object" || value === null || Array.isArray(value))
|
|
9
|
+
return;
|
|
10
|
+
return value;
|
|
11
|
+
};
|
|
12
|
+
var stringValue = function(value) {
|
|
13
|
+
return typeof value === "string" ? value : undefined;
|
|
14
|
+
};
|
|
15
|
+
var nonEmptyString = function(value) {
|
|
16
|
+
return typeof value === "string" && value.length > 0 ? value : undefined;
|
|
17
|
+
};
|
|
18
|
+
var sessionIDFrom = function(value) {
|
|
19
|
+
return typeof value === "string" && SESSION_ID_PATTERN.test(value) ? value : undefined;
|
|
20
|
+
};
|
|
21
|
+
var finiteNumber = function(value) {
|
|
22
|
+
return typeof value === "number" && Number.isFinite(value) ? value : undefined;
|
|
23
|
+
};
|
|
24
|
+
var nonNegativeNumber = function(value) {
|
|
25
|
+
const parsed = finiteNumber(value);
|
|
26
|
+
return parsed !== undefined && parsed >= 0 ? parsed : undefined;
|
|
27
|
+
};
|
|
28
|
+
var optionalField = function(value, parse) {
|
|
29
|
+
if (value === undefined)
|
|
30
|
+
return { ok: true, value: undefined };
|
|
31
|
+
const parsed = parse(value);
|
|
32
|
+
return parsed === undefined ? { ok: false } : { ok: true, value: parsed };
|
|
33
|
+
};
|
|
34
|
+
var parseRows = function(raw, parse) {
|
|
35
|
+
if (!Array.isArray(raw))
|
|
36
|
+
return;
|
|
37
|
+
const rows = [];
|
|
38
|
+
for (const entry of raw) {
|
|
39
|
+
const row = parse(entry);
|
|
40
|
+
if (row === undefined)
|
|
41
|
+
return;
|
|
42
|
+
rows.push(row);
|
|
43
|
+
}
|
|
44
|
+
return rows;
|
|
45
|
+
};
|
|
46
|
+
var parseSample = function(raw) {
|
|
47
|
+
const source = fieldsOf(raw);
|
|
48
|
+
if (source === undefined)
|
|
49
|
+
return;
|
|
50
|
+
const providerID = nonEmptyString(source.providerID);
|
|
51
|
+
const modelID = nonEmptyString(source.modelID);
|
|
52
|
+
const variant = optionalField(source.variant, stringValue);
|
|
53
|
+
const completedAt = finiteNumber(source.completedAt);
|
|
54
|
+
const rate = nonNegativeNumber(source.rate);
|
|
55
|
+
if (providerID === undefined || modelID === undefined || !variant.ok || completedAt === undefined || rate === undefined) {
|
|
56
|
+
return;
|
|
57
|
+
}
|
|
58
|
+
return { providerID, modelID, variant: variant.value, completedAt, rate };
|
|
59
|
+
};
|
|
60
|
+
var parseUnavailableSample = function(raw) {
|
|
61
|
+
const source = fieldsOf(raw);
|
|
62
|
+
if (source === undefined)
|
|
63
|
+
return;
|
|
64
|
+
const providerID = nonEmptyString(source.providerID);
|
|
65
|
+
const modelID = nonEmptyString(source.modelID);
|
|
66
|
+
const variant = optionalField(source.variant, stringValue);
|
|
67
|
+
const completedAt = finiteNumber(source.completedAt);
|
|
68
|
+
if (providerID === undefined || modelID === undefined || !variant.ok || completedAt === undefined) {
|
|
69
|
+
return;
|
|
70
|
+
}
|
|
71
|
+
return { providerID, modelID, variant: variant.value, completedAt };
|
|
72
|
+
};
|
|
73
|
+
var parseSessionRecord = function(raw) {
|
|
74
|
+
const source = fieldsOf(raw);
|
|
75
|
+
if (source === undefined)
|
|
76
|
+
return;
|
|
77
|
+
const sessionID = sessionIDFrom(source.sessionID);
|
|
78
|
+
const directory = optionalField(source.directory, stringValue);
|
|
79
|
+
const createdAt = finiteNumber(source.createdAt);
|
|
80
|
+
const updatedAt = finiteNumber(source.updatedAt);
|
|
81
|
+
const scannedAtMs = finiteNumber(source.scannedAtMs);
|
|
82
|
+
const signature = stringValue(source.signature);
|
|
83
|
+
const fork = source.fork;
|
|
84
|
+
const complete = source.complete;
|
|
85
|
+
if (sessionID === undefined || !directory.ok || createdAt === undefined || updatedAt === undefined || scannedAtMs === undefined || signature === undefined || typeof fork !== "boolean" || typeof complete !== "boolean") {
|
|
86
|
+
return;
|
|
87
|
+
}
|
|
88
|
+
const samples = parseRows(source.samples, parseSample);
|
|
89
|
+
const unavailable = parseRows(source.unavailable, parseUnavailableSample);
|
|
90
|
+
if (samples === undefined || unavailable === undefined)
|
|
91
|
+
return;
|
|
92
|
+
return {
|
|
93
|
+
sessionID,
|
|
94
|
+
directory: directory.value,
|
|
95
|
+
createdAt,
|
|
96
|
+
updatedAt,
|
|
97
|
+
fork,
|
|
98
|
+
signature,
|
|
99
|
+
scannedAtMs,
|
|
100
|
+
complete,
|
|
101
|
+
samples,
|
|
102
|
+
unavailable
|
|
103
|
+
};
|
|
104
|
+
};
|
|
105
|
+
var parseIndexEntry = function(raw) {
|
|
106
|
+
const source = fieldsOf(raw);
|
|
107
|
+
if (source === undefined)
|
|
108
|
+
return;
|
|
109
|
+
const sessionID = sessionIDFrom(source.sessionID);
|
|
110
|
+
const directory = optionalField(source.directory, stringValue);
|
|
111
|
+
const updatedAt = finiteNumber(source.updatedAt);
|
|
112
|
+
if (sessionID === undefined || !directory.ok || updatedAt === undefined)
|
|
113
|
+
return;
|
|
114
|
+
return { sessionID, directory: directory.value, updatedAt };
|
|
115
|
+
};
|
|
116
|
+
var parseComparisonRow = function(raw) {
|
|
117
|
+
const source = fieldsOf(raw);
|
|
118
|
+
if (source === undefined)
|
|
119
|
+
return;
|
|
120
|
+
const key = nonEmptyString(source.key);
|
|
121
|
+
const providerID = nonEmptyString(source.providerID);
|
|
122
|
+
const modelID = nonEmptyString(source.modelID);
|
|
123
|
+
const calls = nonNegativeNumber(source.calls);
|
|
124
|
+
const unavailable = source.unavailable;
|
|
125
|
+
if (key === undefined || providerID === undefined || modelID === undefined || calls === undefined || typeof unavailable !== "boolean") {
|
|
126
|
+
return;
|
|
127
|
+
}
|
|
128
|
+
let median;
|
|
129
|
+
if (source.median === null)
|
|
130
|
+
median = null;
|
|
131
|
+
else {
|
|
132
|
+
const parsed = finiteNumber(source.median);
|
|
133
|
+
if (parsed === undefined)
|
|
134
|
+
return;
|
|
135
|
+
median = parsed;
|
|
136
|
+
}
|
|
137
|
+
return { key, providerID, modelID, median, calls, unavailable };
|
|
138
|
+
};
|
|
139
|
+
var parseWidgetRow = function(raw) {
|
|
140
|
+
const source = fieldsOf(raw);
|
|
141
|
+
if (source === undefined)
|
|
142
|
+
return;
|
|
143
|
+
const key = nonEmptyString(source.key);
|
|
144
|
+
const providerID = nonEmptyString(source.providerID);
|
|
145
|
+
const modelID = nonEmptyString(source.modelID);
|
|
146
|
+
const median = nonNegativeNumber(source.median);
|
|
147
|
+
const calls = nonNegativeNumber(source.calls);
|
|
148
|
+
if (key === undefined || providerID === undefined || modelID === undefined || median === undefined || calls === undefined) {
|
|
149
|
+
return;
|
|
150
|
+
}
|
|
151
|
+
return { key, providerID, modelID, median, calls };
|
|
152
|
+
};
|
|
153
|
+
function signatureFor(meta) {
|
|
154
|
+
return JSON.stringify([
|
|
155
|
+
meta.id,
|
|
156
|
+
meta.time.created,
|
|
157
|
+
meta.time.updated,
|
|
158
|
+
meta.location?.directory,
|
|
159
|
+
meta.cost,
|
|
160
|
+
meta.tokens,
|
|
161
|
+
meta.fork?.sessionID,
|
|
162
|
+
meta.fork?.boundary
|
|
163
|
+
]);
|
|
164
|
+
}
|
|
165
|
+
function emptyShard() {
|
|
166
|
+
return {
|
|
167
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
168
|
+
metricVersion: METRIC_VERSION,
|
|
169
|
+
records: {},
|
|
170
|
+
index: {}
|
|
171
|
+
};
|
|
172
|
+
}
|
|
173
|
+
function parseShard(raw) {
|
|
174
|
+
const source = fieldsOf(raw);
|
|
175
|
+
if (source === undefined)
|
|
176
|
+
return;
|
|
177
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
178
|
+
return;
|
|
179
|
+
if (source.metricVersion !== METRIC_VERSION)
|
|
180
|
+
return;
|
|
181
|
+
const recordsSource = fieldsOf(source.records);
|
|
182
|
+
const indexSource = fieldsOf(source.index);
|
|
183
|
+
if (recordsSource === undefined || indexSource === undefined)
|
|
184
|
+
return;
|
|
185
|
+
const records = {};
|
|
186
|
+
for (const [key, value] of Object.entries(recordsSource)) {
|
|
187
|
+
const record = parseSessionRecord(value);
|
|
188
|
+
if (record === undefined || record.sessionID !== key)
|
|
189
|
+
continue;
|
|
190
|
+
records[key] = record;
|
|
191
|
+
}
|
|
192
|
+
const index = {};
|
|
193
|
+
for (const [key, value] of Object.entries(indexSource)) {
|
|
194
|
+
const entry = parseIndexEntry(value);
|
|
195
|
+
if (entry === undefined || entry.sessionID !== key)
|
|
196
|
+
continue;
|
|
197
|
+
index[key] = entry;
|
|
198
|
+
}
|
|
199
|
+
return { schemaVersion: CACHE_SCHEMA_VERSION, metricVersion: METRIC_VERSION, records, index };
|
|
200
|
+
}
|
|
201
|
+
function parseCoverage(raw) {
|
|
202
|
+
const source = fieldsOf(raw);
|
|
203
|
+
if (source === undefined)
|
|
204
|
+
return;
|
|
205
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
206
|
+
return;
|
|
207
|
+
const directoryFilter = optionalField(source.directoryFilter, stringValue);
|
|
208
|
+
const fullInventoryCompletedAt = optionalField(source.fullInventoryCompletedAt, finiteNumber);
|
|
209
|
+
const recentCatchUpAt = optionalField(source.recentCatchUpAt, finiteNumber);
|
|
210
|
+
if (!directoryFilter.ok || !fullInventoryCompletedAt.ok || !recentCatchUpAt.ok)
|
|
211
|
+
return;
|
|
212
|
+
return {
|
|
213
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
214
|
+
directoryFilter: directoryFilter.value,
|
|
215
|
+
fullInventoryCompletedAt: fullInventoryCompletedAt.value,
|
|
216
|
+
recentCatchUpAt: recentCatchUpAt.value
|
|
217
|
+
};
|
|
218
|
+
}
|
|
219
|
+
function parseViewSnapshot(raw) {
|
|
220
|
+
const source = fieldsOf(raw);
|
|
221
|
+
if (source === undefined)
|
|
222
|
+
return;
|
|
223
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
224
|
+
return;
|
|
225
|
+
if (source.metricVersion !== METRIC_VERSION)
|
|
226
|
+
return;
|
|
227
|
+
if (!RANGE_FILTERS.includes(source.range))
|
|
228
|
+
return;
|
|
229
|
+
const directoryFilter = optionalField(source.directoryFilter, stringValue);
|
|
230
|
+
const lastCheckedAt = optionalField(source.lastCheckedAt, finiteNumber);
|
|
231
|
+
const savedAtMs = finiteNumber(source.savedAtMs);
|
|
232
|
+
const rows = parseRows(source.rows, parseComparisonRow);
|
|
233
|
+
if (!directoryFilter.ok || !lastCheckedAt.ok || savedAtMs === undefined || rows === undefined)
|
|
234
|
+
return;
|
|
235
|
+
return {
|
|
236
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
237
|
+
metricVersion: METRIC_VERSION,
|
|
238
|
+
directoryFilter: directoryFilter.value,
|
|
239
|
+
range: source.range,
|
|
240
|
+
rows,
|
|
241
|
+
lastCheckedAt: lastCheckedAt.value,
|
|
242
|
+
savedAtMs
|
|
243
|
+
};
|
|
244
|
+
}
|
|
245
|
+
function parseWidgetSnapshot(raw) {
|
|
246
|
+
const source = fieldsOf(raw);
|
|
247
|
+
if (source === undefined)
|
|
248
|
+
return;
|
|
249
|
+
if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
|
|
250
|
+
return;
|
|
251
|
+
if (source.metricVersion !== METRIC_VERSION)
|
|
252
|
+
return;
|
|
253
|
+
const rows = parseRows(source.rows, parseWidgetRow);
|
|
254
|
+
const savedAtMs = finiteNumber(source.savedAtMs);
|
|
255
|
+
if (rows === undefined || savedAtMs === undefined)
|
|
256
|
+
return;
|
|
257
|
+
return { schemaVersion: CACHE_SCHEMA_VERSION, metricVersion: METRIC_VERSION, rows, savedAtMs };
|
|
258
|
+
}
|
|
259
|
+
function parseTombstones(raw) {
|
|
260
|
+
const source = fieldsOf(raw);
|
|
261
|
+
if (source === undefined)
|
|
262
|
+
return;
|
|
263
|
+
if (!Array.isArray(source.sessionIDs))
|
|
264
|
+
return;
|
|
265
|
+
const sessionIDs = [];
|
|
266
|
+
for (const entry of source.sessionIDs) {
|
|
267
|
+
const sessionID = sessionIDFrom(entry);
|
|
268
|
+
if (sessionID !== undefined)
|
|
269
|
+
sessionIDs.push(sessionID);
|
|
270
|
+
}
|
|
271
|
+
return { sessionIDs };
|
|
272
|
+
}
|
|
273
|
+
function recordFrom(meta, scan, nowMs) {
|
|
274
|
+
return {
|
|
275
|
+
sessionID: meta.id,
|
|
276
|
+
directory: meta.location?.directory,
|
|
277
|
+
createdAt: meta.time.created,
|
|
278
|
+
updatedAt: meta.time.updated,
|
|
279
|
+
fork: meta.fork !== undefined,
|
|
280
|
+
signature: signatureFor(meta),
|
|
281
|
+
scannedAtMs: nowMs,
|
|
282
|
+
complete: true,
|
|
283
|
+
samples: scan.samples,
|
|
284
|
+
unavailable: scan.unavailable
|
|
285
|
+
};
|
|
286
|
+
}
|
|
287
|
+
var CACHE_SCHEMA_VERSION = 1;
|
|
288
|
+
var METRIC_VERSION = 1;
|
|
289
|
+
var SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
|
|
290
|
+
var RANGE_FILTERS = ["last7", "last30", "last90", "all"];
|
|
291
|
+
|
|
292
|
+
// src/history/durable.ts
|
|
293
|
+
function fnv1a(value) {
|
|
294
|
+
let hash = 2166136261;
|
|
295
|
+
for (let index = 0;index < value.length; index++) {
|
|
296
|
+
hash = Math.imul(hash ^ value.charCodeAt(index), 16777619) >>> 0;
|
|
297
|
+
}
|
|
298
|
+
return hash;
|
|
299
|
+
}
|
|
300
|
+
var shardIndex = function(sessionID) {
|
|
301
|
+
return fnv1a(sessionID) % SHARD_COUNT;
|
|
302
|
+
};
|
|
303
|
+
var shardName = function(index) {
|
|
304
|
+
return `shard:${index}`;
|
|
305
|
+
};
|
|
306
|
+
var shardStorageKey = function(index) {
|
|
307
|
+
return `${SHARD_PREFIX}${index}`;
|
|
308
|
+
};
|
|
309
|
+
var coverageKey = function(directoryFilter) {
|
|
310
|
+
if (directoryFilter === undefined)
|
|
311
|
+
return COVERAGE_ALL_KEY;
|
|
312
|
+
return `${COVERAGE_PREFIX}d${fnv1a(directoryFilter).toString(16).padStart(8, "0")}`;
|
|
313
|
+
};
|
|
314
|
+
var isCoverageKey = function(key) {
|
|
315
|
+
return key === COVERAGE_ALL_KEY || key.startsWith(`${COVERAGE_PREFIX}d`);
|
|
316
|
+
};
|
|
317
|
+
var viewSnapshotKey = function(slot) {
|
|
318
|
+
return `${VIEW_SNAPSHOT_PREFIX}${slot}`;
|
|
319
|
+
};
|
|
320
|
+
var snapshotSlot = function(key) {
|
|
321
|
+
if (!key.startsWith(VIEW_SNAPSHOT_PREFIX))
|
|
322
|
+
return;
|
|
323
|
+
const suffix = key.slice(VIEW_SNAPSHOT_PREFIX.length);
|
|
324
|
+
if (!/^(?:0|[1-9][0-9]*)$/.test(suffix))
|
|
325
|
+
return;
|
|
326
|
+
const slot = Number(suffix);
|
|
327
|
+
return slot < VIEW_SNAPSHOT_LIMIT ? slot : undefined;
|
|
328
|
+
};
|
|
329
|
+
var isSnapshotIndexKey = function(key) {
|
|
330
|
+
return snapshotSlot(key) !== undefined;
|
|
331
|
+
};
|
|
332
|
+
var sameView = function(a, b) {
|
|
333
|
+
return a.directoryFilter === b.directoryFilter && a.range === b.range;
|
|
334
|
+
};
|
|
335
|
+
var replaceDraft = function(draft, value) {
|
|
336
|
+
for (const key of Object.keys(draft))
|
|
337
|
+
delete draft[key];
|
|
338
|
+
Object.assign(draft, value);
|
|
339
|
+
};
|
|
340
|
+
var parseKeyIndex = function(payload, accept) {
|
|
341
|
+
const keys = payload === undefined ? undefined : payload.keys;
|
|
342
|
+
if (!Array.isArray(keys))
|
|
343
|
+
return [];
|
|
344
|
+
const result = [];
|
|
345
|
+
for (const entry of keys) {
|
|
346
|
+
if (typeof entry !== "string" || !accept(entry) || result.includes(entry))
|
|
347
|
+
continue;
|
|
348
|
+
result.push(entry);
|
|
349
|
+
}
|
|
350
|
+
return result;
|
|
351
|
+
};
|
|
352
|
+
var readKeyIndex = function(store, key, accept) {
|
|
353
|
+
return parseKeyIndex(store.read(key), accept);
|
|
354
|
+
};
|
|
355
|
+
var mergeTombstones = function(existing, added) {
|
|
356
|
+
const incoming = new Set(added);
|
|
357
|
+
const merged = existing.filter((sessionID) => !incoming.has(sessionID));
|
|
358
|
+
const seen = new Set;
|
|
359
|
+
for (const sessionID of added) {
|
|
360
|
+
if (seen.has(sessionID))
|
|
361
|
+
continue;
|
|
362
|
+
seen.add(sessionID);
|
|
363
|
+
merged.push(sessionID);
|
|
364
|
+
}
|
|
365
|
+
return merged.slice(-TOMBSTONE_LIMIT);
|
|
366
|
+
};
|
|
367
|
+
function createRepository(store) {
|
|
368
|
+
const readTombstones = () => parseTombstones(store.read(TOMBSTONES_KEY)) ?? { sessionIDs: [] };
|
|
369
|
+
const readSnapshotIndex = () => readKeyIndex(store, SNAPSHOTS_INDEX_KEY, isSnapshotIndexKey);
|
|
370
|
+
const liveSnapshots = (keys) => {
|
|
371
|
+
const live = [];
|
|
372
|
+
for (const key of keys) {
|
|
373
|
+
const slot = snapshotSlot(key);
|
|
374
|
+
if (slot === undefined)
|
|
375
|
+
continue;
|
|
376
|
+
const parsed = parseViewSnapshot(store.read(key));
|
|
377
|
+
if (parsed !== undefined)
|
|
378
|
+
live.push({ key, slot, snapshot: parsed });
|
|
379
|
+
}
|
|
380
|
+
return live;
|
|
381
|
+
};
|
|
382
|
+
return {
|
|
383
|
+
loadAllShards() {
|
|
384
|
+
const shards = new Map;
|
|
385
|
+
for (let index = 0;index < SHARD_COUNT; index++) {
|
|
386
|
+
const shard = parseShard(store.read(shardStorageKey(index)));
|
|
387
|
+
if (shard !== undefined)
|
|
388
|
+
shards.set(shardName(index), shard);
|
|
389
|
+
}
|
|
390
|
+
return shards;
|
|
391
|
+
},
|
|
392
|
+
async putRecords(records2, nowMs) {
|
|
393
|
+
const grouped = new Map;
|
|
394
|
+
for (const record of records2) {
|
|
395
|
+
const index = shardIndex(record.sessionID);
|
|
396
|
+
const group = grouped.get(index);
|
|
397
|
+
if (group === undefined)
|
|
398
|
+
grouped.set(index, [record]);
|
|
399
|
+
else
|
|
400
|
+
group.push(record);
|
|
401
|
+
}
|
|
402
|
+
for (const [index, group] of [...grouped].sort((a, b) => a[0] - b[0])) {
|
|
403
|
+
await store.write(shardStorageKey(index), (draft) => {
|
|
404
|
+
const shard = parseShard(draft) ?? emptyShard();
|
|
405
|
+
for (const record of group) {
|
|
406
|
+
shard.records[record.sessionID] = record;
|
|
407
|
+
shard.index[record.sessionID] = {
|
|
408
|
+
sessionID: record.sessionID,
|
|
409
|
+
directory: record.directory,
|
|
410
|
+
updatedAt: record.updatedAt
|
|
411
|
+
};
|
|
412
|
+
}
|
|
413
|
+
replaceDraft(draft, shard);
|
|
414
|
+
});
|
|
415
|
+
}
|
|
416
|
+
},
|
|
417
|
+
async removeSessions(sessionIDs, nowMs) {
|
|
418
|
+
if (sessionIDs.length === 0)
|
|
419
|
+
return;
|
|
420
|
+
await store.write(TOMBSTONES_KEY, (draft) => replaceDraft(draft, { sessionIDs: mergeTombstones(readTombstones().sessionIDs, sessionIDs) }));
|
|
421
|
+
const grouped = new Map;
|
|
422
|
+
for (const sessionID of sessionIDs) {
|
|
423
|
+
const index = shardIndex(sessionID);
|
|
424
|
+
const group = grouped.get(index);
|
|
425
|
+
if (group === undefined)
|
|
426
|
+
grouped.set(index, [sessionID]);
|
|
427
|
+
else
|
|
428
|
+
group.push(sessionID);
|
|
429
|
+
}
|
|
430
|
+
for (const [index, group] of [...grouped].sort((a, b) => a[0] - b[0])) {
|
|
431
|
+
const key = shardStorageKey(index);
|
|
432
|
+
if (store.read(key) === undefined)
|
|
433
|
+
continue;
|
|
434
|
+
await store.write(key, (draft) => {
|
|
435
|
+
const shard = parseShard(draft) ?? emptyShard();
|
|
436
|
+
for (const sessionID of group) {
|
|
437
|
+
delete shard.records[sessionID];
|
|
438
|
+
delete shard.index[sessionID];
|
|
439
|
+
}
|
|
440
|
+
replaceDraft(draft, shard);
|
|
441
|
+
});
|
|
442
|
+
}
|
|
443
|
+
},
|
|
444
|
+
loadTombstones() {
|
|
445
|
+
return readTombstones();
|
|
446
|
+
},
|
|
447
|
+
async clearTombstones(nowMs) {
|
|
448
|
+
await store.write(TOMBSTONES_KEY, (draft) => replaceDraft(draft, { sessionIDs: [] }));
|
|
449
|
+
},
|
|
450
|
+
readCoverage(directoryFilter) {
|
|
451
|
+
const record = parseCoverage(store.read(coverageKey(directoryFilter)));
|
|
452
|
+
if (record === undefined)
|
|
453
|
+
return;
|
|
454
|
+
return record.directoryFilter === directoryFilter ? record : undefined;
|
|
455
|
+
},
|
|
456
|
+
async writeCoverage(record) {
|
|
457
|
+
const key = coverageKey(record.directoryFilter);
|
|
458
|
+
await store.write(COVERAGE_INDEX_KEY, (draft) => {
|
|
459
|
+
const indexed = parseKeyIndex(draft, isCoverageKey);
|
|
460
|
+
replaceDraft(draft, { keys: indexed.includes(key) ? indexed : [...indexed, key] });
|
|
461
|
+
});
|
|
462
|
+
await store.write(key, (draft) => replaceDraft(draft, record));
|
|
463
|
+
},
|
|
464
|
+
readViewSnapshot(directoryFilter, range) {
|
|
465
|
+
const index = readSnapshotIndex();
|
|
466
|
+
for (let position = index.length - 1;position >= 0; position--) {
|
|
467
|
+
const snapshot = parseViewSnapshot(store.read(index[position]));
|
|
468
|
+
if (snapshot === undefined)
|
|
469
|
+
continue;
|
|
470
|
+
if (snapshot.directoryFilter === directoryFilter && snapshot.range === range)
|
|
471
|
+
return snapshot;
|
|
472
|
+
}
|
|
473
|
+
return;
|
|
474
|
+
},
|
|
475
|
+
async writeViewSnapshot(snapshot) {
|
|
476
|
+
const live = liveSnapshots(readSnapshotIndex());
|
|
477
|
+
const updated = live.filter((entry) => sameView(entry.snapshot, snapshot)).at(-1);
|
|
478
|
+
const kept = live.filter((entry) => !sameView(entry.snapshot, snapshot));
|
|
479
|
+
let slot;
|
|
480
|
+
if (updated !== undefined) {
|
|
481
|
+
slot = updated.slot;
|
|
482
|
+
} else {
|
|
483
|
+
const used = new Set(kept.map((entry) => entry.slot));
|
|
484
|
+
const free = Array.from({ length: VIEW_SNAPSHOT_LIMIT }, (_, candidate) => candidate).find((candidate) => !used.has(candidate));
|
|
485
|
+
if (free !== undefined) {
|
|
486
|
+
slot = free;
|
|
487
|
+
} else {
|
|
488
|
+
slot = kept[0].slot;
|
|
489
|
+
kept.shift();
|
|
490
|
+
}
|
|
491
|
+
}
|
|
492
|
+
const key = viewSnapshotKey(slot);
|
|
493
|
+
await store.write(key, (draft) => replaceDraft(draft, snapshot));
|
|
494
|
+
await store.write(SNAPSHOTS_INDEX_KEY, (draft) => {
|
|
495
|
+
const current = liveSnapshots(parseKeyIndex(draft, isSnapshotIndexKey)).filter((entry) => entry.key !== key && !sameView(entry.snapshot, snapshot)).map((entry) => entry.key);
|
|
496
|
+
replaceDraft(draft, { keys: [...current, key].slice(-VIEW_SNAPSHOT_LIMIT) });
|
|
497
|
+
});
|
|
498
|
+
},
|
|
499
|
+
readWidgetSnapshot() {
|
|
500
|
+
return parseWidgetSnapshot(store.read(WIDGET_SNAPSHOT_KEY));
|
|
501
|
+
},
|
|
502
|
+
async writeWidgetSnapshot(rows, nowMs) {
|
|
503
|
+
const snapshot = {
|
|
504
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
505
|
+
metricVersion: METRIC_VERSION,
|
|
506
|
+
rows,
|
|
507
|
+
savedAtMs: nowMs
|
|
508
|
+
};
|
|
509
|
+
await store.write(WIDGET_SNAPSHOT_KEY, (draft) => replaceDraft(draft, snapshot));
|
|
510
|
+
},
|
|
511
|
+
async clear() {
|
|
512
|
+
const keys = [
|
|
513
|
+
...Array.from({ length: SHARD_COUNT }, (_, index) => shardStorageKey(index)),
|
|
514
|
+
TOMBSTONES_KEY,
|
|
515
|
+
COVERAGE_INDEX_KEY,
|
|
516
|
+
...readKeyIndex(store, COVERAGE_INDEX_KEY, isCoverageKey),
|
|
517
|
+
SNAPSHOTS_INDEX_KEY,
|
|
518
|
+
...Array.from({ length: VIEW_SNAPSHOT_LIMIT }, (_, slot) => viewSnapshotKey(slot)),
|
|
519
|
+
WIDGET_SNAPSHOT_KEY
|
|
520
|
+
];
|
|
521
|
+
for (const key of keys) {
|
|
522
|
+
if (store.read(key) === undefined)
|
|
523
|
+
continue;
|
|
524
|
+
await store.write(key, (draft) => replaceDraft(draft, {}));
|
|
525
|
+
}
|
|
526
|
+
}
|
|
527
|
+
};
|
|
528
|
+
}
|
|
529
|
+
var SHARD_COUNT = 64;
|
|
530
|
+
var TOMBSTONE_LIMIT = 1000;
|
|
531
|
+
var VIEW_SNAPSHOT_LIMIT = 8;
|
|
532
|
+
var SHARD_PREFIX = "tks.shard.";
|
|
533
|
+
var COVERAGE_PREFIX = "tks.coverage.";
|
|
534
|
+
var COVERAGE_ALL_KEY = "tks.coverage.all";
|
|
535
|
+
var COVERAGE_INDEX_KEY = "tks.coverage-index";
|
|
536
|
+
var TOMBSTONES_KEY = "tks.tombstones";
|
|
537
|
+
var SNAPSHOTS_INDEX_KEY = "tks.snapshots";
|
|
538
|
+
var VIEW_SNAPSHOT_PREFIX = "tks.snapshot.view.";
|
|
539
|
+
var WIDGET_SNAPSHOT_KEY = "tks.snapshot.widget24h";
|
|
540
|
+
|
|
541
|
+
// src/history/plugin-storage.ts
|
|
542
|
+
import {unwrap} from "solid-js/store";
|
|
543
|
+
function createPluginDurableStore(storage) {
|
|
544
|
+
const entries = new Map;
|
|
545
|
+
const entryOf = (key) => {
|
|
546
|
+
const existing = entries.get(key);
|
|
547
|
+
if (existing !== undefined)
|
|
548
|
+
return existing;
|
|
549
|
+
const [store2, update] = storage.store(`${KEY_PREFIX}${key}`, {
|
|
550
|
+
initial: {}
|
|
551
|
+
});
|
|
552
|
+
const entry = {
|
|
553
|
+
read: () => unwrap(store2),
|
|
554
|
+
write: (mutation) => update(mutation)
|
|
555
|
+
};
|
|
556
|
+
entries.set(key, entry);
|
|
557
|
+
return entry;
|
|
558
|
+
};
|
|
559
|
+
return {
|
|
560
|
+
read(key) {
|
|
561
|
+
return entryOf(key).read();
|
|
562
|
+
},
|
|
563
|
+
write(key, mutate) {
|
|
564
|
+
return entryOf(key).write(mutate);
|
|
565
|
+
}
|
|
566
|
+
};
|
|
567
|
+
}
|
|
568
|
+
var KEY_PREFIX = "history.";
|
|
569
|
+
|
|
570
|
+
// src/history/service.ts
|
|
571
|
+
import {createSignal} from "solid-js";
|
|
572
|
+
|
|
573
|
+
// src/filters.ts
|
|
574
|
+
function rangeStartMs(range, nowMs) {
|
|
575
|
+
switch (range) {
|
|
576
|
+
case "last7":
|
|
577
|
+
return nowMs - 7 * DAY_MS;
|
|
578
|
+
case "last30":
|
|
579
|
+
return nowMs - 30 * DAY_MS;
|
|
580
|
+
case "last90":
|
|
581
|
+
return nowMs - 90 * DAY_MS;
|
|
582
|
+
case "all":
|
|
583
|
+
return;
|
|
584
|
+
}
|
|
585
|
+
}
|
|
586
|
+
var DEFAULT_FILTERS = { scope: "all", range: "last30", reasoning: "all" };
|
|
587
|
+
var DAY_MS = 86400000;
|
|
588
|
+
|
|
589
|
+
// src/metric.ts
|
|
590
|
+
function classifyAssistant(message) {
|
|
591
|
+
if (message.error !== undefined)
|
|
592
|
+
return { kind: "excluded", reason: "failed" };
|
|
593
|
+
const completedAt = message.time.completed;
|
|
594
|
+
if (completedAt === undefined)
|
|
595
|
+
return { kind: "excluded", reason: "in-progress" };
|
|
596
|
+
const attribution = {
|
|
597
|
+
providerID: message.model.providerID,
|
|
598
|
+
modelID: message.model.id,
|
|
599
|
+
variant: message.model.variant,
|
|
600
|
+
completedAt
|
|
601
|
+
};
|
|
602
|
+
if (message.time.streamed === undefined) {
|
|
603
|
+
return { kind: "unavailable", sample: attribution, reason: "missing-streamed" };
|
|
604
|
+
}
|
|
605
|
+
if (message.tokens === undefined) {
|
|
606
|
+
return { kind: "unavailable", sample: attribution, reason: "missing-tokens" };
|
|
607
|
+
}
|
|
608
|
+
const durationMs = message.time.streamed - message.time.created;
|
|
609
|
+
if (durationMs <= 0) {
|
|
610
|
+
return { kind: "unavailable", sample: attribution, reason: "invalid-duration" };
|
|
611
|
+
}
|
|
612
|
+
const generated = message.tokens.output + message.tokens.reasoning;
|
|
613
|
+
if (generated <= 0) {
|
|
614
|
+
return { kind: "unavailable", sample: attribution, reason: "no-generated-tokens" };
|
|
615
|
+
}
|
|
616
|
+
return {
|
|
617
|
+
kind: "measured",
|
|
618
|
+
sample: {
|
|
619
|
+
providerID: attribution.providerID,
|
|
620
|
+
modelID: attribution.modelID,
|
|
621
|
+
variant: attribution.variant,
|
|
622
|
+
completedAt,
|
|
623
|
+
rate: generated / (durationMs / 1000)
|
|
624
|
+
}
|
|
625
|
+
};
|
|
626
|
+
}
|
|
627
|
+
|
|
628
|
+
// src/harvest.ts
|
|
629
|
+
async function listSessions(client, options) {
|
|
630
|
+
const sessions = [];
|
|
631
|
+
const fromMs = options.fromMs;
|
|
632
|
+
const seenCursors = new Set;
|
|
633
|
+
let sessionCursor;
|
|
634
|
+
do {
|
|
635
|
+
const page = await client.session.list(sessionCursor === undefined ? {
|
|
636
|
+
limit: SESSION_PAGE_SIZE,
|
|
637
|
+
order: "desc",
|
|
638
|
+
...options.directory === undefined ? {} : { directory: options.directory }
|
|
639
|
+
} : { limit: SESSION_PAGE_SIZE, cursor: sessionCursor });
|
|
640
|
+
sessions.push(...page.data);
|
|
641
|
+
const stalePage = fromMs !== undefined && page.data.length > 0 && page.data.every((session) => session.time.updated < fromMs);
|
|
642
|
+
if (stalePage)
|
|
643
|
+
return { sessions, boundaryReached: true };
|
|
644
|
+
sessionCursor = page.cursor.next ?? undefined;
|
|
645
|
+
if (sessionCursor !== undefined) {
|
|
646
|
+
if (seenCursors.has(sessionCursor))
|
|
647
|
+
throw new Error("repeated cursor");
|
|
648
|
+
seenCursors.add(sessionCursor);
|
|
649
|
+
}
|
|
650
|
+
} while (sessionCursor !== undefined);
|
|
651
|
+
return { sessions, boundaryReached: true };
|
|
652
|
+
}
|
|
653
|
+
function inRangeSamples(result, fromMs) {
|
|
654
|
+
if (fromMs === undefined)
|
|
655
|
+
return result;
|
|
656
|
+
return {
|
|
657
|
+
samples: result.samples.filter((sample) => sample.completedAt >= fromMs),
|
|
658
|
+
unavailable: result.unavailable.filter((sample) => sample.completedAt >= fromMs)
|
|
659
|
+
};
|
|
660
|
+
}
|
|
661
|
+
function collectVariants(samples, unavailable) {
|
|
662
|
+
const variantSet = new Set;
|
|
663
|
+
for (const sample of samples)
|
|
664
|
+
if (sample.variant !== undefined)
|
|
665
|
+
variantSet.add(sample.variant);
|
|
666
|
+
for (const sample of unavailable)
|
|
667
|
+
if (sample.variant !== undefined)
|
|
668
|
+
variantSet.add(sample.variant);
|
|
669
|
+
return [...variantSet].sort();
|
|
670
|
+
}
|
|
671
|
+
async function scanMessages(client, session) {
|
|
672
|
+
const samples = [];
|
|
673
|
+
const unavailable = [];
|
|
674
|
+
const seenCursors = new Set;
|
|
675
|
+
let messageCursor;
|
|
676
|
+
do {
|
|
677
|
+
const page = await client.message.list(messageCursor === undefined ? { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, order: "desc", type: "assistant" } : { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, type: "assistant", cursor: messageCursor });
|
|
678
|
+
for (const message of page.data) {
|
|
679
|
+
if (message.type !== "assistant")
|
|
680
|
+
continue;
|
|
681
|
+
if (session.fork !== undefined && message.time.created < session.time.created)
|
|
682
|
+
continue;
|
|
683
|
+
const result = classifyAssistant(message);
|
|
684
|
+
if (result.kind === "measured")
|
|
685
|
+
samples.push(result.sample);
|
|
686
|
+
else if (result.kind === "unavailable")
|
|
687
|
+
unavailable.push(result.sample);
|
|
688
|
+
}
|
|
689
|
+
messageCursor = page.cursor.next ?? undefined;
|
|
690
|
+
if (messageCursor !== undefined) {
|
|
691
|
+
if (seenCursors.has(messageCursor))
|
|
692
|
+
throw new Error("repeated cursor");
|
|
693
|
+
seenCursors.add(messageCursor);
|
|
694
|
+
}
|
|
695
|
+
} while (messageCursor !== undefined);
|
|
696
|
+
return { samples, unavailable };
|
|
697
|
+
}
|
|
698
|
+
var SESSION_PAGE_SIZE = 100;
|
|
699
|
+
var MESSAGE_PAGE_SIZE = 200;
|
|
700
|
+
|
|
701
|
+
// src/stats.ts
|
|
702
|
+
function median(values) {
|
|
703
|
+
if (values.length === 0)
|
|
704
|
+
return null;
|
|
705
|
+
const sorted = [...values].sort((a, b) => a - b);
|
|
706
|
+
const middle = Math.floor(sorted.length / 2);
|
|
707
|
+
if (sorted.length % 2 === 1)
|
|
708
|
+
return sorted[middle];
|
|
709
|
+
return (sorted[middle - 1] + sorted[middle]) / 2;
|
|
710
|
+
}
|
|
711
|
+
function applyReasoningFilter(samples, unavailable, filter) {
|
|
712
|
+
if (filter === "all")
|
|
713
|
+
return { samples, unavailable };
|
|
714
|
+
const matches = (variant) => filter === "unknown" ? variant === undefined : variant === filter;
|
|
715
|
+
return {
|
|
716
|
+
samples: samples.filter((sample) => matches(sample.variant)),
|
|
717
|
+
unavailable: unavailable.filter((sample) => matches(sample.variant))
|
|
718
|
+
};
|
|
719
|
+
}
|
|
720
|
+
function rowKey(providerID, modelID) {
|
|
721
|
+
return `${providerID}/${modelID}`;
|
|
722
|
+
}
|
|
723
|
+
function comparisonRows(samples, unavailable) {
|
|
724
|
+
const groups = new Map;
|
|
725
|
+
const ensure = (providerID, modelID) => {
|
|
726
|
+
const key = rowKey(providerID, modelID);
|
|
727
|
+
let group = groups.get(key);
|
|
728
|
+
if (group === undefined) {
|
|
729
|
+
group = { providerID, modelID, rates: [], unavailable: 0 };
|
|
730
|
+
groups.set(key, group);
|
|
731
|
+
}
|
|
732
|
+
return group;
|
|
733
|
+
};
|
|
734
|
+
for (const sample of samples)
|
|
735
|
+
ensure(sample.providerID, sample.modelID).rates.push(sample.rate);
|
|
736
|
+
for (const sample of unavailable)
|
|
737
|
+
ensure(sample.providerID, sample.modelID).unavailable++;
|
|
738
|
+
const rows = [...groups].map(([key, group]) => {
|
|
739
|
+
const measured = group.rates.length > 0;
|
|
740
|
+
return {
|
|
741
|
+
key,
|
|
742
|
+
providerID: group.providerID,
|
|
743
|
+
modelID: group.modelID,
|
|
744
|
+
median: measured ? median(group.rates) : null,
|
|
745
|
+
calls: group.rates.length,
|
|
746
|
+
unavailable: !measured && group.unavailable > 0
|
|
747
|
+
};
|
|
748
|
+
});
|
|
749
|
+
return rows.sort((a, b) => {
|
|
750
|
+
const unavailableOrder = Number(a.unavailable) - Number(b.unavailable);
|
|
751
|
+
if (unavailableOrder !== 0)
|
|
752
|
+
return unavailableOrder;
|
|
753
|
+
const medianOrder = (b.median ?? Number.NEGATIVE_INFINITY) - (a.median ?? Number.NEGATIVE_INFINITY);
|
|
754
|
+
if (medianOrder !== 0)
|
|
755
|
+
return medianOrder;
|
|
756
|
+
if (b.calls !== a.calls)
|
|
757
|
+
return b.calls - a.calls;
|
|
758
|
+
return a.key.localeCompare(b.key);
|
|
759
|
+
});
|
|
760
|
+
}
|
|
761
|
+
var dayStart = function(epochMs) {
|
|
762
|
+
const date = new Date(epochMs);
|
|
763
|
+
return new Date(date.getFullYear(), date.getMonth(), date.getDate());
|
|
764
|
+
};
|
|
765
|
+
function localDayKey(epochMs) {
|
|
766
|
+
const date = new Date(epochMs);
|
|
767
|
+
const month = String(date.getMonth() + 1).padStart(2, "0");
|
|
768
|
+
const day = String(date.getDate()).padStart(2, "0");
|
|
769
|
+
return `${date.getFullYear()}-${month}-${day}`;
|
|
770
|
+
}
|
|
771
|
+
function dailySeries(samples, key, fromMs, nowMs) {
|
|
772
|
+
const matching = samples.filter((sample) => rowKey(sample.providerID, sample.modelID) === key);
|
|
773
|
+
const startMs = fromMs ?? (matching.length > 0 ? Math.min(...matching.map((sample) => sample.completedAt)) : nowMs);
|
|
774
|
+
const byDay = new Map;
|
|
775
|
+
for (const sample of matching) {
|
|
776
|
+
const day = localDayKey(sample.completedAt);
|
|
777
|
+
const rates = byDay.get(day);
|
|
778
|
+
if (rates === undefined)
|
|
779
|
+
byDay.set(day, [sample.rate]);
|
|
780
|
+
else
|
|
781
|
+
rates.push(sample.rate);
|
|
782
|
+
}
|
|
783
|
+
const points = [];
|
|
784
|
+
const end = dayStart(nowMs);
|
|
785
|
+
for (const cursor = dayStart(startMs);cursor.getTime() <= end.getTime(); cursor.setDate(cursor.getDate() + 1)) {
|
|
786
|
+
const date = localDayKey(cursor.getTime());
|
|
787
|
+
const rates = byDay.get(date);
|
|
788
|
+
points.push({
|
|
789
|
+
date,
|
|
790
|
+
median: rates === undefined ? null : median(rates),
|
|
791
|
+
calls: rates?.length ?? 0
|
|
792
|
+
});
|
|
793
|
+
}
|
|
794
|
+
return points;
|
|
795
|
+
}
|
|
796
|
+
function windowRange(length, selected, size) {
|
|
797
|
+
const span = Math.max(0, Math.min(size, length));
|
|
798
|
+
if (span === 0)
|
|
799
|
+
return { start: 0, end: 0 };
|
|
800
|
+
const clamped = Math.max(0, Math.min(selected, length - 1));
|
|
801
|
+
const start = Math.max(0, Math.min(clamped - Math.floor(span / 2), length - span));
|
|
802
|
+
return { start, end: start + span };
|
|
803
|
+
}
|
|
804
|
+
function dayWindow(series, selected, width) {
|
|
805
|
+
return windowRange(series.length, selected, width);
|
|
806
|
+
}
|
|
807
|
+
function barLevels(series, rows) {
|
|
808
|
+
const max = Math.max(0, ...series.map((point) => point.median ?? 0));
|
|
809
|
+
return series.map((point) => {
|
|
810
|
+
if (point.median === null || max <= 0)
|
|
811
|
+
return null;
|
|
812
|
+
return Math.max(1, Math.round(point.median / max * rows));
|
|
813
|
+
});
|
|
814
|
+
}
|
|
815
|
+
|
|
816
|
+
// src/sidebar/rank.ts
|
|
817
|
+
function widgetRows(samples, nowMs) {
|
|
818
|
+
const since = nowMs - WIDGET_WINDOW_MS;
|
|
819
|
+
const groups = new Map;
|
|
820
|
+
for (const sample of samples) {
|
|
821
|
+
if (sample.completedAt <= since || sample.completedAt > nowMs)
|
|
822
|
+
continue;
|
|
823
|
+
const key = rowKey(sample.providerID, sample.modelID);
|
|
824
|
+
let group = groups.get(key);
|
|
825
|
+
if (group === undefined) {
|
|
826
|
+
group = { providerID: sample.providerID, modelID: sample.modelID, rates: [] };
|
|
827
|
+
groups.set(key, group);
|
|
828
|
+
}
|
|
829
|
+
group.rates.push(sample.rate);
|
|
830
|
+
}
|
|
831
|
+
const rows = [];
|
|
832
|
+
for (const [key, group] of groups) {
|
|
833
|
+
if (group.rates.length < WIDGET_MIN_CALLS)
|
|
834
|
+
continue;
|
|
835
|
+
const value = median(group.rates);
|
|
836
|
+
if (value === null)
|
|
837
|
+
continue;
|
|
838
|
+
rows.push({
|
|
839
|
+
key,
|
|
840
|
+
providerID: group.providerID,
|
|
841
|
+
modelID: group.modelID,
|
|
842
|
+
median: value,
|
|
843
|
+
calls: group.rates.length
|
|
844
|
+
});
|
|
845
|
+
}
|
|
846
|
+
rows.sort((a, b) => {
|
|
847
|
+
const medianOrder = b.median - a.median;
|
|
848
|
+
if (medianOrder !== 0)
|
|
849
|
+
return medianOrder;
|
|
850
|
+
if (b.calls !== a.calls)
|
|
851
|
+
return b.calls - a.calls;
|
|
852
|
+
return a.key.localeCompare(b.key);
|
|
853
|
+
});
|
|
854
|
+
return rows.slice(0, WIDGET_MAX_ENTRIES);
|
|
855
|
+
}
|
|
856
|
+
var WIDGET_WINDOW_MS = 86400000;
|
|
857
|
+
var WIDGET_MIN_CALLS = 3;
|
|
858
|
+
var WIDGET_MAX_ENTRIES = 3;
|
|
859
|
+
|
|
860
|
+
// src/history/service.ts
|
|
861
|
+
var matchesScope = function(sessionDirectory, directoryFilter) {
|
|
862
|
+
if (directoryFilter === undefined)
|
|
863
|
+
return true;
|
|
864
|
+
return sessionDirectory === undefined || sessionDirectory === directoryFilter;
|
|
865
|
+
};
|
|
866
|
+
var isNotFound = function(error) {
|
|
867
|
+
if (typeof error !== "object" || error === null)
|
|
868
|
+
return false;
|
|
869
|
+
const fields = error;
|
|
870
|
+
if (fields.status === 404 || fields.statusCode === 404)
|
|
871
|
+
return true;
|
|
872
|
+
if (fields.cause?.status === 404)
|
|
873
|
+
return true;
|
|
874
|
+
return typeof fields.message === "string" && /(?:^|\D)404(?:\D|$)/.test(fields.message);
|
|
875
|
+
};
|
|
876
|
+
function createHistoryService(deps) {
|
|
877
|
+
const client = deps.client;
|
|
878
|
+
const now = deps.now;
|
|
879
|
+
const concurrency = Math.max(1, deps.concurrency ?? 8);
|
|
880
|
+
const records3 = new Map;
|
|
881
|
+
const index = new Map;
|
|
882
|
+
const tombstones = new Set;
|
|
883
|
+
const coverage = new Map;
|
|
884
|
+
const views = new Map;
|
|
885
|
+
const passes = new Map;
|
|
886
|
+
const statuses = new Map;
|
|
887
|
+
const work = new Map;
|
|
888
|
+
const dirty = new Set;
|
|
889
|
+
const scanTokens = new Map;
|
|
890
|
+
let holds = 0;
|
|
891
|
+
let timerCancel;
|
|
892
|
+
let auditCancel;
|
|
893
|
+
let burstCancel;
|
|
894
|
+
let burstStartedAt;
|
|
895
|
+
let flushInFlight;
|
|
896
|
+
let resetGeneration = 0;
|
|
897
|
+
let pendingRecords = [];
|
|
898
|
+
let persistence = "ok";
|
|
899
|
+
let widgetPublished = false;
|
|
900
|
+
let hydrated = false;
|
|
901
|
+
const storedWidget = deps.repository.readWidgetSnapshot();
|
|
902
|
+
const [widgetState, setWidgetState] = createSignal(storedWidget === undefined ? { status: "loading", rows: [], stale: false } : { status: "ready", rows: storedWidget.rows, stale: true });
|
|
903
|
+
if (storedWidget !== undefined)
|
|
904
|
+
widgetPublished = true;
|
|
905
|
+
rememberTombstones();
|
|
906
|
+
function rememberTombstones() {
|
|
907
|
+
for (const sessionID of deps.repository.loadTombstones().sessionIDs)
|
|
908
|
+
tombstones.add(sessionID);
|
|
909
|
+
}
|
|
910
|
+
function hydrateShards() {
|
|
911
|
+
if (hydrated)
|
|
912
|
+
return;
|
|
913
|
+
hydrated = true;
|
|
914
|
+
for (const shard of deps.repository.loadAllShards().values()) {
|
|
915
|
+
for (const entry of Object.values(shard.index)) {
|
|
916
|
+
if (!tombstones.has(entry.sessionID))
|
|
917
|
+
index.set(entry.sessionID, entry);
|
|
918
|
+
}
|
|
919
|
+
for (const record of Object.values(shard.records)) {
|
|
920
|
+
if (!tombstones.has(record.sessionID))
|
|
921
|
+
records3.set(record.sessionID, record);
|
|
922
|
+
}
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
function forgetSession(sessionID) {
|
|
926
|
+
records3.delete(sessionID);
|
|
927
|
+
index.delete(sessionID);
|
|
928
|
+
dirty.delete(sessionID);
|
|
929
|
+
pendingRecords = pendingRecords.filter((record) => record.sessionID !== sessionID);
|
|
930
|
+
}
|
|
931
|
+
function workOf(sessionID) {
|
|
932
|
+
const existing = work.get(sessionID);
|
|
933
|
+
if (existing !== undefined)
|
|
934
|
+
return existing;
|
|
935
|
+
const fresh = { revision: 0, covered: 0, inFlight: false, pending: false, followUp: false };
|
|
936
|
+
work.set(sessionID, fresh);
|
|
937
|
+
return fresh;
|
|
938
|
+
}
|
|
939
|
+
function scanTokenOf(sessionID) {
|
|
940
|
+
return scanTokens.get(sessionID) ?? 0;
|
|
941
|
+
}
|
|
942
|
+
function coverageFor(directory) {
|
|
943
|
+
const key = directoryKeyOf(directory);
|
|
944
|
+
const cached = coverage.get(key);
|
|
945
|
+
if (cached !== undefined)
|
|
946
|
+
return cached;
|
|
947
|
+
const stored = deps.repository.readCoverage(directory);
|
|
948
|
+
if (stored !== undefined)
|
|
949
|
+
coverage.set(key, stored);
|
|
950
|
+
return stored;
|
|
951
|
+
}
|
|
952
|
+
function statusFor(directory) {
|
|
953
|
+
const key = directoryKeyOf(directory);
|
|
954
|
+
let status = statuses.get(key);
|
|
955
|
+
if (status === undefined) {
|
|
956
|
+
status = { refreshing: false, failed: false, publishedAt: undefined, publishCancel: undefined };
|
|
957
|
+
statuses.set(key, status);
|
|
958
|
+
}
|
|
959
|
+
return status;
|
|
960
|
+
}
|
|
961
|
+
function viewsOf(directory) {
|
|
962
|
+
const matching = [];
|
|
963
|
+
for (const entry of views.values()) {
|
|
964
|
+
if (entry.request.directory === directory)
|
|
965
|
+
matching.push(entry);
|
|
966
|
+
}
|
|
967
|
+
return matching;
|
|
968
|
+
}
|
|
969
|
+
function requestedDirectories() {
|
|
970
|
+
const directories = [];
|
|
971
|
+
for (const entry of views.values()) {
|
|
972
|
+
if (!directories.some((directory) => directory === entry.request.directory)) {
|
|
973
|
+
directories.push(entry.request.directory);
|
|
974
|
+
}
|
|
975
|
+
}
|
|
976
|
+
if (directories.length === 0 && holds > 0)
|
|
977
|
+
directories.push(undefined);
|
|
978
|
+
return directories;
|
|
979
|
+
}
|
|
980
|
+
function affectedDirectories(sessionDirectory) {
|
|
981
|
+
return requestedDirectories().filter((directory) => matchesScope(sessionDirectory, directory));
|
|
982
|
+
}
|
|
983
|
+
function countIndex(directory) {
|
|
984
|
+
let count = 0;
|
|
985
|
+
for (const entry of index.values())
|
|
986
|
+
if (matchesScope(entry.directory, directory))
|
|
987
|
+
count += 1;
|
|
988
|
+
return count;
|
|
989
|
+
}
|
|
990
|
+
function liveView(request) {
|
|
991
|
+
const fromMs = rangeStartMs(request.range, now());
|
|
992
|
+
const samples = [];
|
|
993
|
+
const unavailable = [];
|
|
994
|
+
for (const entry of index.values()) {
|
|
995
|
+
if (!matchesScope(entry.directory, request.directory))
|
|
996
|
+
continue;
|
|
997
|
+
if (fromMs !== undefined && entry.updatedAt < fromMs)
|
|
998
|
+
continue;
|
|
999
|
+
const record = records3.get(entry.sessionID);
|
|
1000
|
+
if (record === undefined)
|
|
1001
|
+
continue;
|
|
1002
|
+
const inRange = inRangeSamples(record, fromMs);
|
|
1003
|
+
samples.push(...inRange.samples);
|
|
1004
|
+
unavailable.push(...inRange.unavailable);
|
|
1005
|
+
}
|
|
1006
|
+
return { samples, unavailable };
|
|
1007
|
+
}
|
|
1008
|
+
function buildState(request, kind, lastCheckedAt, refreshing, refreshFailed) {
|
|
1009
|
+
const data = liveView(request);
|
|
1010
|
+
const hasData = data.samples.length > 0 || data.unavailable.length > 0;
|
|
1011
|
+
return {
|
|
1012
|
+
kind: kind === "partial" && !hasData ? "loading" : kind,
|
|
1013
|
+
samples: data.samples,
|
|
1014
|
+
unavailable: data.unavailable,
|
|
1015
|
+
variants: collectVariants(data.samples, data.unavailable),
|
|
1016
|
+
scanned: countIndex(request.directory),
|
|
1017
|
+
lastCheckedAt,
|
|
1018
|
+
refreshing,
|
|
1019
|
+
refreshFailed,
|
|
1020
|
+
persistence
|
|
1021
|
+
};
|
|
1022
|
+
}
|
|
1023
|
+
function publishViews(directory, mode) {
|
|
1024
|
+
const status = statusFor(directory);
|
|
1025
|
+
for (const entry of viewsOf(directory)) {
|
|
1026
|
+
const kind = mode === "ready" ? "ready" : mode === "failure" ? "error" : "partial";
|
|
1027
|
+
entry.publish(buildState(entry.request, kind, entry.lastCheckedAt, mode !== "ready", mode === "failure" || status.failed));
|
|
1028
|
+
}
|
|
1029
|
+
if (mode === "failure")
|
|
1030
|
+
publishWidgetFailure();
|
|
1031
|
+
else
|
|
1032
|
+
publishWidget(mode === "ready");
|
|
1033
|
+
}
|
|
1034
|
+
function publishWidget(persist) {
|
|
1035
|
+
const nowMs = now();
|
|
1036
|
+
const rows = widgetRows(allSamples(), nowMs);
|
|
1037
|
+
widgetPublished = true;
|
|
1038
|
+
setWidgetState({ status: "ready", rows, stale: false });
|
|
1039
|
+
if (persist)
|
|
1040
|
+
persistWidget(rows, nowMs);
|
|
1041
|
+
}
|
|
1042
|
+
function publishWidgetFailure() {
|
|
1043
|
+
const current = widgetState();
|
|
1044
|
+
setWidgetState(widgetPublished ? { status: "ready", rows: current.rows, stale: true } : { status: "error", rows: [], stale: false });
|
|
1045
|
+
}
|
|
1046
|
+
async function persistWidget(rows, nowMs) {
|
|
1047
|
+
try {
|
|
1048
|
+
await deps.repository.writeWidgetSnapshot(rows, nowMs);
|
|
1049
|
+
} catch {
|
|
1050
|
+
persistence = "unavailable";
|
|
1051
|
+
}
|
|
1052
|
+
}
|
|
1053
|
+
function allSamples() {
|
|
1054
|
+
const samples = [];
|
|
1055
|
+
for (const record of records3.values())
|
|
1056
|
+
samples.push(...record.samples);
|
|
1057
|
+
return samples;
|
|
1058
|
+
}
|
|
1059
|
+
async function flushRecords() {
|
|
1060
|
+
if (pendingRecords.length === 0)
|
|
1061
|
+
return;
|
|
1062
|
+
const generation = resetGeneration;
|
|
1063
|
+
const batch = pendingRecords;
|
|
1064
|
+
pendingRecords = [];
|
|
1065
|
+
const flush = (async () => {
|
|
1066
|
+
try {
|
|
1067
|
+
await deps.repository.putRecords(batch, now());
|
|
1068
|
+
persistence = "ok";
|
|
1069
|
+
} catch {
|
|
1070
|
+
if (generation === resetGeneration)
|
|
1071
|
+
pendingRecords = [...batch, ...pendingRecords];
|
|
1072
|
+
persistence = "unavailable";
|
|
1073
|
+
}
|
|
1074
|
+
})();
|
|
1075
|
+
flushInFlight = flush;
|
|
1076
|
+
try {
|
|
1077
|
+
await flush;
|
|
1078
|
+
} finally {
|
|
1079
|
+
if (flushInFlight === flush)
|
|
1080
|
+
flushInFlight = undefined;
|
|
1081
|
+
}
|
|
1082
|
+
}
|
|
1083
|
+
async function readMeta(sessionID) {
|
|
1084
|
+
const get = client.session.get;
|
|
1085
|
+
if (get === undefined)
|
|
1086
|
+
return;
|
|
1087
|
+
try {
|
|
1088
|
+
return await get.call(client.session, { sessionID });
|
|
1089
|
+
} catch {
|
|
1090
|
+
return;
|
|
1091
|
+
}
|
|
1092
|
+
}
|
|
1093
|
+
async function scanSession(meta) {
|
|
1094
|
+
if (tombstones.has(meta.id)) {
|
|
1095
|
+
forgetSession(meta.id);
|
|
1096
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1097
|
+
}
|
|
1098
|
+
const state = workOf(meta.id);
|
|
1099
|
+
if (state.inFlight) {
|
|
1100
|
+
state.followUp = true;
|
|
1101
|
+
return;
|
|
1102
|
+
}
|
|
1103
|
+
state.inFlight = true;
|
|
1104
|
+
const revision = state.revision;
|
|
1105
|
+
const generation = resetGeneration;
|
|
1106
|
+
const token = scanTokenOf(meta.id);
|
|
1107
|
+
const current = () => generation === resetGeneration && scanTokenOf(meta.id) === token;
|
|
1108
|
+
try {
|
|
1109
|
+
const fresh = await readMeta(meta.id) ?? meta;
|
|
1110
|
+
if (!current())
|
|
1111
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1112
|
+
const scan = await scanMessages(client, fresh);
|
|
1113
|
+
if (!current())
|
|
1114
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1115
|
+
const after = await readMeta(meta.id) ?? fresh;
|
|
1116
|
+
if (!current())
|
|
1117
|
+
return { meta: undefined, requeue: false, discarded: true };
|
|
1118
|
+
if (tombstones.has(fresh.id)) {
|
|
1119
|
+
forgetSession(fresh.id);
|
|
1120
|
+
return { meta: after, requeue: false, discarded: true };
|
|
1121
|
+
}
|
|
1122
|
+
const record = recordFrom(fresh, scan, now());
|
|
1123
|
+
records3.set(record.sessionID, record);
|
|
1124
|
+
index.set(record.sessionID, {
|
|
1125
|
+
sessionID: record.sessionID,
|
|
1126
|
+
directory: record.directory,
|
|
1127
|
+
updatedAt: record.updatedAt
|
|
1128
|
+
});
|
|
1129
|
+
pendingRecords.push(record);
|
|
1130
|
+
return { meta: after, requeue: signatureFor(after) !== signatureFor(fresh), discarded: false };
|
|
1131
|
+
} finally {
|
|
1132
|
+
state.inFlight = false;
|
|
1133
|
+
state.covered = Math.max(state.covered, revision);
|
|
1134
|
+
if (state.followUp || state.revision > state.covered) {
|
|
1135
|
+
state.followUp = false;
|
|
1136
|
+
scheduleSessionScan(meta.id);
|
|
1137
|
+
}
|
|
1138
|
+
}
|
|
1139
|
+
}
|
|
1140
|
+
function cancelPublish(directory) {
|
|
1141
|
+
const status = statuses.get(directoryKeyOf(directory));
|
|
1142
|
+
if (status?.publishCancel === undefined)
|
|
1143
|
+
return;
|
|
1144
|
+
status.publishCancel();
|
|
1145
|
+
status.publishCancel = undefined;
|
|
1146
|
+
}
|
|
1147
|
+
function cancelPublications() {
|
|
1148
|
+
for (const status of statuses.values()) {
|
|
1149
|
+
if (status.publishCancel === undefined)
|
|
1150
|
+
continue;
|
|
1151
|
+
status.publishCancel();
|
|
1152
|
+
status.publishCancel = undefined;
|
|
1153
|
+
}
|
|
1154
|
+
}
|
|
1155
|
+
function schedulePublish(directory) {
|
|
1156
|
+
const status = statusFor(directory);
|
|
1157
|
+
if (status.publishCancel !== undefined)
|
|
1158
|
+
return;
|
|
1159
|
+
const elapsed = now() - (status.publishedAt ?? now());
|
|
1160
|
+
status.publishCancel = deps.delay(() => {
|
|
1161
|
+
status.publishCancel = undefined;
|
|
1162
|
+
publishDeferred(directory);
|
|
1163
|
+
}, Math.max(0, PUBLISH_INTERVAL_MS - elapsed));
|
|
1164
|
+
}
|
|
1165
|
+
async function publishDeferred(directory) {
|
|
1166
|
+
try {
|
|
1167
|
+
await flushRecords();
|
|
1168
|
+
publishViews(directory, "progress");
|
|
1169
|
+
statusFor(directory).publishedAt = now();
|
|
1170
|
+
} catch {
|
|
1171
|
+
}
|
|
1172
|
+
}
|
|
1173
|
+
async function publishProgress(directory) {
|
|
1174
|
+
const status = statusFor(directory);
|
|
1175
|
+
if (status.publishedAt !== undefined && now() - status.publishedAt < PUBLISH_INTERVAL_MS) {
|
|
1176
|
+
schedulePublish(directory);
|
|
1177
|
+
return;
|
|
1178
|
+
}
|
|
1179
|
+
await flushRecords();
|
|
1180
|
+
publishViews(directory, "progress");
|
|
1181
|
+
status.publishedAt = now();
|
|
1182
|
+
}
|
|
1183
|
+
async function drain(directory, items, onRequeue) {
|
|
1184
|
+
let cursor = 0;
|
|
1185
|
+
let abandoned = false;
|
|
1186
|
+
const worker = async () => {
|
|
1187
|
+
for (;; ) {
|
|
1188
|
+
if (holds === 0) {
|
|
1189
|
+
abandoned = true;
|
|
1190
|
+
return;
|
|
1191
|
+
}
|
|
1192
|
+
const position = cursor;
|
|
1193
|
+
cursor += 1;
|
|
1194
|
+
if (position >= items.length)
|
|
1195
|
+
return;
|
|
1196
|
+
const outcome = await scanSession(items[position]);
|
|
1197
|
+
if (outcome?.requeue === true && outcome.meta !== undefined)
|
|
1198
|
+
onRequeue(outcome.meta);
|
|
1199
|
+
await publishProgress(directory);
|
|
1200
|
+
}
|
|
1201
|
+
};
|
|
1202
|
+
const workers = Math.min(concurrency, Math.max(1, items.length));
|
|
1203
|
+
await Promise.all(Array.from({ length: workers }, () => worker()));
|
|
1204
|
+
return abandoned;
|
|
1205
|
+
}
|
|
1206
|
+
async function commitCoverage(directory, startedAt, inventory, previous) {
|
|
1207
|
+
const next = {
|
|
1208
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
1209
|
+
directoryFilter: directory,
|
|
1210
|
+
fullInventoryCompletedAt: inventory ? startedAt : previous?.fullInventoryCompletedAt,
|
|
1211
|
+
recentCatchUpAt: startedAt
|
|
1212
|
+
};
|
|
1213
|
+
try {
|
|
1214
|
+
await deps.repository.writeCoverage(next);
|
|
1215
|
+
coverage.set(directoryKeyOf(directory), next);
|
|
1216
|
+
} catch {
|
|
1217
|
+
persistence = "unavailable";
|
|
1218
|
+
}
|
|
1219
|
+
}
|
|
1220
|
+
async function publishReady(directory) {
|
|
1221
|
+
cancelPublish(directory);
|
|
1222
|
+
await flushRecords();
|
|
1223
|
+
const checkedAt = now();
|
|
1224
|
+
for (const entry of viewsOf(directory)) {
|
|
1225
|
+
const data = liveView(entry.request);
|
|
1226
|
+
entry.lastCheckedAt = checkedAt;
|
|
1227
|
+
const snapshot = {
|
|
1228
|
+
schemaVersion: CACHE_SCHEMA_VERSION,
|
|
1229
|
+
metricVersion: METRIC_VERSION,
|
|
1230
|
+
directoryFilter: entry.request.directory,
|
|
1231
|
+
range: entry.request.range,
|
|
1232
|
+
rows: comparisonRows(data.samples, data.unavailable),
|
|
1233
|
+
lastCheckedAt: checkedAt,
|
|
1234
|
+
savedAtMs: checkedAt
|
|
1235
|
+
};
|
|
1236
|
+
try {
|
|
1237
|
+
await deps.repository.writeViewSnapshot(snapshot);
|
|
1238
|
+
} catch {
|
|
1239
|
+
persistence = "unavailable";
|
|
1240
|
+
}
|
|
1241
|
+
}
|
|
1242
|
+
statusFor(directory).publishedAt = checkedAt;
|
|
1243
|
+
publishViews(directory, "ready");
|
|
1244
|
+
}
|
|
1245
|
+
async function probeSession(sessionID) {
|
|
1246
|
+
const get = client.session.get;
|
|
1247
|
+
if (get === undefined)
|
|
1248
|
+
return "unknown";
|
|
1249
|
+
try {
|
|
1250
|
+
await get.call(client.session, { sessionID });
|
|
1251
|
+
return "present";
|
|
1252
|
+
} catch (error) {
|
|
1253
|
+
return isNotFound(error) ? "missing" : "unknown";
|
|
1254
|
+
}
|
|
1255
|
+
}
|
|
1256
|
+
async function verifyInventory(listed, known) {
|
|
1257
|
+
if (client.session.get === undefined)
|
|
1258
|
+
return;
|
|
1259
|
+
const tombstoned = [...tombstones];
|
|
1260
|
+
let removed = false;
|
|
1261
|
+
let verified = true;
|
|
1262
|
+
for (const sessionID of known) {
|
|
1263
|
+
if (listed.has(sessionID) || tombstones.has(sessionID))
|
|
1264
|
+
continue;
|
|
1265
|
+
const state = await probeSession(sessionID);
|
|
1266
|
+
if (state === "missing") {
|
|
1267
|
+
await deleteSession(sessionID);
|
|
1268
|
+
removed = true;
|
|
1269
|
+
} else if (state === "unknown") {
|
|
1270
|
+
verified = false;
|
|
1271
|
+
}
|
|
1272
|
+
}
|
|
1273
|
+
if (removed || !verified)
|
|
1274
|
+
return;
|
|
1275
|
+
for (const sessionID of tombstoned) {
|
|
1276
|
+
if (await probeSession(sessionID) !== "missing") {
|
|
1277
|
+
verified = false;
|
|
1278
|
+
break;
|
|
1279
|
+
}
|
|
1280
|
+
}
|
|
1281
|
+
if (!verified || tombstoned.length === 0)
|
|
1282
|
+
return;
|
|
1283
|
+
try {
|
|
1284
|
+
await deps.repository.clearTombstones(now());
|
|
1285
|
+
tombstones.clear();
|
|
1286
|
+
} catch {
|
|
1287
|
+
persistence = "unavailable";
|
|
1288
|
+
}
|
|
1289
|
+
}
|
|
1290
|
+
async function deleteSession(sessionID) {
|
|
1291
|
+
scanTokens.set(sessionID, scanTokenOf(sessionID) + 1);
|
|
1292
|
+
tombstones.add(sessionID);
|
|
1293
|
+
const directory = records3.get(sessionID)?.directory ?? index.get(sessionID)?.directory;
|
|
1294
|
+
forgetSession(sessionID);
|
|
1295
|
+
try {
|
|
1296
|
+
await deps.repository.removeSessions([sessionID], now());
|
|
1297
|
+
} catch {
|
|
1298
|
+
persistence = "unavailable";
|
|
1299
|
+
}
|
|
1300
|
+
await publishSessionWork([directory], "settled");
|
|
1301
|
+
}
|
|
1302
|
+
function unsettled() {
|
|
1303
|
+
for (const state of work.values()) {
|
|
1304
|
+
if (state.inFlight || state.pending || state.followUp || state.revision > state.covered)
|
|
1305
|
+
return true;
|
|
1306
|
+
}
|
|
1307
|
+
return false;
|
|
1308
|
+
}
|
|
1309
|
+
async function publishSessionWork(sessionDirectories, mode) {
|
|
1310
|
+
const targets = new Set;
|
|
1311
|
+
for (const sessionDirectory of sessionDirectories) {
|
|
1312
|
+
for (const directory of affectedDirectories(sessionDirectory))
|
|
1313
|
+
targets.add(directory);
|
|
1314
|
+
}
|
|
1315
|
+
if (targets.size === 0) {
|
|
1316
|
+
await flushRecords();
|
|
1317
|
+
publishWidget(false);
|
|
1318
|
+
return;
|
|
1319
|
+
}
|
|
1320
|
+
for (const directory of targets) {
|
|
1321
|
+
if (mode === "settled" && !statusFor(directory).refreshing && !unsettled()) {
|
|
1322
|
+
await publishReady(directory);
|
|
1323
|
+
} else {
|
|
1324
|
+
await publishProgress(directory);
|
|
1325
|
+
}
|
|
1326
|
+
}
|
|
1327
|
+
}
|
|
1328
|
+
function publishSessionFailure(sessionDirectory) {
|
|
1329
|
+
const targets = affectedDirectories(sessionDirectory);
|
|
1330
|
+
if (targets.length === 0) {
|
|
1331
|
+
publishWidgetFailure();
|
|
1332
|
+
return;
|
|
1333
|
+
}
|
|
1334
|
+
for (const directory of targets) {
|
|
1335
|
+
const status = statusFor(directory);
|
|
1336
|
+
status.refreshing = true;
|
|
1337
|
+
status.failed = true;
|
|
1338
|
+
publishViews(directory, "failure");
|
|
1339
|
+
}
|
|
1340
|
+
}
|
|
1341
|
+
async function scanOne(sessionID) {
|
|
1342
|
+
const meta = await readMeta(sessionID);
|
|
1343
|
+
if (meta === undefined)
|
|
1344
|
+
return { scanned: false, directory: undefined };
|
|
1345
|
+
const directory = meta.location?.directory;
|
|
1346
|
+
if (tombstones.has(sessionID)) {
|
|
1347
|
+
forgetSession(sessionID);
|
|
1348
|
+
return { scanned: false, directory };
|
|
1349
|
+
}
|
|
1350
|
+
try {
|
|
1351
|
+
await scanSession(meta);
|
|
1352
|
+
return { scanned: true, directory };
|
|
1353
|
+
} catch {
|
|
1354
|
+
publishSessionFailure(directory);
|
|
1355
|
+
return { scanned: false, directory };
|
|
1356
|
+
}
|
|
1357
|
+
}
|
|
1358
|
+
function scheduleSessionScan(sessionID) {
|
|
1359
|
+
const state = workOf(sessionID);
|
|
1360
|
+
if (state.pending || state.inFlight) {
|
|
1361
|
+
if (state.revision > state.covered)
|
|
1362
|
+
state.followUp = true;
|
|
1363
|
+
return;
|
|
1364
|
+
}
|
|
1365
|
+
if (state.revision <= state.covered)
|
|
1366
|
+
return;
|
|
1367
|
+
state.pending = true;
|
|
1368
|
+
Promise.resolve().then(async () => {
|
|
1369
|
+
state.pending = false;
|
|
1370
|
+
const result = await scanOne(sessionID);
|
|
1371
|
+
if (!result.scanned)
|
|
1372
|
+
return;
|
|
1373
|
+
await publishSessionWork([result.directory], "progress");
|
|
1374
|
+
}).catch(() => {
|
|
1375
|
+
}).finally(() => {
|
|
1376
|
+
state.pending = false;
|
|
1377
|
+
});
|
|
1378
|
+
}
|
|
1379
|
+
function scheduleDirtyFlush() {
|
|
1380
|
+
if (holds === 0 || dirty.size === 0)
|
|
1381
|
+
return;
|
|
1382
|
+
const at = now();
|
|
1383
|
+
if (burstStartedAt === undefined)
|
|
1384
|
+
burstStartedAt = at;
|
|
1385
|
+
burstCancel?.();
|
|
1386
|
+
burstCancel = undefined;
|
|
1387
|
+
const remaining = Math.max(0, burstStartedAt + MAX_SCHEDULE_DELAY_MS - at);
|
|
1388
|
+
burstCancel = deps.delay(() => {
|
|
1389
|
+
burstCancel = undefined;
|
|
1390
|
+
flushDirty();
|
|
1391
|
+
}, Math.min(DIRTY_DEBOUNCE_MS, remaining));
|
|
1392
|
+
}
|
|
1393
|
+
function flushDirty() {
|
|
1394
|
+
burstStartedAt = undefined;
|
|
1395
|
+
if (holds === 0)
|
|
1396
|
+
return;
|
|
1397
|
+
const sessions = [...dirty];
|
|
1398
|
+
dirty.clear();
|
|
1399
|
+
for (const sessionID of sessions) {
|
|
1400
|
+
const state = workOf(sessionID);
|
|
1401
|
+
state.revision += 1;
|
|
1402
|
+
scheduleSessionScan(sessionID);
|
|
1403
|
+
}
|
|
1404
|
+
}
|
|
1405
|
+
function markDirty(sessionID) {
|
|
1406
|
+
if (tombstones.has(sessionID))
|
|
1407
|
+
return;
|
|
1408
|
+
dirty.add(sessionID);
|
|
1409
|
+
scheduleDirtyFlush();
|
|
1410
|
+
}
|
|
1411
|
+
function auditCandidates() {
|
|
1412
|
+
return [...index.values()].filter((entry) => !tombstones.has(entry.sessionID)).map((entry) => ({ entry, scannedAt: records3.get(entry.sessionID)?.scannedAtMs ?? 0 })).sort((left, right) => left.scannedAt - right.scannedAt || left.entry.sessionID.localeCompare(right.entry.sessionID)).slice(0, AUDIT_BATCH_SESSIONS).map((candidate) => candidate.entry.sessionID);
|
|
1413
|
+
}
|
|
1414
|
+
async function runAudit() {
|
|
1415
|
+
if (holds === 0)
|
|
1416
|
+
return;
|
|
1417
|
+
const directories = [];
|
|
1418
|
+
for (const sessionID of auditCandidates()) {
|
|
1419
|
+
if (holds === 0)
|
|
1420
|
+
break;
|
|
1421
|
+
const result = await scanOne(sessionID);
|
|
1422
|
+
if (result.scanned)
|
|
1423
|
+
directories.push(result.directory);
|
|
1424
|
+
}
|
|
1425
|
+
if (directories.length > 0)
|
|
1426
|
+
await publishSessionWork(directories, "settled");
|
|
1427
|
+
}
|
|
1428
|
+
async function runPass(directory) {
|
|
1429
|
+
hydrateShards();
|
|
1430
|
+
const status = statusFor(directory);
|
|
1431
|
+
status.refreshing = true;
|
|
1432
|
+
const startedAt = now();
|
|
1433
|
+
const generation = resetGeneration;
|
|
1434
|
+
const previous = coverageFor(directory);
|
|
1435
|
+
const inventory = previous?.fullInventoryCompletedAt === undefined || startedAt - previous.fullInventoryCompletedAt > INVENTORY_MIN_INTERVAL_MS;
|
|
1436
|
+
try {
|
|
1437
|
+
const listing = await listSessions(client, inventory || previous?.recentCatchUpAt === undefined ? { directory } : { directory, fromMs: previous.recentCatchUpAt });
|
|
1438
|
+
if (generation !== resetGeneration) {
|
|
1439
|
+
status.refreshing = true;
|
|
1440
|
+
return;
|
|
1441
|
+
}
|
|
1442
|
+
rememberTombstones();
|
|
1443
|
+
const known = [];
|
|
1444
|
+
if (inventory) {
|
|
1445
|
+
for (const entry of index.values()) {
|
|
1446
|
+
if (tombstones.has(entry.sessionID))
|
|
1447
|
+
continue;
|
|
1448
|
+
if (!matchesScope(entry.directory, directory))
|
|
1449
|
+
continue;
|
|
1450
|
+
known.push(entry.sessionID);
|
|
1451
|
+
}
|
|
1452
|
+
}
|
|
1453
|
+
const listed = new Set;
|
|
1454
|
+
const queue = [];
|
|
1455
|
+
for (const meta of listing.sessions) {
|
|
1456
|
+
listed.add(meta.id);
|
|
1457
|
+
if (tombstones.has(meta.id)) {
|
|
1458
|
+
forgetSession(meta.id);
|
|
1459
|
+
continue;
|
|
1460
|
+
}
|
|
1461
|
+
const existing = records3.get(meta.id);
|
|
1462
|
+
if (existing !== undefined && existing.signature === signatureFor(meta))
|
|
1463
|
+
continue;
|
|
1464
|
+
queue.push(meta);
|
|
1465
|
+
}
|
|
1466
|
+
if (inventory)
|
|
1467
|
+
await verifyInventory(listed, known);
|
|
1468
|
+
const requeue = [];
|
|
1469
|
+
const abandoned = await drain(directory, queue, (meta) => {
|
|
1470
|
+
if (!requeue.some((item) => item.id === meta.id))
|
|
1471
|
+
requeue.push(meta);
|
|
1472
|
+
});
|
|
1473
|
+
if (abandoned) {
|
|
1474
|
+
cancelPublish(directory);
|
|
1475
|
+
return;
|
|
1476
|
+
}
|
|
1477
|
+
const abandonedAgain = await drain(directory, requeue, () => {
|
|
1478
|
+
});
|
|
1479
|
+
if (abandonedAgain) {
|
|
1480
|
+
cancelPublish(directory);
|
|
1481
|
+
return;
|
|
1482
|
+
}
|
|
1483
|
+
if (generation !== resetGeneration) {
|
|
1484
|
+
status.refreshing = true;
|
|
1485
|
+
return;
|
|
1486
|
+
}
|
|
1487
|
+
await flushRecords();
|
|
1488
|
+
if (generation !== resetGeneration) {
|
|
1489
|
+
status.refreshing = true;
|
|
1490
|
+
return;
|
|
1491
|
+
}
|
|
1492
|
+
await commitCoverage(directory, startedAt, inventory, previous);
|
|
1493
|
+
if (generation !== resetGeneration) {
|
|
1494
|
+
status.refreshing = true;
|
|
1495
|
+
return;
|
|
1496
|
+
}
|
|
1497
|
+
status.refreshing = false;
|
|
1498
|
+
status.failed = false;
|
|
1499
|
+
await publishReady(directory);
|
|
1500
|
+
} catch {
|
|
1501
|
+
if (generation !== resetGeneration) {
|
|
1502
|
+
status.refreshing = true;
|
|
1503
|
+
return;
|
|
1504
|
+
}
|
|
1505
|
+
status.refreshing = true;
|
|
1506
|
+
status.failed = true;
|
|
1507
|
+
cancelPublish(directory);
|
|
1508
|
+
publishViews(directory, "failure");
|
|
1509
|
+
}
|
|
1510
|
+
}
|
|
1511
|
+
function ensurePass(directory) {
|
|
1512
|
+
const key = directoryKeyOf(directory);
|
|
1513
|
+
const slot = passes.get(key);
|
|
1514
|
+
if (slot?.inFlight === true) {
|
|
1515
|
+
slot.queued = true;
|
|
1516
|
+
return;
|
|
1517
|
+
}
|
|
1518
|
+
const next = { inFlight: true, queued: false };
|
|
1519
|
+
passes.set(key, next);
|
|
1520
|
+
runPass(directory).finally(() => {
|
|
1521
|
+
next.inFlight = false;
|
|
1522
|
+
if (next.queued) {
|
|
1523
|
+
next.queued = false;
|
|
1524
|
+
ensurePass(directory);
|
|
1525
|
+
}
|
|
1526
|
+
});
|
|
1527
|
+
}
|
|
1528
|
+
function schedulePass(directory) {
|
|
1529
|
+
if (holds === 0)
|
|
1530
|
+
return;
|
|
1531
|
+
Promise.resolve().then(() => {
|
|
1532
|
+
if (holds === 0 || !requestedDirectories().some((requested) => requested === directory))
|
|
1533
|
+
return;
|
|
1534
|
+
ensurePass(directory);
|
|
1535
|
+
});
|
|
1536
|
+
}
|
|
1537
|
+
function startTimers() {
|
|
1538
|
+
if (timerCancel !== undefined)
|
|
1539
|
+
return;
|
|
1540
|
+
timerCancel = deps.setTimer(() => {
|
|
1541
|
+
if (holds === 0)
|
|
1542
|
+
return;
|
|
1543
|
+
for (const directory of requestedDirectories())
|
|
1544
|
+
ensurePass(directory);
|
|
1545
|
+
}, RECENT_CATCHUP_MS);
|
|
1546
|
+
auditCancel = deps.setTimer(() => {
|
|
1547
|
+
runAudit().catch(() => {
|
|
1548
|
+
});
|
|
1549
|
+
}, AUDIT_INTERVAL_MS);
|
|
1550
|
+
scheduleDirtyFlush();
|
|
1551
|
+
for (const directory of requestedDirectories())
|
|
1552
|
+
schedulePass(directory);
|
|
1553
|
+
}
|
|
1554
|
+
function stopTimers() {
|
|
1555
|
+
cancelPublications();
|
|
1556
|
+
burstCancel?.();
|
|
1557
|
+
burstCancel = undefined;
|
|
1558
|
+
burstStartedAt = undefined;
|
|
1559
|
+
if (auditCancel !== undefined) {
|
|
1560
|
+
auditCancel();
|
|
1561
|
+
auditCancel = undefined;
|
|
1562
|
+
}
|
|
1563
|
+
if (timerCancel !== undefined) {
|
|
1564
|
+
timerCancel();
|
|
1565
|
+
timerCancel = undefined;
|
|
1566
|
+
}
|
|
1567
|
+
}
|
|
1568
|
+
function view(request) {
|
|
1569
|
+
const key = viewKeyOf(request);
|
|
1570
|
+
const existing = views.get(key);
|
|
1571
|
+
if (existing !== undefined)
|
|
1572
|
+
return existing.accessor;
|
|
1573
|
+
const snapshot = deps.repository.readViewSnapshot(request.directory, request.range);
|
|
1574
|
+
const lastCheckedAt = snapshot?.lastCheckedAt;
|
|
1575
|
+
hydrateShards();
|
|
1576
|
+
const [state, setState] = createSignal(buildState(request, snapshot === undefined ? "loading" : "cached", lastCheckedAt, true, false));
|
|
1577
|
+
views.set(key, { request, accessor: state, publish: setState, lastCheckedAt });
|
|
1578
|
+
schedulePass(request.directory);
|
|
1579
|
+
return state;
|
|
1580
|
+
}
|
|
1581
|
+
function hold() {
|
|
1582
|
+
holds += 1;
|
|
1583
|
+
if (holds === 1)
|
|
1584
|
+
startTimers();
|
|
1585
|
+
let released = false;
|
|
1586
|
+
return () => {
|
|
1587
|
+
if (released)
|
|
1588
|
+
return;
|
|
1589
|
+
released = true;
|
|
1590
|
+
holds -= 1;
|
|
1591
|
+
if (holds === 0)
|
|
1592
|
+
stopTimers();
|
|
1593
|
+
};
|
|
1594
|
+
}
|
|
1595
|
+
function refreshNow() {
|
|
1596
|
+
for (const directory of requestedDirectories())
|
|
1597
|
+
ensurePass(directory);
|
|
1598
|
+
}
|
|
1599
|
+
async function reset() {
|
|
1600
|
+
resetGeneration += 1;
|
|
1601
|
+
cancelPublications();
|
|
1602
|
+
burstCancel?.();
|
|
1603
|
+
burstCancel = undefined;
|
|
1604
|
+
burstStartedAt = undefined;
|
|
1605
|
+
dirty.clear();
|
|
1606
|
+
records3.clear();
|
|
1607
|
+
index.clear();
|
|
1608
|
+
tombstones.clear();
|
|
1609
|
+
coverage.clear();
|
|
1610
|
+
pendingRecords = [];
|
|
1611
|
+
widgetPublished = false;
|
|
1612
|
+
setWidgetState({ status: "loading", rows: [], stale: false });
|
|
1613
|
+
for (const status of statuses.values()) {
|
|
1614
|
+
status.refreshing = true;
|
|
1615
|
+
status.failed = false;
|
|
1616
|
+
status.publishedAt = undefined;
|
|
1617
|
+
}
|
|
1618
|
+
for (const entry of views.values()) {
|
|
1619
|
+
entry.lastCheckedAt = undefined;
|
|
1620
|
+
entry.publish(buildState(entry.request, "loading", undefined, true, false));
|
|
1621
|
+
}
|
|
1622
|
+
try {
|
|
1623
|
+
await flushInFlight;
|
|
1624
|
+
await deps.repository.clear();
|
|
1625
|
+
} catch {
|
|
1626
|
+
persistence = "unavailable";
|
|
1627
|
+
}
|
|
1628
|
+
for (const directory of requestedDirectories())
|
|
1629
|
+
ensurePass(directory);
|
|
1630
|
+
}
|
|
1631
|
+
function subscribeToEvents() {
|
|
1632
|
+
deps.subscribeEvents((event) => {
|
|
1633
|
+
const sessionID = event.data?.sessionID;
|
|
1634
|
+
if (typeof sessionID !== "string" || sessionID.length === 0)
|
|
1635
|
+
return;
|
|
1636
|
+
if (event.type === DELETED_EVENT_TYPE) {
|
|
1637
|
+
deleteSession(sessionID).catch(() => {
|
|
1638
|
+
});
|
|
1639
|
+
return;
|
|
1640
|
+
}
|
|
1641
|
+
if (!DIRTY_EVENT_TYPES.has(event.type))
|
|
1642
|
+
return;
|
|
1643
|
+
markDirty(sessionID);
|
|
1644
|
+
});
|
|
1645
|
+
}
|
|
1646
|
+
subscribeToEvents();
|
|
1647
|
+
return { view, widget: () => widgetState, hold, refreshNow, reset };
|
|
1648
|
+
}
|
|
1649
|
+
var DIRTY_DEBOUNCE_MS = 250;
|
|
1650
|
+
var MAX_SCHEDULE_DELAY_MS = 1000;
|
|
1651
|
+
var PUBLISH_INTERVAL_MS = 250;
|
|
1652
|
+
var RECENT_CATCHUP_MS = 60000;
|
|
1653
|
+
var INVENTORY_MIN_INTERVAL_MS = 600000;
|
|
1654
|
+
var AUDIT_INTERVAL_MS = 60000;
|
|
1655
|
+
var AUDIT_BATCH_SESSIONS = 20;
|
|
1656
|
+
var DIRTY_EVENT_TYPES = new Set([
|
|
1657
|
+
"session.step.ended",
|
|
1658
|
+
"session.step.failed",
|
|
1659
|
+
"session.execution.succeeded",
|
|
1660
|
+
"session.execution.failed",
|
|
1661
|
+
"session.execution.interrupted",
|
|
1662
|
+
"session.created",
|
|
1663
|
+
"session.forked",
|
|
1664
|
+
"session.moved",
|
|
1665
|
+
"session.revert.staged",
|
|
1666
|
+
"session.revert.committed",
|
|
1667
|
+
"session.compaction.ended",
|
|
1668
|
+
"session.compaction.failed",
|
|
1669
|
+
"session.usage.recorded"
|
|
1670
|
+
]);
|
|
1671
|
+
var DELETED_EVENT_TYPE = "session.deleted";
|
|
1672
|
+
var viewKeyOf = (request) => JSON.stringify([request.directory, request.range]);
|
|
1673
|
+
var directoryKeyOf = (directory) => JSON.stringify(directory ?? null);
|
|
1674
|
+
|
|
1675
|
+
// src/page/tokscope.tsx
|
|
1676
|
+
import {effect as _$effect5} from "@opentui/solid";
|
|
1677
|
+
import {insertNode as _$insertNode5} from "@opentui/solid";
|
|
1678
|
+
import {insert as _$insert5} from "@opentui/solid";
|
|
1679
|
+
import {createComponent as _$createComponent3} from "@opentui/solid";
|
|
1680
|
+
import {setProp as _$setProp5} from "@opentui/solid";
|
|
1681
|
+
import {createElement as _$createElement5} from "@opentui/solid";
|
|
1682
|
+
import {useTerminalDimensions} from "@opentui/solid";
|
|
1683
|
+
import {createEffect, createMemo as createMemo2, createSignal as createSignal2, Match, Show as Show3, Switch} from "solid-js";
|
|
1684
|
+
|
|
1685
|
+
// src/format.ts
|
|
1686
|
+
function formatRate(median2) {
|
|
1687
|
+
return `${median2.toFixed(1)} tok/s`;
|
|
1688
|
+
}
|
|
1689
|
+
function formatDayLabel(date) {
|
|
1690
|
+
const [year, month, day] = date.split("-").map(Number);
|
|
1691
|
+
return new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric" }).format(new Date(year, month - 1, day));
|
|
1692
|
+
}
|
|
1693
|
+
function formatCoverage(measured, unavailable) {
|
|
1694
|
+
return unavailable > 0 ? `${measured} measured calls; ${unavailable} unavailable` : `${measured} measured calls`;
|
|
1695
|
+
}
|
|
1696
|
+
function formatHm(ms) {
|
|
1697
|
+
const date = new Date(ms);
|
|
1698
|
+
return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
|
|
1699
|
+
}
|
|
1700
|
+
function modelDisplayName(models, providerID, modelID) {
|
|
1701
|
+
const match = models?.find((model) => model.id === modelID && model.providerID === providerID);
|
|
1702
|
+
return match?.name ?? `${providerID}/${modelID}`;
|
|
1703
|
+
}
|
|
1704
|
+
|
|
1705
|
+
// src/page/header.tsx
|
|
1706
|
+
import {effect as _$effect} from "@opentui/solid";
|
|
1707
|
+
import {insert as _$insert} from "@opentui/solid";
|
|
1708
|
+
import {createTextNode as _$createTextNode} from "@opentui/solid";
|
|
1709
|
+
import {insertNode as _$insertNode} from "@opentui/solid";
|
|
1710
|
+
import {setProp as _$setProp} from "@opentui/solid";
|
|
1711
|
+
import {createElement as _$createElement} from "@opentui/solid";
|
|
1712
|
+
import {TextAttributes} from "@opentui/core";
|
|
1713
|
+
function scopeLabel(scope) {
|
|
1714
|
+
return scope === "project" ? "current project" : "all projects";
|
|
1715
|
+
}
|
|
1716
|
+
function rangeLabel(range) {
|
|
1717
|
+
switch (range) {
|
|
1718
|
+
case "last7":
|
|
1719
|
+
return "last 7 days";
|
|
1720
|
+
case "last30":
|
|
1721
|
+
return "last 30 days";
|
|
1722
|
+
case "last90":
|
|
1723
|
+
return "last 90 days";
|
|
1724
|
+
case "all":
|
|
1725
|
+
return "all history";
|
|
1726
|
+
}
|
|
1727
|
+
}
|
|
1728
|
+
function reasoningLabel(reasoning) {
|
|
1729
|
+
if (reasoning === "all")
|
|
1730
|
+
return "all settings";
|
|
1731
|
+
if (reasoning === "unknown")
|
|
1732
|
+
return "unknown";
|
|
1733
|
+
return reasoning;
|
|
1734
|
+
}
|
|
1735
|
+
function Header(props) {
|
|
1736
|
+
const theme = props.context.theme;
|
|
1737
|
+
return (() => {
|
|
1738
|
+
var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$4 = _$createElement("text"), _el$5 = _$createTextNode(`\xB7 `), _el$6 = _$createTextNode(` \xB7 `), _el$7 = _$createTextNode(` \xB7 reasoning: `);
|
|
1739
|
+
_$insertNode(_el$, _el$2);
|
|
1740
|
+
_$insertNode(_el$, _el$4);
|
|
1741
|
+
_$setProp(_el$, "flexDirection", "row");
|
|
1742
|
+
_$setProp(_el$, "gap", 1);
|
|
1743
|
+
_$insertNode(_el$2, _$createTextNode(`Tokscope`));
|
|
1744
|
+
_$insertNode(_el$4, _el$5);
|
|
1745
|
+
_$insertNode(_el$4, _el$6);
|
|
1746
|
+
_$insertNode(_el$4, _el$7);
|
|
1747
|
+
_$insert(_el$4, () => scopeLabel(props.filters.scope), _el$6);
|
|
1748
|
+
_$insert(_el$4, () => rangeLabel(props.filters.range), _el$7);
|
|
1749
|
+
_$insert(_el$4, () => reasoningLabel(props.filters.reasoning), null);
|
|
1750
|
+
_$effect((_p$) => {
|
|
1751
|
+
var _v$ = theme.text.base, _v$2 = TextAttributes.BOLD, _v$3 = theme.text.muted;
|
|
1752
|
+
_v$ !== _p$.e && (_p$.e = _$setProp(_el$2, "fg", _v$, _p$.e));
|
|
1753
|
+
_v$2 !== _p$.t && (_p$.t = _$setProp(_el$2, "attributes", _v$2, _p$.t));
|
|
1754
|
+
_v$3 !== _p$.a && (_p$.a = _$setProp(_el$4, "fg", _v$3, _p$.a));
|
|
1755
|
+
return _p$;
|
|
1756
|
+
}, {
|
|
1757
|
+
e: undefined,
|
|
1758
|
+
t: undefined,
|
|
1759
|
+
a: undefined
|
|
1760
|
+
});
|
|
1761
|
+
return _el$;
|
|
1762
|
+
})();
|
|
1763
|
+
}
|
|
1764
|
+
|
|
1765
|
+
// src/page/heading-status.ts
|
|
1766
|
+
var withPersistence = function(message, view) {
|
|
1767
|
+
return view.persistence === "unavailable" ? message + NOT_SAVED_SUFFIX : message;
|
|
1768
|
+
};
|
|
1769
|
+
var hasData = function(view) {
|
|
1770
|
+
return view.samples.length > 0 || view.unavailable.length > 0;
|
|
1771
|
+
};
|
|
1772
|
+
function partialMessage(view) {
|
|
1773
|
+
return withPersistence("History loading \u2014 results incomplete", view);
|
|
1774
|
+
}
|
|
1775
|
+
function cachedMessage(view) {
|
|
1776
|
+
const base = view.lastCheckedAt === undefined ? "Cached \xB7 refreshing\u2026" : `Cached \xB7 last checked ${formatHm(view.lastCheckedAt)} \xB7 refreshing\u2026`;
|
|
1777
|
+
return withPersistence(base, view);
|
|
1778
|
+
}
|
|
1779
|
+
function refreshFailedMessage(view) {
|
|
1780
|
+
return withPersistence("Refresh failed \u2014 showing cached results", view);
|
|
1781
|
+
}
|
|
1782
|
+
function bannerMessage(view) {
|
|
1783
|
+
switch (view.kind) {
|
|
1784
|
+
case "partial":
|
|
1785
|
+
return partialMessage(view);
|
|
1786
|
+
case "cached":
|
|
1787
|
+
return cachedMessage(view);
|
|
1788
|
+
case "error":
|
|
1789
|
+
return hasData(view) ? refreshFailedMessage(view) : undefined;
|
|
1790
|
+
default:
|
|
1791
|
+
return;
|
|
1792
|
+
}
|
|
1793
|
+
}
|
|
1794
|
+
function footerStatusSuffix(view) {
|
|
1795
|
+
switch (view.kind) {
|
|
1796
|
+
case "ready":
|
|
1797
|
+
return view.lastCheckedAt === undefined ? SHARED_CACHE_SUFFIX : ` \xB7 checked ${formatHm(view.lastCheckedAt)}${SHARED_CACHE_SUFFIX}`;
|
|
1798
|
+
case "cached":
|
|
1799
|
+
return SHARED_CACHE_SUFFIX;
|
|
1800
|
+
default:
|
|
1801
|
+
return "";
|
|
1802
|
+
}
|
|
1803
|
+
}
|
|
1804
|
+
var NOT_SAVED_SUFFIX = " \xB7 Cache not saved";
|
|
1805
|
+
var SHARED_CACHE_SUFFIX = " \xB7 cache: shared";
|
|
1806
|
+
|
|
1807
|
+
// src/page/selection.ts
|
|
1808
|
+
function nextSelection(keys, current, delta) {
|
|
1809
|
+
if (keys.length === 0)
|
|
1810
|
+
return;
|
|
1811
|
+
if (current === undefined)
|
|
1812
|
+
return keys[0];
|
|
1813
|
+
const index = keys.indexOf(current);
|
|
1814
|
+
if (index === -1)
|
|
1815
|
+
return keys[0];
|
|
1816
|
+
const next = Math.max(0, Math.min(index + delta, keys.length - 1));
|
|
1817
|
+
return keys[next];
|
|
1818
|
+
}
|
|
1819
|
+
|
|
1820
|
+
// src/page/state.ts
|
|
1821
|
+
function pickPageState(result, samples, unavailable) {
|
|
1822
|
+
if (result === undefined)
|
|
1823
|
+
return "loading";
|
|
1824
|
+
if (result.error !== undefined)
|
|
1825
|
+
return "error";
|
|
1826
|
+
if (samples.length > 0)
|
|
1827
|
+
return "ready";
|
|
1828
|
+
if (unavailable.length > 0)
|
|
1829
|
+
return "unmeasurable";
|
|
1830
|
+
return "empty";
|
|
1831
|
+
}
|
|
1832
|
+
function pickViewPageState(view) {
|
|
1833
|
+
if (view.kind === "loading")
|
|
1834
|
+
return "loading";
|
|
1835
|
+
const content = pickPageState({ error: undefined }, view.samples, view.unavailable);
|
|
1836
|
+
if (view.kind === "error" && content === "empty")
|
|
1837
|
+
return "error";
|
|
1838
|
+
return content;
|
|
1839
|
+
}
|
|
1840
|
+
|
|
1841
|
+
// src/page/states.tsx
|
|
1842
|
+
import {createTextNode as _$createTextNode2} from "@opentui/solid";
|
|
1843
|
+
import {insertNode as _$insertNode2} from "@opentui/solid";
|
|
1844
|
+
import {setProp as _$setProp2} from "@opentui/solid";
|
|
1845
|
+
import {effect as _$effect2} from "@opentui/solid";
|
|
1846
|
+
import {insert as _$insert2} from "@opentui/solid";
|
|
1847
|
+
import {createElement as _$createElement2} from "@opentui/solid";
|
|
1848
|
+
function LoadingState(props) {
|
|
1849
|
+
const theme = props.context.theme;
|
|
1850
|
+
const detail = () => props.sessions > 0 ? ` ${props.sessions} sessions` : "";
|
|
1851
|
+
return (() => {
|
|
1852
|
+
var _el$ = _$createElement2("text");
|
|
1853
|
+
_$insert2(_el$, () => `Scanning history\u2026${detail()}`);
|
|
1854
|
+
_$effect2((_$p) => _$setProp2(_el$, "fg", theme.text.muted, _$p));
|
|
1855
|
+
return _el$;
|
|
1856
|
+
})();
|
|
1857
|
+
}
|
|
1858
|
+
function ErrorState(props) {
|
|
1859
|
+
const theme = props.context.theme;
|
|
1860
|
+
return (() => {
|
|
1861
|
+
var _el$2 = _$createElement2("box"), _el$3 = _$createElement2("text"), _el$5 = _$createElement2("text");
|
|
1862
|
+
_$insertNode2(_el$2, _el$3);
|
|
1863
|
+
_$insertNode2(_el$2, _el$5);
|
|
1864
|
+
_$setProp2(_el$2, "flexDirection", "column");
|
|
1865
|
+
_$setProp2(_el$2, "gap", 1);
|
|
1866
|
+
_$insertNode2(_el$3, _$createTextNode2(`Could not read history`));
|
|
1867
|
+
_$insertNode2(_el$5, _$createTextNode2(`Press enter to retry.`));
|
|
1868
|
+
_$effect2((_p$) => {
|
|
1869
|
+
var _v$ = theme.text.feedback.error.base, _v$2 = theme.text.muted;
|
|
1870
|
+
_v$ !== _p$.e && (_p$.e = _$setProp2(_el$3, "fg", _v$, _p$.e));
|
|
1871
|
+
_v$2 !== _p$.t && (_p$.t = _$setProp2(_el$5, "fg", _v$2, _p$.t));
|
|
1872
|
+
return _p$;
|
|
1873
|
+
}, {
|
|
1874
|
+
e: undefined,
|
|
1875
|
+
t: undefined
|
|
1876
|
+
});
|
|
1877
|
+
return _el$2;
|
|
1878
|
+
})();
|
|
1879
|
+
}
|
|
1880
|
+
function EmptyState(props) {
|
|
1881
|
+
const theme = props.context.theme;
|
|
1882
|
+
return (() => {
|
|
1883
|
+
var _el$7 = _$createElement2("box"), _el$8 = _$createElement2("text"), _el$9 = _$createElement2("text");
|
|
1884
|
+
_$insertNode2(_el$7, _el$8);
|
|
1885
|
+
_$insertNode2(_el$7, _el$9);
|
|
1886
|
+
_$setProp2(_el$7, "flexDirection", "column");
|
|
1887
|
+
_$setProp2(_el$7, "gap", 1);
|
|
1888
|
+
_$insert2(_el$8, () => `No history in ${scopeLabel(props.filters.scope)} \xB7 ${rangeLabel(props.filters.range)} \xB7 reasoning: ${reasoningLabel(props.filters.reasoning)}.`);
|
|
1889
|
+
_$insertNode2(_el$9, _$createTextNode2(`Try a wider time range or all projects.`));
|
|
1890
|
+
_$effect2((_p$) => {
|
|
1891
|
+
var _v$3 = theme.text.muted, _v$4 = theme.text.muted;
|
|
1892
|
+
_v$3 !== _p$.e && (_p$.e = _$setProp2(_el$8, "fg", _v$3, _p$.e));
|
|
1893
|
+
_v$4 !== _p$.t && (_p$.t = _$setProp2(_el$9, "fg", _v$4, _p$.t));
|
|
1894
|
+
return _p$;
|
|
1895
|
+
}, {
|
|
1896
|
+
e: undefined,
|
|
1897
|
+
t: undefined
|
|
1898
|
+
});
|
|
1899
|
+
return _el$7;
|
|
1900
|
+
})();
|
|
1901
|
+
}
|
|
1902
|
+
function UnmeasurableState(props) {
|
|
1903
|
+
const theme = props.context.theme;
|
|
1904
|
+
return (() => {
|
|
1905
|
+
var _el$1 = _$createElement2("box"), _el$10 = _$createElement2("text"), _el$12 = _$createElement2("text");
|
|
1906
|
+
_$insertNode2(_el$1, _el$10);
|
|
1907
|
+
_$insertNode2(_el$1, _el$12);
|
|
1908
|
+
_$setProp2(_el$1, "flexDirection", "column");
|
|
1909
|
+
_$setProp2(_el$1, "gap", 1);
|
|
1910
|
+
_$insertNode2(_el$10, _$createTextNode2(`History exists, but none of it is measurable.`));
|
|
1911
|
+
_$insertNode2(_el$12, _$createTextNode2(`Completed requests are missing the historical timing or token data needed for speed.`));
|
|
1912
|
+
_$effect2((_p$) => {
|
|
1913
|
+
var _v$5 = theme.text.muted, _v$6 = theme.text.muted;
|
|
1914
|
+
_v$5 !== _p$.e && (_p$.e = _$setProp2(_el$10, "fg", _v$5, _p$.e));
|
|
1915
|
+
_v$6 !== _p$.t && (_p$.t = _$setProp2(_el$12, "fg", _v$6, _p$.t));
|
|
1916
|
+
return _p$;
|
|
1917
|
+
}, {
|
|
1918
|
+
e: undefined,
|
|
1919
|
+
t: undefined
|
|
1920
|
+
});
|
|
1921
|
+
return _el$1;
|
|
1922
|
+
})();
|
|
1923
|
+
}
|
|
1924
|
+
|
|
1925
|
+
// src/page/table.tsx
|
|
1926
|
+
import {insertNode as _$insertNode3} from "@opentui/solid";
|
|
1927
|
+
import {effect as _$effect3} from "@opentui/solid";
|
|
1928
|
+
import {createComponent as _$createComponent} from "@opentui/solid";
|
|
1929
|
+
import {insert as _$insert3} from "@opentui/solid";
|
|
1930
|
+
import {setProp as _$setProp3} from "@opentui/solid";
|
|
1931
|
+
import {createElement as _$createElement3} from "@opentui/solid";
|
|
1932
|
+
import {TextAttributes as TextAttributes2} from "@opentui/core";
|
|
1933
|
+
import {For, Show} from "solid-js";
|
|
1934
|
+
var pad = function(value, width) {
|
|
1935
|
+
if (value.length <= width)
|
|
1936
|
+
return value.padEnd(width);
|
|
1937
|
+
return value.slice(0, Math.max(1, width - 1)) + "\u2026";
|
|
1938
|
+
};
|
|
1939
|
+
function ComparisonTable(props) {
|
|
1940
|
+
const theme = props.context.theme;
|
|
1941
|
+
const showProvider = () => props.width >= 60;
|
|
1942
|
+
const modelWidth = () => Math.max(12, props.width - MARKER_WIDTH - MEDIAN_WIDTH - CALLS_WIDTH - GAP * (showProvider() ? 3 : 2) - (showProvider() ? PROVIDER_WIDTH : 0));
|
|
1943
|
+
const models = () => props.context.data.location.model.list();
|
|
1944
|
+
const providers = () => props.context.data.location.provider.list();
|
|
1945
|
+
const modelName = (row) => modelDisplayName(models(), row.providerID, row.modelID);
|
|
1946
|
+
const providerName = (row) => providers()?.find((provider) => provider.id === row.providerID)?.name ?? row.providerID;
|
|
1947
|
+
const selectedIndex = () => Math.max(0, props.rows.findIndex((row) => row.key === props.selectedKey));
|
|
1948
|
+
const visible = () => {
|
|
1949
|
+
const window = windowRange(props.rows.length, selectedIndex(), Math.max(1, props.height));
|
|
1950
|
+
return props.rows.slice(window.start, window.end);
|
|
1951
|
+
};
|
|
1952
|
+
const line = (row, selected) => {
|
|
1953
|
+
const median2 = row.unavailable || row.median === null ? "unavailable" : formatRate(row.median);
|
|
1954
|
+
const cells = [pad(modelName(row), modelWidth()), ...showProvider() ? [pad(providerName(row), PROVIDER_WIDTH)] : [], pad(median2, MEDIAN_WIDTH), pad(String(row.calls), CALLS_WIDTH)];
|
|
1955
|
+
return `${selected ? "\u203A " : " "}${cells.join(" ".repeat(GAP))}`;
|
|
1956
|
+
};
|
|
1957
|
+
const header2 = () => {
|
|
1958
|
+
const cells = [pad("Model", modelWidth()), ...showProvider() ? [pad("Provider", PROVIDER_WIDTH)] : [], pad("Median tok/s", MEDIAN_WIDTH), pad("Calls", CALLS_WIDTH)];
|
|
1959
|
+
return ` ${cells.join(" ".repeat(GAP))}`;
|
|
1960
|
+
};
|
|
1961
|
+
return (() => {
|
|
1962
|
+
var _el$ = _$createElement3("box"), _el$2 = _$createElement3("text");
|
|
1963
|
+
_$insertNode3(_el$, _el$2);
|
|
1964
|
+
_$setProp3(_el$, "flexDirection", "column");
|
|
1965
|
+
_$insert3(_el$2, header2);
|
|
1966
|
+
_$insert3(_el$, _$createComponent(For, {
|
|
1967
|
+
get each() {
|
|
1968
|
+
return visible();
|
|
1969
|
+
},
|
|
1970
|
+
children: (row) => (() => {
|
|
1971
|
+
var _el$4 = _$createElement3("text");
|
|
1972
|
+
_$setProp3(_el$4, "selectable", false);
|
|
1973
|
+
_$insert3(_el$4, () => line(row, row.key === props.selectedKey));
|
|
1974
|
+
_$effect3((_p$) => {
|
|
1975
|
+
var _v$3 = row.key === props.selectedKey ? theme.text.base : theme.text.muted, _v$4 = row.key === props.selectedKey ? TextAttributes2.BOLD : undefined;
|
|
1976
|
+
_v$3 !== _p$.e && (_p$.e = _$setProp3(_el$4, "fg", _v$3, _p$.e));
|
|
1977
|
+
_v$4 !== _p$.t && (_p$.t = _$setProp3(_el$4, "attributes", _v$4, _p$.t));
|
|
1978
|
+
return _p$;
|
|
1979
|
+
}, {
|
|
1980
|
+
e: undefined,
|
|
1981
|
+
t: undefined
|
|
1982
|
+
});
|
|
1983
|
+
return _el$4;
|
|
1984
|
+
})()
|
|
1985
|
+
}), null);
|
|
1986
|
+
_$insert3(_el$, _$createComponent(Show, {
|
|
1987
|
+
get when() {
|
|
1988
|
+
return props.rows.length > visible().length;
|
|
1989
|
+
},
|
|
1990
|
+
get children() {
|
|
1991
|
+
var _el$3 = _$createElement3("text");
|
|
1992
|
+
_$insert3(_el$3, () => ` \u2026 ${props.rows.length - visible().length} more rows`);
|
|
1993
|
+
_$effect3((_$p) => _$setProp3(_el$3, "fg", theme.text.muted, _$p));
|
|
1994
|
+
return _el$3;
|
|
1995
|
+
}
|
|
1996
|
+
}), null);
|
|
1997
|
+
_$effect3((_p$) => {
|
|
1998
|
+
var _v$ = theme.text.muted, _v$2 = TextAttributes2.BOLD;
|
|
1999
|
+
_v$ !== _p$.e && (_p$.e = _$setProp3(_el$2, "fg", _v$, _p$.e));
|
|
2000
|
+
_v$2 !== _p$.t && (_p$.t = _$setProp3(_el$2, "attributes", _v$2, _p$.t));
|
|
2001
|
+
return _p$;
|
|
2002
|
+
}, {
|
|
2003
|
+
e: undefined,
|
|
2004
|
+
t: undefined
|
|
2005
|
+
});
|
|
2006
|
+
return _el$;
|
|
2007
|
+
})();
|
|
2008
|
+
}
|
|
2009
|
+
var MARKER_WIDTH = 2;
|
|
2010
|
+
var PROVIDER_WIDTH = 18;
|
|
2011
|
+
var MEDIAN_WIDTH = 13;
|
|
2012
|
+
var CALLS_WIDTH = 5;
|
|
2013
|
+
var GAP = 2;
|
|
2014
|
+
|
|
2015
|
+
// src/page/trend.tsx
|
|
2016
|
+
import {createTextNode as _$createTextNode3} from "@opentui/solid";
|
|
2017
|
+
import {effect as _$effect4} from "@opentui/solid";
|
|
2018
|
+
import {insertNode as _$insertNode4} from "@opentui/solid";
|
|
2019
|
+
import {createComponent as _$createComponent2} from "@opentui/solid";
|
|
2020
|
+
import {insert as _$insert4} from "@opentui/solid";
|
|
2021
|
+
import {setProp as _$setProp4} from "@opentui/solid";
|
|
2022
|
+
import {createElement as _$createElement4} from "@opentui/solid";
|
|
2023
|
+
import {TextAttributes as TextAttributes3} from "@opentui/core";
|
|
2024
|
+
import {For as For2, Show as Show2, createMemo} from "solid-js";
|
|
2025
|
+
|
|
2026
|
+
// src/page/chart.ts
|
|
2027
|
+
function barChar(level, row, rows) {
|
|
2028
|
+
if (level === null)
|
|
2029
|
+
return " ";
|
|
2030
|
+
if (level > row + 1)
|
|
2031
|
+
return "\u2588";
|
|
2032
|
+
if (level !== row + 1)
|
|
2033
|
+
return " ";
|
|
2034
|
+
const index = Math.min(7, Math.max(0, Math.ceil(level / rows * 8) - 1));
|
|
2035
|
+
return BAR_CHARS[index];
|
|
2036
|
+
}
|
|
2037
|
+
function axisLine(visible, selected) {
|
|
2038
|
+
if (visible.length === 0)
|
|
2039
|
+
return "";
|
|
2040
|
+
const width = visible.length * 2;
|
|
2041
|
+
const chars = new Array(width).fill(" ");
|
|
2042
|
+
const placed = [];
|
|
2043
|
+
const put = (label, at) => {
|
|
2044
|
+
const start = Math.max(0, Math.min(at, width - label.length));
|
|
2045
|
+
const end = start + label.length;
|
|
2046
|
+
if (placed.some(([placedStart, placedEnd]) => start < placedEnd && placedStart < end))
|
|
2047
|
+
return;
|
|
2048
|
+
for (let index = 0;index < label.length && start + index < width; index++)
|
|
2049
|
+
chars[start + index] = label[index];
|
|
2050
|
+
placed.push([start, end]);
|
|
2051
|
+
};
|
|
2052
|
+
const clamped = Math.max(0, Math.min(selected, visible.length - 1));
|
|
2053
|
+
const first = formatDayLabel(visible[0].date);
|
|
2054
|
+
const current = formatDayLabel(visible[clamped].date);
|
|
2055
|
+
const last = formatDayLabel(visible[visible.length - 1].date);
|
|
2056
|
+
put(current, clamped * 2 - Math.floor(current.length / 2));
|
|
2057
|
+
put(first, 0);
|
|
2058
|
+
put(last, width - last.length);
|
|
2059
|
+
return chars.join("").trimEnd();
|
|
2060
|
+
}
|
|
2061
|
+
var PLOT_ROWS = 8;
|
|
2062
|
+
var BAR_CHARS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
|
|
2063
|
+
|
|
2064
|
+
// src/page/trend.tsx
|
|
2065
|
+
function TrendPanel(props) {
|
|
2066
|
+
const theme = props.context.theme;
|
|
2067
|
+
const columns = () => Math.max(1, Math.floor((props.width - 16) / 2));
|
|
2068
|
+
const window = createMemo(() => dayWindow(props.series, props.selectedDay, columns()));
|
|
2069
|
+
const visible = createMemo(() => props.series.slice(window().start, window().end));
|
|
2070
|
+
const levels = createMemo(() => barLevels(visible(), PLOT_ROWS));
|
|
2071
|
+
const selectedIndex = () => Math.max(0, Math.min(props.selectedDay - window().start, Math.max(0, visible().length - 1)));
|
|
2072
|
+
const plotRows = () => Array.from({
|
|
2073
|
+
length: PLOT_ROWS
|
|
2074
|
+
}, (_, index) => PLOT_ROWS - 1 - index);
|
|
2075
|
+
const measurable = () => props.series.some((point) => point.median !== null);
|
|
2076
|
+
const detail = () => {
|
|
2077
|
+
const point = props.series[props.selectedDay];
|
|
2078
|
+
if (point === undefined)
|
|
2079
|
+
return "no measured calls";
|
|
2080
|
+
if (point.median === null)
|
|
2081
|
+
return `${formatDayLabel(point.date)} \xB7 no measured calls`;
|
|
2082
|
+
return `${formatDayLabel(point.date)} \xB7 ${point.median.toFixed(1)} tok/s \xB7 ${point.calls} calls`;
|
|
2083
|
+
};
|
|
2084
|
+
return (() => {
|
|
2085
|
+
var _el$ = _$createElement4("box"), _el$2 = _$createElement4("text");
|
|
2086
|
+
_$insertNode4(_el$, _el$2);
|
|
2087
|
+
_$setProp4(_el$, "flexDirection", "column");
|
|
2088
|
+
_$setProp4(_el$, "gap", 1);
|
|
2089
|
+
_$insert4(_el$2, () => `Trend: ${props.rowLabel} \xB7 ${props.rangeLabel} \xB7 ${props.reasoningLabel}`);
|
|
2090
|
+
_$insert4(_el$, _$createComponent2(Show2, {
|
|
2091
|
+
get when() {
|
|
2092
|
+
return measurable();
|
|
2093
|
+
},
|
|
2094
|
+
get fallback() {
|
|
2095
|
+
return (() => {
|
|
2096
|
+
var _el$6 = _$createElement4("text");
|
|
2097
|
+
_$insertNode4(_el$6, _$createTextNode3(`No measurable trend for this model \u2014 historical timing or token data is unavailable.`));
|
|
2098
|
+
_$effect4((_$p) => _$setProp4(_el$6, "fg", theme.text.muted, _$p));
|
|
2099
|
+
return _el$6;
|
|
2100
|
+
})();
|
|
2101
|
+
},
|
|
2102
|
+
get children() {
|
|
2103
|
+
return [(() => {
|
|
2104
|
+
var _el$3 = _$createElement4("box"), _el$4 = _$createElement4("text");
|
|
2105
|
+
_$insertNode4(_el$3, _el$4);
|
|
2106
|
+
_$setProp4(_el$3, "flexDirection", "column");
|
|
2107
|
+
_$insert4(_el$3, _$createComponent2(For2, {
|
|
2108
|
+
get each() {
|
|
2109
|
+
return plotRows();
|
|
2110
|
+
},
|
|
2111
|
+
children: (row) => (() => {
|
|
2112
|
+
var _el$8 = _$createElement4("box");
|
|
2113
|
+
_$setProp4(_el$8, "flexDirection", "row");
|
|
2114
|
+
_$insert4(_el$8, _$createComponent2(For2, {
|
|
2115
|
+
get each() {
|
|
2116
|
+
return visible();
|
|
2117
|
+
},
|
|
2118
|
+
children: (_, index) => (() => {
|
|
2119
|
+
var _el$9 = _$createElement4("text");
|
|
2120
|
+
_$setProp4(_el$9, "selectable", false);
|
|
2121
|
+
_$insert4(_el$9, () => barChar(levels()[index()], row, PLOT_ROWS) + " ");
|
|
2122
|
+
_$effect4((_$p) => _$setProp4(_el$9, "fg", index() === selectedIndex() ? theme.text.base : theme.text.muted, _$p));
|
|
2123
|
+
return _el$9;
|
|
2124
|
+
})()
|
|
2125
|
+
}));
|
|
2126
|
+
return _el$8;
|
|
2127
|
+
})()
|
|
2128
|
+
}), _el$4);
|
|
2129
|
+
_$insert4(_el$4, () => axisLine(visible(), selectedIndex()));
|
|
2130
|
+
_$effect4((_$p) => _$setProp4(_el$4, "fg", theme.text.muted, _$p));
|
|
2131
|
+
return _el$3;
|
|
2132
|
+
})(), (() => {
|
|
2133
|
+
var _el$5 = _$createElement4("text");
|
|
2134
|
+
_$insert4(_el$5, detail);
|
|
2135
|
+
_$effect4((_$p) => _$setProp4(_el$5, "fg", theme.text.base, _$p));
|
|
2136
|
+
return _el$5;
|
|
2137
|
+
})()];
|
|
2138
|
+
}
|
|
2139
|
+
}), null);
|
|
2140
|
+
_$effect4((_p$) => {
|
|
2141
|
+
var _v$ = theme.text.muted, _v$2 = TextAttributes3.BOLD;
|
|
2142
|
+
_v$ !== _p$.e && (_p$.e = _$setProp4(_el$2, "fg", _v$, _p$.e));
|
|
2143
|
+
_v$2 !== _p$.t && (_p$.t = _$setProp4(_el$2, "attributes", _v$2, _p$.t));
|
|
2144
|
+
return _p$;
|
|
2145
|
+
}, {
|
|
2146
|
+
e: undefined,
|
|
2147
|
+
t: undefined
|
|
2148
|
+
});
|
|
2149
|
+
return _el$;
|
|
2150
|
+
})();
|
|
2151
|
+
}
|
|
2152
|
+
|
|
2153
|
+
// src/page/tokscope.tsx
|
|
2154
|
+
function TokscopePage(props) {
|
|
2155
|
+
const theme = props.context.theme;
|
|
2156
|
+
const dimensions = useTerminalDimensions();
|
|
2157
|
+
props.context.data.location.model.sync();
|
|
2158
|
+
props.context.data.location.provider.sync();
|
|
2159
|
+
const [filters3, setFilters] = createSignal2({
|
|
2160
|
+
...DEFAULT_FILTERS
|
|
2161
|
+
});
|
|
2162
|
+
const [selectedKey, setSelectedKey] = createSignal2(undefined);
|
|
2163
|
+
const [selectedDay, setSelectedDay] = createSignal2(0);
|
|
2164
|
+
const directory = () => props.context.location?.directory ?? props.context.data.location.default().directory;
|
|
2165
|
+
const state2 = () => props.service.view({
|
|
2166
|
+
directory: filters3().scope === "project" ? directory() : undefined,
|
|
2167
|
+
range: filters3().range
|
|
2168
|
+
})();
|
|
2169
|
+
const referenceNow = () => state2().lastCheckedAt ?? Date.now();
|
|
2170
|
+
const filtered = createMemo2(() => applyReasoningFilter(state2().samples, state2().unavailable, filters3().reasoning));
|
|
2171
|
+
const pageState = createMemo2(() => pickViewPageState(state2()));
|
|
2172
|
+
const rows = createMemo2(() => comparisonRows(filtered().samples, filtered().unavailable));
|
|
2173
|
+
createEffect(() => {
|
|
2174
|
+
const list = rows();
|
|
2175
|
+
if (list.some((row) => row.key === selectedKey()))
|
|
2176
|
+
return;
|
|
2177
|
+
setSelectedKey(list[0]?.key);
|
|
2178
|
+
});
|
|
2179
|
+
const moveSelection = (delta) => setSelectedKey(nextSelection(rows().map((row) => row.key), selectedKey(), delta));
|
|
2180
|
+
const selectedRow = createMemo2(() => rows().find((row) => row.key === selectedKey()));
|
|
2181
|
+
const series = createMemo2(() => {
|
|
2182
|
+
const key = selectedKey();
|
|
2183
|
+
if (key === undefined)
|
|
2184
|
+
return [];
|
|
2185
|
+
const nowMs = referenceNow();
|
|
2186
|
+
return dailySeries(filtered().samples, key, rangeStartMs(filters3().range, nowMs), nowMs);
|
|
2187
|
+
});
|
|
2188
|
+
let anchoredKey;
|
|
2189
|
+
createEffect(() => {
|
|
2190
|
+
const key = selectedKey();
|
|
2191
|
+
const points = series();
|
|
2192
|
+
const current = selectedDay();
|
|
2193
|
+
if (key === anchoredKey && current < points.length)
|
|
2194
|
+
return;
|
|
2195
|
+
const last = points.findLastIndex((point) => point.calls > 0);
|
|
2196
|
+
setSelectedDay(last === -1 ? Math.max(0, points.length - 1) : last);
|
|
2197
|
+
anchoredKey = key;
|
|
2198
|
+
});
|
|
2199
|
+
const moveDay = (delta) => setSelectedDay((current) => Math.max(0, Math.min(current + delta, Math.max(0, series().length - 1))));
|
|
2200
|
+
const rowLabel = () => {
|
|
2201
|
+
const row = selectedRow();
|
|
2202
|
+
if (row === undefined)
|
|
2203
|
+
return "No row selected";
|
|
2204
|
+
const name = modelDisplayName(props.context.data.location.model.list(), row.providerID, row.modelID);
|
|
2205
|
+
const provider = props.context.data.location.provider.list()?.find((item) => item.id === row.providerID)?.name ?? row.providerID;
|
|
2206
|
+
return `${name} \xB7 ${provider}`;
|
|
2207
|
+
};
|
|
2208
|
+
const reasoningOptions = () => {
|
|
2209
|
+
const options = [{
|
|
2210
|
+
title: "All settings",
|
|
2211
|
+
value: "all"
|
|
2212
|
+
}];
|
|
2213
|
+
const value = state2();
|
|
2214
|
+
for (const variant of value.variants)
|
|
2215
|
+
options.push({
|
|
2216
|
+
title: variant,
|
|
2217
|
+
value: variant
|
|
2218
|
+
});
|
|
2219
|
+
const hasUnknown = [...value.samples, ...value.unavailable].some((item) => item.variant === undefined);
|
|
2220
|
+
if (hasUnknown)
|
|
2221
|
+
options.push({
|
|
2222
|
+
title: "unknown",
|
|
2223
|
+
value: "unknown"
|
|
2224
|
+
});
|
|
2225
|
+
return options;
|
|
2226
|
+
};
|
|
2227
|
+
const pickScope = async () => {
|
|
2228
|
+
const chosen = await props.context.ui.dialog.select({
|
|
2229
|
+
title: "Scope",
|
|
2230
|
+
current: filters3().scope,
|
|
2231
|
+
options: SCOPE_OPTIONS
|
|
2232
|
+
});
|
|
2233
|
+
if (chosen !== undefined)
|
|
2234
|
+
setFilters((previous) => ({
|
|
2235
|
+
...previous,
|
|
2236
|
+
scope: chosen
|
|
2237
|
+
}));
|
|
2238
|
+
};
|
|
2239
|
+
const pickRange = async () => {
|
|
2240
|
+
const chosen = await props.context.ui.dialog.select({
|
|
2241
|
+
title: "Time range",
|
|
2242
|
+
current: filters3().range,
|
|
2243
|
+
options: RANGE_OPTIONS
|
|
2244
|
+
});
|
|
2245
|
+
if (chosen !== undefined)
|
|
2246
|
+
setFilters((previous) => ({
|
|
2247
|
+
...previous,
|
|
2248
|
+
range: chosen
|
|
2249
|
+
}));
|
|
2250
|
+
};
|
|
2251
|
+
const pickReasoning = async () => {
|
|
2252
|
+
const chosen = await props.context.ui.dialog.select({
|
|
2253
|
+
title: "Reasoning setting",
|
|
2254
|
+
current: filters3().reasoning,
|
|
2255
|
+
options: reasoningOptions()
|
|
2256
|
+
});
|
|
2257
|
+
if (chosen !== undefined)
|
|
2258
|
+
setFilters((previous) => ({
|
|
2259
|
+
...previous,
|
|
2260
|
+
reasoning: chosen
|
|
2261
|
+
}));
|
|
2262
|
+
};
|
|
2263
|
+
props.context.keymap.layer(() => ({
|
|
2264
|
+
commands: [{
|
|
2265
|
+
bind: "escape",
|
|
2266
|
+
title: "back",
|
|
2267
|
+
run: props.onClose
|
|
2268
|
+
}, {
|
|
2269
|
+
bind: "up",
|
|
2270
|
+
title: "previous row",
|
|
2271
|
+
run: () => moveSelection(-1)
|
|
2272
|
+
}, {
|
|
2273
|
+
bind: "down",
|
|
2274
|
+
title: "next row",
|
|
2275
|
+
run: () => moveSelection(1)
|
|
2276
|
+
}, {
|
|
2277
|
+
bind: "k",
|
|
2278
|
+
title: "previous row",
|
|
2279
|
+
run: () => moveSelection(-1)
|
|
2280
|
+
}, {
|
|
2281
|
+
bind: "j",
|
|
2282
|
+
title: "next row",
|
|
2283
|
+
run: () => moveSelection(1)
|
|
2284
|
+
}, {
|
|
2285
|
+
bind: "left",
|
|
2286
|
+
title: "previous day",
|
|
2287
|
+
run: () => moveDay(-1)
|
|
2288
|
+
}, {
|
|
2289
|
+
bind: "right",
|
|
2290
|
+
title: "next day",
|
|
2291
|
+
run: () => moveDay(1)
|
|
2292
|
+
}, {
|
|
2293
|
+
bind: "s",
|
|
2294
|
+
title: "scope",
|
|
2295
|
+
run: pickScope
|
|
2296
|
+
}, {
|
|
2297
|
+
bind: "t",
|
|
2298
|
+
title: "time range",
|
|
2299
|
+
run: pickRange
|
|
2300
|
+
}, {
|
|
2301
|
+
bind: "r",
|
|
2302
|
+
title: "reasoning",
|
|
2303
|
+
run: pickReasoning
|
|
2304
|
+
}, {
|
|
2305
|
+
bind: "enter",
|
|
2306
|
+
title: "retry",
|
|
2307
|
+
run: () => {
|
|
2308
|
+
if (state2().kind === "error")
|
|
2309
|
+
props.service.refreshNow();
|
|
2310
|
+
}
|
|
2311
|
+
}]
|
|
2312
|
+
}));
|
|
2313
|
+
const coverage = () => pageState() === "loading" ? "" : ` \xB7 ${formatCoverage(filtered().samples.length, filtered().unavailable.length)}`;
|
|
2314
|
+
return (() => {
|
|
2315
|
+
var _el$ = _$createElement5("box"), _el$2 = _$createElement5("box"), _el$4 = _$createElement5("text");
|
|
2316
|
+
_$insertNode5(_el$, _el$2);
|
|
2317
|
+
_$insertNode5(_el$, _el$4);
|
|
2318
|
+
_$setProp5(_el$, "width", "100%");
|
|
2319
|
+
_$setProp5(_el$, "height", "100%");
|
|
2320
|
+
_$setProp5(_el$, "flexDirection", "column");
|
|
2321
|
+
_$setProp5(_el$, "padding", 1);
|
|
2322
|
+
_$setProp5(_el$, "gap", 1);
|
|
2323
|
+
_$insert5(_el$, _$createComponent3(Header, {
|
|
2324
|
+
get context() {
|
|
2325
|
+
return props.context;
|
|
2326
|
+
},
|
|
2327
|
+
get filters() {
|
|
2328
|
+
return filters3();
|
|
2329
|
+
}
|
|
2330
|
+
}), _el$2);
|
|
2331
|
+
_$insert5(_el$, _$createComponent3(Show3, {
|
|
2332
|
+
get when() {
|
|
2333
|
+
return bannerMessage(state2());
|
|
2334
|
+
},
|
|
2335
|
+
children: (message) => (() => {
|
|
2336
|
+
var _el$5 = _$createElement5("text");
|
|
2337
|
+
_$insert5(_el$5, message);
|
|
2338
|
+
_$effect5((_$p) => _$setProp5(_el$5, "fg", state2().kind === "error" ? theme.text.feedback.error.base : theme.text.muted, _$p));
|
|
2339
|
+
return _el$5;
|
|
2340
|
+
})()
|
|
2341
|
+
}), _el$2);
|
|
2342
|
+
_$setProp5(_el$2, "flexGrow", 1);
|
|
2343
|
+
_$setProp5(_el$2, "flexDirection", "column");
|
|
2344
|
+
_$setProp5(_el$2, "gap", 1);
|
|
2345
|
+
_$insert5(_el$2, _$createComponent3(Switch, {
|
|
2346
|
+
get children() {
|
|
2347
|
+
return [_$createComponent3(Match, {
|
|
2348
|
+
get when() {
|
|
2349
|
+
return pageState() === "loading";
|
|
2350
|
+
},
|
|
2351
|
+
get children() {
|
|
2352
|
+
return _$createComponent3(LoadingState, {
|
|
2353
|
+
get context() {
|
|
2354
|
+
return props.context;
|
|
2355
|
+
},
|
|
2356
|
+
get sessions() {
|
|
2357
|
+
return state2().scanned;
|
|
2358
|
+
}
|
|
2359
|
+
});
|
|
2360
|
+
}
|
|
2361
|
+
}), _$createComponent3(Match, {
|
|
2362
|
+
get when() {
|
|
2363
|
+
return pageState() === "error";
|
|
2364
|
+
},
|
|
2365
|
+
get children() {
|
|
2366
|
+
return _$createComponent3(ErrorState, {
|
|
2367
|
+
get context() {
|
|
2368
|
+
return props.context;
|
|
2369
|
+
}
|
|
2370
|
+
});
|
|
2371
|
+
}
|
|
2372
|
+
}), _$createComponent3(Match, {
|
|
2373
|
+
get when() {
|
|
2374
|
+
return pageState() === "empty";
|
|
2375
|
+
},
|
|
2376
|
+
get children() {
|
|
2377
|
+
return _$createComponent3(EmptyState, {
|
|
2378
|
+
get context() {
|
|
2379
|
+
return props.context;
|
|
2380
|
+
},
|
|
2381
|
+
get filters() {
|
|
2382
|
+
return filters3();
|
|
2383
|
+
}
|
|
2384
|
+
});
|
|
2385
|
+
}
|
|
2386
|
+
}), _$createComponent3(Match, {
|
|
2387
|
+
get when() {
|
|
2388
|
+
return pageState() === "unmeasurable";
|
|
2389
|
+
},
|
|
2390
|
+
get children() {
|
|
2391
|
+
return _$createComponent3(UnmeasurableState, {
|
|
2392
|
+
get context() {
|
|
2393
|
+
return props.context;
|
|
2394
|
+
}
|
|
2395
|
+
});
|
|
2396
|
+
}
|
|
2397
|
+
}), _$createComponent3(Match, {
|
|
2398
|
+
get when() {
|
|
2399
|
+
return pageState() === "ready";
|
|
2400
|
+
},
|
|
2401
|
+
get children() {
|
|
2402
|
+
var _el$3 = _$createElement5("box");
|
|
2403
|
+
_$setProp5(_el$3, "flexDirection", "column");
|
|
2404
|
+
_$setProp5(_el$3, "flexGrow", 1);
|
|
2405
|
+
_$setProp5(_el$3, "gap", 1);
|
|
2406
|
+
_$insert5(_el$3, _$createComponent3(ComparisonTable, {
|
|
2407
|
+
get context() {
|
|
2408
|
+
return props.context;
|
|
2409
|
+
},
|
|
2410
|
+
get rows() {
|
|
2411
|
+
return rows();
|
|
2412
|
+
},
|
|
2413
|
+
get selectedKey() {
|
|
2414
|
+
return selectedKey();
|
|
2415
|
+
},
|
|
2416
|
+
get width() {
|
|
2417
|
+
return Math.max(20, dimensions().width - 2);
|
|
2418
|
+
},
|
|
2419
|
+
get height() {
|
|
2420
|
+
return Math.max(3, dimensions().height - 27);
|
|
2421
|
+
}
|
|
2422
|
+
}), null);
|
|
2423
|
+
_$insert5(_el$3, _$createComponent3(TrendPanel, {
|
|
2424
|
+
get context() {
|
|
2425
|
+
return props.context;
|
|
2426
|
+
},
|
|
2427
|
+
get series() {
|
|
2428
|
+
return series();
|
|
2429
|
+
},
|
|
2430
|
+
get selectedDay() {
|
|
2431
|
+
return selectedDay();
|
|
2432
|
+
},
|
|
2433
|
+
get rowLabel() {
|
|
2434
|
+
return rowLabel();
|
|
2435
|
+
},
|
|
2436
|
+
get rangeLabel() {
|
|
2437
|
+
return rangeLabel(filters3().range);
|
|
2438
|
+
},
|
|
2439
|
+
get reasoningLabel() {
|
|
2440
|
+
return reasoningLabel(filters3().reasoning);
|
|
2441
|
+
},
|
|
2442
|
+
get width() {
|
|
2443
|
+
return Math.max(20, dimensions().width - 2);
|
|
2444
|
+
}
|
|
2445
|
+
}), null);
|
|
2446
|
+
return _el$3;
|
|
2447
|
+
}
|
|
2448
|
+
})];
|
|
2449
|
+
}
|
|
2450
|
+
}));
|
|
2451
|
+
_$insert5(_el$4, () => HELP_LINE + coverage() + footerStatusSuffix(state2()));
|
|
2452
|
+
_$effect5((_p$) => {
|
|
2453
|
+
var _v$ = theme.background.base, _v$2 = theme.text.muted;
|
|
2454
|
+
_v$ !== _p$.e && (_p$.e = _$setProp5(_el$, "backgroundColor", _v$, _p$.e));
|
|
2455
|
+
_v$2 !== _p$.t && (_p$.t = _$setProp5(_el$4, "fg", _v$2, _p$.t));
|
|
2456
|
+
return _p$;
|
|
2457
|
+
}, {
|
|
2458
|
+
e: undefined,
|
|
2459
|
+
t: undefined
|
|
2460
|
+
});
|
|
2461
|
+
return _el$;
|
|
2462
|
+
})();
|
|
2463
|
+
}
|
|
2464
|
+
var SCOPE_OPTIONS = [{
|
|
2465
|
+
title: "Current project",
|
|
2466
|
+
value: "project"
|
|
2467
|
+
}, {
|
|
2468
|
+
title: "All projects",
|
|
2469
|
+
value: "all"
|
|
2470
|
+
}];
|
|
2471
|
+
var RANGE_OPTIONS = [{
|
|
2472
|
+
title: "Last 7 days",
|
|
2473
|
+
value: "last7"
|
|
2474
|
+
}, {
|
|
2475
|
+
title: "Last 30 days",
|
|
2476
|
+
value: "last30"
|
|
2477
|
+
}, {
|
|
2478
|
+
title: "Last 90 days",
|
|
2479
|
+
value: "last90"
|
|
2480
|
+
}, {
|
|
2481
|
+
title: "All history",
|
|
2482
|
+
value: "all"
|
|
2483
|
+
}];
|
|
2484
|
+
var HELP_LINE = "\u2191\u2193 select \xB7 enter trend \xB7 \u2190\u2192 day \xB7 s scope \xB7 t range \xB7 r reasoning \xB7 esc back \xB7 reset history in palette";
|
|
2485
|
+
|
|
2486
|
+
// src/sidebar/store.ts
|
|
2487
|
+
function createWidgetStore(service) {
|
|
2488
|
+
return {
|
|
2489
|
+
state: () => service.widget()(),
|
|
2490
|
+
refresh: () => service.refreshNow(),
|
|
2491
|
+
attach: () => service.hold()
|
|
2492
|
+
};
|
|
2493
|
+
}
|
|
2494
|
+
|
|
2495
|
+
// src/sidebar/widget.tsx
|
|
2496
|
+
import {insertNode as _$insertNode6} from "@opentui/solid";
|
|
2497
|
+
import {effect as _$effect6} from "@opentui/solid";
|
|
2498
|
+
import {insert as _$insert6} from "@opentui/solid";
|
|
2499
|
+
import {createComponent as _$createComponent4} from "@opentui/solid";
|
|
2500
|
+
import {setProp as _$setProp6} from "@opentui/solid";
|
|
2501
|
+
import {use as _$use} from "@opentui/solid";
|
|
2502
|
+
import {createElement as _$createElement6} from "@opentui/solid";
|
|
2503
|
+
import {TextAttributes as TextAttributes4} from "@opentui/core";
|
|
2504
|
+
import {useTerminalDimensions as useTerminalDimensions2} from "@opentui/solid";
|
|
2505
|
+
import {createEffect as createEffect2, createMemo as createMemo3, createSignal as createSignal3, For as For3, onCleanup, onMount, Show as Show4} from "solid-js";
|
|
2506
|
+
|
|
2507
|
+
// src/sidebar/layout.ts
|
|
2508
|
+
var unitLine = function(width) {
|
|
2509
|
+
return " ".repeat(Math.max(0, width - UNIT.length)) + UNIT;
|
|
2510
|
+
};
|
|
2511
|
+
function headingTitle(stale) {
|
|
2512
|
+
return stale ? `${HEADING_BRAND} \xB7 24h (stale)` : `${HEADING_BRAND} \xB7 24h`;
|
|
2513
|
+
}
|
|
2514
|
+
function headingLine(width, stale) {
|
|
2515
|
+
const title = headingTitle(stale);
|
|
2516
|
+
const gap = width - title.length - UNIT.length;
|
|
2517
|
+
if (gap < 1)
|
|
2518
|
+
return [title, unitLine(width)];
|
|
2519
|
+
return [title + " ".repeat(gap) + UNIT];
|
|
2520
|
+
}
|
|
2521
|
+
var abbreviate = function(provider, budget) {
|
|
2522
|
+
if (provider.length <= budget)
|
|
2523
|
+
return provider;
|
|
2524
|
+
return provider.slice(0, budget - 1) + "\u2026";
|
|
2525
|
+
};
|
|
2526
|
+
var alignSpeed = function(content, speed, width) {
|
|
2527
|
+
const gap = Math.max(0, width - content.length - speed.length);
|
|
2528
|
+
return content + " ".repeat(gap) + speed;
|
|
2529
|
+
};
|
|
2530
|
+
var wrapWords = function(text, width) {
|
|
2531
|
+
const lines = [];
|
|
2532
|
+
let line = "";
|
|
2533
|
+
for (const word of text.split(" ")) {
|
|
2534
|
+
const candidate = line === "" ? word : `${line} ${word}`;
|
|
2535
|
+
if (candidate.length <= width) {
|
|
2536
|
+
line = candidate;
|
|
2537
|
+
continue;
|
|
2538
|
+
}
|
|
2539
|
+
if (line !== "") {
|
|
2540
|
+
lines.push(line);
|
|
2541
|
+
line = "";
|
|
2542
|
+
}
|
|
2543
|
+
let rest = word;
|
|
2544
|
+
while (rest.length > width) {
|
|
2545
|
+
lines.push(rest.slice(0, width));
|
|
2546
|
+
rest = rest.slice(width);
|
|
2547
|
+
}
|
|
2548
|
+
line = rest;
|
|
2549
|
+
}
|
|
2550
|
+
if (line !== "")
|
|
2551
|
+
lines.push(line);
|
|
2552
|
+
return lines;
|
|
2553
|
+
};
|
|
2554
|
+
var wrapEntry = function(model, speed, width) {
|
|
2555
|
+
const available = Math.max(1, width - speed.length - 2);
|
|
2556
|
+
const lines = wrapWords(model, available);
|
|
2557
|
+
const last = lines.pop() ?? "";
|
|
2558
|
+
return [...lines, alignSpeed(last, speed, width)];
|
|
2559
|
+
};
|
|
2560
|
+
function entryLines(entries, width) {
|
|
2561
|
+
const lines = [];
|
|
2562
|
+
const usedLabels = new Map;
|
|
2563
|
+
for (const entry of entries) {
|
|
2564
|
+
const speed = String(Math.round(entry.median));
|
|
2565
|
+
if (entry.model.length + speed.length + 2 > width) {
|
|
2566
|
+
lines.push(...wrapEntry(entry.model, speed, width));
|
|
2567
|
+
continue;
|
|
2568
|
+
}
|
|
2569
|
+
let budget = width - entry.model.length - SEPARATOR.length - speed.length - 2;
|
|
2570
|
+
if (budget < 2 || entry.provider.length === 0) {
|
|
2571
|
+
lines.push(alignSpeed(entry.model, speed, width));
|
|
2572
|
+
continue;
|
|
2573
|
+
}
|
|
2574
|
+
let label = abbreviate(entry.provider, budget);
|
|
2575
|
+
let truncated = label !== entry.provider;
|
|
2576
|
+
while (usedLabels.has(label) && (truncated || usedLabels.get(label) === true) && budget > 2) {
|
|
2577
|
+
budget--;
|
|
2578
|
+
label = abbreviate(entry.provider, budget);
|
|
2579
|
+
truncated = true;
|
|
2580
|
+
}
|
|
2581
|
+
usedLabels.set(label, truncated);
|
|
2582
|
+
lines.push(alignSpeed(entry.model + SEPARATOR + label, speed, width));
|
|
2583
|
+
}
|
|
2584
|
+
return lines;
|
|
2585
|
+
}
|
|
2586
|
+
var NO_QUALIFYING_MESSAGE = "No models with 3+ calls in 24h.";
|
|
2587
|
+
var LOADING_MESSAGE = "Loading\u2026";
|
|
2588
|
+
var READ_ERROR_MESSAGE = "Could not read history.";
|
|
2589
|
+
var UNIT = "tok/s";
|
|
2590
|
+
var SEPARATOR = " \xB7 ";
|
|
2591
|
+
var HEADING_BRAND = "TokScope";
|
|
2592
|
+
|
|
2593
|
+
// src/sidebar/view.ts
|
|
2594
|
+
function widgetView(state2, width, entries) {
|
|
2595
|
+
if (width === undefined)
|
|
2596
|
+
return;
|
|
2597
|
+
return {
|
|
2598
|
+
title: headingTitle(state2.stale),
|
|
2599
|
+
heading: headingLine(width, state2.stale),
|
|
2600
|
+
status: state2.status,
|
|
2601
|
+
lines: state2.status === "ready" ? entryLines(entries, width) : []
|
|
2602
|
+
};
|
|
2603
|
+
}
|
|
2604
|
+
|
|
2605
|
+
// src/sidebar/widget.tsx
|
|
2606
|
+
function TokscopeSidebar(props) {
|
|
2607
|
+
const theme = props.context.theme;
|
|
2608
|
+
const dimensions = useTerminalDimensions2();
|
|
2609
|
+
const [width, setWidth] = createSignal3();
|
|
2610
|
+
let target;
|
|
2611
|
+
let timer;
|
|
2612
|
+
const measure = (remaining = MEASURE_TICKS) => {
|
|
2613
|
+
if (timer !== undefined)
|
|
2614
|
+
clearTimeout(timer);
|
|
2615
|
+
timer = setTimeout(() => {
|
|
2616
|
+
timer = undefined;
|
|
2617
|
+
if (target === undefined)
|
|
2618
|
+
return;
|
|
2619
|
+
let measured = 0;
|
|
2620
|
+
try {
|
|
2621
|
+
measured = target.getLayout().width;
|
|
2622
|
+
} catch {
|
|
2623
|
+
return;
|
|
2624
|
+
}
|
|
2625
|
+
if (measured > 0) {
|
|
2626
|
+
setWidth(measured);
|
|
2627
|
+
return;
|
|
2628
|
+
}
|
|
2629
|
+
if (remaining > 1)
|
|
2630
|
+
measure(remaining - 1);
|
|
2631
|
+
}, 0);
|
|
2632
|
+
};
|
|
2633
|
+
createEffect2(() => {
|
|
2634
|
+
dimensions();
|
|
2635
|
+
measure();
|
|
2636
|
+
});
|
|
2637
|
+
onCleanup(() => {
|
|
2638
|
+
if (timer !== undefined)
|
|
2639
|
+
clearTimeout(timer);
|
|
2640
|
+
});
|
|
2641
|
+
onMount(() => {
|
|
2642
|
+
props.context.data.location.model.sync();
|
|
2643
|
+
props.context.data.location.provider.sync();
|
|
2644
|
+
const detach = props.store.attach();
|
|
2645
|
+
onCleanup(detach);
|
|
2646
|
+
});
|
|
2647
|
+
const entries = createMemo3(() => {
|
|
2648
|
+
const models = props.context.data.location.model.list();
|
|
2649
|
+
const providers = props.context.data.location.provider.list();
|
|
2650
|
+
return props.store.state().rows.map((row) => ({
|
|
2651
|
+
model: modelDisplayName(models, row.providerID, row.modelID),
|
|
2652
|
+
provider: providers?.find((item) => item.id === row.providerID)?.name ?? row.providerID,
|
|
2653
|
+
median: row.median
|
|
2654
|
+
}));
|
|
2655
|
+
});
|
|
2656
|
+
const view2 = () => widgetView(props.store.state(), width(), entries());
|
|
2657
|
+
return (() => {
|
|
2658
|
+
var _el$ = _$createElement6("box");
|
|
2659
|
+
_$use((element) => {
|
|
2660
|
+
target = element;
|
|
2661
|
+
measure();
|
|
2662
|
+
}, _el$);
|
|
2663
|
+
_$setProp6(_el$, "flexDirection", "column");
|
|
2664
|
+
_$setProp6(_el$, "width", "100%");
|
|
2665
|
+
_$insert6(_el$, _$createComponent4(Show4, {
|
|
2666
|
+
get when() {
|
|
2667
|
+
return view2();
|
|
2668
|
+
},
|
|
2669
|
+
keyed: true,
|
|
2670
|
+
children: (current) => [_$createComponent4(For3, {
|
|
2671
|
+
get each() {
|
|
2672
|
+
return current.heading;
|
|
2673
|
+
},
|
|
2674
|
+
children: (line, index) => index() === 0 ? (() => {
|
|
2675
|
+
var _el$4 = _$createElement6("box"), _el$5 = _$createElement6("text"), _el$6 = _$createElement6("text");
|
|
2676
|
+
_$insertNode6(_el$4, _el$5);
|
|
2677
|
+
_$insertNode6(_el$4, _el$6);
|
|
2678
|
+
_$setProp6(_el$4, "flexDirection", "row");
|
|
2679
|
+
_$insert6(_el$5, () => line.slice(0, HEADING_BRAND.length));
|
|
2680
|
+
_$insert6(_el$6, () => line.slice(HEADING_BRAND.length));
|
|
2681
|
+
_$effect6((_p$) => {
|
|
2682
|
+
var _v$ = theme.text.base, _v$2 = TextAttributes4.BOLD, _v$3 = theme.text.muted;
|
|
2683
|
+
_v$ !== _p$.e && (_p$.e = _$setProp6(_el$5, "fg", _v$, _p$.e));
|
|
2684
|
+
_v$2 !== _p$.t && (_p$.t = _$setProp6(_el$5, "attributes", _v$2, _p$.t));
|
|
2685
|
+
_v$3 !== _p$.a && (_p$.a = _$setProp6(_el$6, "fg", _v$3, _p$.a));
|
|
2686
|
+
return _p$;
|
|
2687
|
+
}, {
|
|
2688
|
+
e: undefined,
|
|
2689
|
+
t: undefined,
|
|
2690
|
+
a: undefined
|
|
2691
|
+
});
|
|
2692
|
+
return _el$4;
|
|
2693
|
+
})() : (() => {
|
|
2694
|
+
var _el$7 = _$createElement6("text");
|
|
2695
|
+
_$insert6(_el$7, line);
|
|
2696
|
+
_$effect6((_$p) => _$setProp6(_el$7, "fg", theme.text.muted, _$p));
|
|
2697
|
+
return _el$7;
|
|
2698
|
+
})()
|
|
2699
|
+
}), _$createComponent4(Show4, {
|
|
2700
|
+
get when() {
|
|
2701
|
+
return current.status === "loading";
|
|
2702
|
+
},
|
|
2703
|
+
get children() {
|
|
2704
|
+
var _el$2 = _$createElement6("text");
|
|
2705
|
+
_$insert6(_el$2, LOADING_MESSAGE);
|
|
2706
|
+
_$effect6((_$p) => _$setProp6(_el$2, "fg", theme.text.muted, _$p));
|
|
2707
|
+
return _el$2;
|
|
2708
|
+
}
|
|
2709
|
+
}), _$createComponent4(Show4, {
|
|
2710
|
+
get when() {
|
|
2711
|
+
return current.status === "error";
|
|
2712
|
+
},
|
|
2713
|
+
get children() {
|
|
2714
|
+
var _el$3 = _$createElement6("text");
|
|
2715
|
+
_$insert6(_el$3, READ_ERROR_MESSAGE);
|
|
2716
|
+
_$effect6((_$p) => _$setProp6(_el$3, "fg", theme.text.feedback.error.base, _$p));
|
|
2717
|
+
return _el$3;
|
|
2718
|
+
}
|
|
2719
|
+
}), _$createComponent4(Show4, {
|
|
2720
|
+
get when() {
|
|
2721
|
+
return current.status === "ready";
|
|
2722
|
+
},
|
|
2723
|
+
get children() {
|
|
2724
|
+
return _$createComponent4(Show4, {
|
|
2725
|
+
get when() {
|
|
2726
|
+
return current.lines.length > 0;
|
|
2727
|
+
},
|
|
2728
|
+
get fallback() {
|
|
2729
|
+
return (() => {
|
|
2730
|
+
var _el$8 = _$createElement6("text");
|
|
2731
|
+
_$insert6(_el$8, NO_QUALIFYING_MESSAGE);
|
|
2732
|
+
_$effect6((_$p) => _$setProp6(_el$8, "fg", theme.text.muted, _$p));
|
|
2733
|
+
return _el$8;
|
|
2734
|
+
})();
|
|
2735
|
+
},
|
|
2736
|
+
get children() {
|
|
2737
|
+
return _$createComponent4(For3, {
|
|
2738
|
+
get each() {
|
|
2739
|
+
return current.lines.map((text, index) => ({
|
|
2740
|
+
index,
|
|
2741
|
+
text
|
|
2742
|
+
}));
|
|
2743
|
+
},
|
|
2744
|
+
children: (line) => (() => {
|
|
2745
|
+
var _el$9 = _$createElement6("text");
|
|
2746
|
+
_$insert6(_el$9, () => line.text);
|
|
2747
|
+
_$effect6((_$p) => _$setProp6(_el$9, "fg", theme.text.muted, _$p));
|
|
2748
|
+
return _el$9;
|
|
2749
|
+
})()
|
|
2750
|
+
});
|
|
2751
|
+
}
|
|
2752
|
+
});
|
|
2753
|
+
}
|
|
2754
|
+
})]
|
|
2755
|
+
}));
|
|
2756
|
+
_$effect6((_$p) => _$setProp6(_el$, "onMouseDown", props.open, _$p));
|
|
2757
|
+
return _el$;
|
|
2758
|
+
})();
|
|
2759
|
+
}
|
|
2760
|
+
var MEASURE_TICKS = 10;
|
|
2761
|
+
|
|
2762
|
+
// src/tui.tsx
|
|
2763
|
+
var tui_default = Plugin.define({
|
|
2764
|
+
id: "tokscope",
|
|
2765
|
+
setup(context) {
|
|
2766
|
+
const [previous, setPrevious] = createSignal4({
|
|
2767
|
+
...context.ui.router.current()
|
|
2768
|
+
});
|
|
2769
|
+
const openTokscope = () => {
|
|
2770
|
+
const current = context.ui.router.current();
|
|
2771
|
+
if (current.type === "plugin" && current.name === "tokscope")
|
|
2772
|
+
return;
|
|
2773
|
+
setPrevious({
|
|
2774
|
+
...current
|
|
2775
|
+
});
|
|
2776
|
+
context.ui.dialog.clear();
|
|
2777
|
+
context.ui.router.navigate({
|
|
2778
|
+
type: "plugin",
|
|
2779
|
+
name: "tokscope"
|
|
2780
|
+
});
|
|
2781
|
+
};
|
|
2782
|
+
let unsubscribeEvents;
|
|
2783
|
+
const service2 = createHistoryService({
|
|
2784
|
+
client: context.client,
|
|
2785
|
+
repository: createRepository(createPluginDurableStore(context.storage)),
|
|
2786
|
+
subscribeEvents: (handler) => {
|
|
2787
|
+
unsubscribeEvents = context.data.listen(({
|
|
2788
|
+
details
|
|
2789
|
+
}) => handler({
|
|
2790
|
+
type: details.type,
|
|
2791
|
+
data: details.data
|
|
2792
|
+
}));
|
|
2793
|
+
return unsubscribeEvents;
|
|
2794
|
+
},
|
|
2795
|
+
setTimer: (callback, ms) => {
|
|
2796
|
+
const id = setInterval(callback, ms);
|
|
2797
|
+
return () => clearInterval(id);
|
|
2798
|
+
},
|
|
2799
|
+
delay: (callback, ms) => {
|
|
2800
|
+
const id = setTimeout(callback, ms);
|
|
2801
|
+
return () => clearTimeout(id);
|
|
2802
|
+
},
|
|
2803
|
+
now: () => Date.now()
|
|
2804
|
+
});
|
|
2805
|
+
const release = service2.hold();
|
|
2806
|
+
const store3 = createWidgetStore(service2);
|
|
2807
|
+
context.ui.router.register({
|
|
2808
|
+
name: "tokscope",
|
|
2809
|
+
render: () => _$createComponent5(TokscopePage, {
|
|
2810
|
+
context,
|
|
2811
|
+
service: service2,
|
|
2812
|
+
onClose: () => context.ui.router.navigate(previous())
|
|
2813
|
+
})
|
|
2814
|
+
});
|
|
2815
|
+
context.ui.slot({
|
|
2816
|
+
append: "sidebar.content",
|
|
2817
|
+
render: () => _$createComponent5(TokscopeSidebar, {
|
|
2818
|
+
context,
|
|
2819
|
+
store: store3,
|
|
2820
|
+
open: openTokscope
|
|
2821
|
+
})
|
|
2822
|
+
});
|
|
2823
|
+
context.ui.slot({
|
|
2824
|
+
append: "app",
|
|
2825
|
+
render() {
|
|
2826
|
+
context.keymap.layer(() => ({
|
|
2827
|
+
mode: "global",
|
|
2828
|
+
commands: [{
|
|
2829
|
+
id: "tokscope.open",
|
|
2830
|
+
title: "Tokscope",
|
|
2831
|
+
group: "System",
|
|
2832
|
+
slash: {
|
|
2833
|
+
name: "tokscope"
|
|
2834
|
+
},
|
|
2835
|
+
palette: true,
|
|
2836
|
+
run: openTokscope
|
|
2837
|
+
}, {
|
|
2838
|
+
id: "tokscope.resetHistory",
|
|
2839
|
+
title: "Tokscope: reset history cache",
|
|
2840
|
+
group: "System",
|
|
2841
|
+
palette: true,
|
|
2842
|
+
run: async () => {
|
|
2843
|
+
const confirmed = await context.ui.dialog.confirm({
|
|
2844
|
+
title: "Reset Tokscope history cache",
|
|
2845
|
+
message: "Delete the shared Tokscope history cache and rebuild it from the server?",
|
|
2846
|
+
label: {
|
|
2847
|
+
confirm: "Reset",
|
|
2848
|
+
cancel: "Cancel"
|
|
2849
|
+
}
|
|
2850
|
+
});
|
|
2851
|
+
if (confirmed === true)
|
|
2852
|
+
await service2.reset();
|
|
2853
|
+
}
|
|
2854
|
+
}]
|
|
2855
|
+
}));
|
|
2856
|
+
return null;
|
|
2857
|
+
}
|
|
2858
|
+
});
|
|
2859
|
+
return () => {
|
|
2860
|
+
unsubscribeEvents?.();
|
|
2861
|
+
release();
|
|
2862
|
+
};
|
|
2863
|
+
}
|
|
2864
|
+
});
|
|
2865
|
+
export {
|
|
2866
|
+
tui_default as default
|
|
2867
|
+
};
|