mirror of
https://github.com/Youzini-afk/ST-Bionic-Memory-Ecology.git
synced 2026-05-15 22:30:38 +08:00
401 lines
11 KiB
JavaScript
401 lines
11 KiB
JavaScript
import assert from "node:assert/strict";
|
|
|
|
import {
|
|
buildAuthorityDiagnosticsBundle,
|
|
buildAuthorityDiagnosticsBundlePath,
|
|
buildAuthorityDiagnosticsManifestPath,
|
|
buildAuthorityPerformanceBaseline,
|
|
buildAuthorityPerformanceBaselineComparison,
|
|
readAuthorityDiagnosticsManifest,
|
|
removeAuthorityDiagnosticsManifestEntry,
|
|
sanitizeDiagnosticsSettings,
|
|
upsertAuthorityDiagnosticsManifestEntry,
|
|
writeAuthorityDiagnosticsBundle,
|
|
} from "../maintenance/authority-diagnostics-bundle.js";
|
|
|
|
function createMockAdapter() {
|
|
const calls = [];
|
|
const storage = new Map();
|
|
return {
|
|
calls,
|
|
storage,
|
|
async writeJson(path, payload, options = {}) {
|
|
storage.set(path, structuredClone(payload));
|
|
calls.push([path, payload, options]);
|
|
return {
|
|
ok: true,
|
|
path,
|
|
size: JSON.stringify(payload).length,
|
|
};
|
|
},
|
|
async readJson(path) {
|
|
if (!storage.has(path)) {
|
|
return {
|
|
exists: false,
|
|
path,
|
|
};
|
|
}
|
|
return {
|
|
exists: true,
|
|
path,
|
|
payload: structuredClone(storage.get(path)),
|
|
};
|
|
},
|
|
async delete(path) {
|
|
const existed = storage.delete(path);
|
|
return {
|
|
ok: true,
|
|
path,
|
|
deleted: existed,
|
|
missing: !existed,
|
|
};
|
|
},
|
|
};
|
|
}
|
|
|
|
{
|
|
const sanitized = sanitizeDiagnosticsSettings({
|
|
authorityBaseUrl: "https://example.test",
|
|
authorityApiKey: "secret-1",
|
|
nested: {
|
|
embeddingApiKey: "secret-2",
|
|
label: "ok",
|
|
},
|
|
models: [
|
|
{ name: "a", token: "secret-3" },
|
|
{ name: "b", enabled: true },
|
|
],
|
|
});
|
|
assert.equal(sanitized.authorityBaseUrl, "https://example.test");
|
|
assert.equal(sanitized.authorityApiKey, "[REDACTED]");
|
|
assert.equal(sanitized.nested.embeddingApiKey, "[REDACTED]");
|
|
assert.equal(sanitized.nested.label, "ok");
|
|
assert.equal(sanitized.models[0].token, "[REDACTED]");
|
|
}
|
|
|
|
{
|
|
const baseline = buildAuthorityPerformanceBaseline({
|
|
chatId: "chat/main",
|
|
graphPersistence: {
|
|
chatId: "chat/main",
|
|
revision: 12,
|
|
loadState: "loaded",
|
|
loadDiagnostics: {
|
|
source: "authority-sql",
|
|
totalMs: 45,
|
|
hydrateMs: 18,
|
|
},
|
|
persistDelta: {
|
|
totalMs: 22,
|
|
commitMs: 8,
|
|
commitPayloadBytes: 2048,
|
|
},
|
|
authorityRecentJobs: [
|
|
{ id: "job-1", queueState: "success" },
|
|
{ id: "job-2", queueState: "failed" },
|
|
],
|
|
authorityLastJobId: "job-2",
|
|
authorityLastJobStatus: "failed",
|
|
authorityConsistencyState: "warning",
|
|
authorityBlobCheckpointRevision: 11,
|
|
authorityDiagnosticsBundlePath: "user/files/diag.json",
|
|
authorityDiagnosticsBundleSize: 512,
|
|
},
|
|
graph: {
|
|
chatId: "chat/main",
|
|
meta: { revision: 12 },
|
|
nodes: [{ id: "n1" }, { id: "n2" }],
|
|
edges: [{ id: "e1" }],
|
|
historyState: { extractionCount: 5 },
|
|
},
|
|
consistencyAudit: {
|
|
issues: [{ code: "revision-drift" }],
|
|
sql: { revision: 12 },
|
|
trivium: { revision: 10 },
|
|
blob: { revision: 11 },
|
|
},
|
|
});
|
|
assert.equal(baseline.kind, "authority-performance-baseline");
|
|
assert.equal(baseline.graphRevision, 12);
|
|
assert.equal(baseline.graphNodeCount, 2);
|
|
assert.equal(baseline.soak.recentJobCount, 2);
|
|
assert.equal(baseline.soak.failedJobCount, 1);
|
|
assert.equal(baseline.audit.issueCount, 1);
|
|
assert.equal(baseline.artifacts.diagnosticsBundlePath, "user/files/diag.json");
|
|
}
|
|
|
|
{
|
|
const previousBaseline = {
|
|
kind: "authority-performance-baseline",
|
|
chatId: "chat/main",
|
|
capturedAt: "2026-01-01T00:00:00.000Z",
|
|
graphRevision: 12,
|
|
graphNodeCount: 2,
|
|
graphEdgeCount: 1,
|
|
extractionCount: 5,
|
|
load: {
|
|
totalMs: 45,
|
|
hydrateMs: 18,
|
|
},
|
|
persist: {
|
|
totalMs: 22,
|
|
commitMs: 8,
|
|
commitPayloadBytes: 2048,
|
|
commitWalBytes: 128,
|
|
},
|
|
soak: {
|
|
recentJobCount: 2,
|
|
runningJobCount: 0,
|
|
failedJobCount: 1,
|
|
},
|
|
};
|
|
const currentBaseline = {
|
|
kind: "authority-performance-baseline",
|
|
chatId: "chat/main",
|
|
capturedAt: "2026-01-02T00:00:00.000Z",
|
|
graphRevision: 15,
|
|
graphNodeCount: 4,
|
|
graphEdgeCount: 3,
|
|
extractionCount: 8,
|
|
load: {
|
|
totalMs: 60,
|
|
hydrateMs: 24,
|
|
},
|
|
persist: {
|
|
totalMs: 30,
|
|
commitMs: 11,
|
|
commitPayloadBytes: 3072,
|
|
commitWalBytes: 256,
|
|
},
|
|
soak: {
|
|
recentJobCount: 4,
|
|
runningJobCount: 1,
|
|
failedJobCount: 0,
|
|
},
|
|
};
|
|
const comparison = buildAuthorityPerformanceBaselineComparison(
|
|
previousBaseline,
|
|
currentBaseline,
|
|
);
|
|
assert.equal(comparison.kind, "authority-performance-baseline-comparison");
|
|
assert.equal(comparison.previousCapturedAt, "2026-01-01T00:00:00.000Z");
|
|
assert.equal(comparison.currentCapturedAt, "2026-01-02T00:00:00.000Z");
|
|
assert.equal(comparison.deltaGraphRevision, 3);
|
|
assert.equal(comparison.deltaNodeCount, 2);
|
|
assert.equal(comparison.deltaEdgeCount, 2);
|
|
assert.equal(comparison.load.totalMs, 15);
|
|
assert.equal(comparison.persist.commitMs, 3);
|
|
assert.equal(comparison.soak.failedJobCount, -1);
|
|
}
|
|
|
|
{
|
|
const bundle = buildAuthorityDiagnosticsBundle({
|
|
chatId: "chat/main",
|
|
reason: "manual-export",
|
|
settings: {
|
|
authorityApiKey: "secret-1",
|
|
authorityBlobEnabled: true,
|
|
},
|
|
runtimeStatus: {
|
|
text: "待命",
|
|
meta: "准备就绪",
|
|
level: "idle",
|
|
updatedAt: 1,
|
|
},
|
|
runtimeDebug: {
|
|
runtimeDebug: {
|
|
injections: {
|
|
recall: {
|
|
retrievalMeta: {
|
|
authorityCandidateUsed: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
graphPersistence: {
|
|
authorityBlobState: "active",
|
|
authorityLastBlobPath: "user/files/demo.json",
|
|
},
|
|
graph: {
|
|
nodes: [
|
|
{ id: "n1", type: "memory", archived: false },
|
|
{ id: "n2", type: "summary", archived: true },
|
|
],
|
|
edges: [{ id: "e1" }],
|
|
historyState: {
|
|
chatId: "chat/main",
|
|
extractionCount: 4,
|
|
lastProcessedAssistantFloor: 12,
|
|
activeRegion: "archive",
|
|
activeRecallOwnerKeys: ["character:Alice"],
|
|
},
|
|
vectorIndexState: {
|
|
mode: "authority",
|
|
source: "authority-trivium",
|
|
dirty: false,
|
|
collectionId: "collection-1",
|
|
hashToNodeId: {
|
|
a: "n1",
|
|
},
|
|
},
|
|
summaryState: {
|
|
enabled: true,
|
|
lastSummarizedExtractionCount: 3,
|
|
},
|
|
},
|
|
lastExtractionStatus: {
|
|
text: "提取完成",
|
|
meta: "ok",
|
|
level: "success",
|
|
updatedAt: 2,
|
|
},
|
|
lastVectorStatus: {
|
|
text: "向量完成",
|
|
meta: "ok",
|
|
level: "success",
|
|
updatedAt: 3,
|
|
},
|
|
lastRecallStatus: {
|
|
text: "召回完成",
|
|
meta: "ok",
|
|
level: "success",
|
|
updatedAt: 4,
|
|
},
|
|
lastBatchStatus: {
|
|
ok: true,
|
|
stage: "finalize",
|
|
},
|
|
lastInjection: "A".repeat(4500),
|
|
lastExtract: [{ id: "n1" }],
|
|
lastRecall: [{ id: "n2" }],
|
|
performanceBaseline: {
|
|
kind: "authority-performance-baseline",
|
|
graphRevision: 9,
|
|
load: { totalMs: 12 },
|
|
},
|
|
performanceBaselineComparison: {
|
|
kind: "authority-performance-baseline-comparison",
|
|
deltaGraphRevision: 2,
|
|
load: { totalMs: 4 },
|
|
persist: { totalMs: 3 },
|
|
soak: { failedJobCount: -1 },
|
|
},
|
|
});
|
|
|
|
assert.equal(bundle.kind, "st-bme-authority-diagnostics");
|
|
assert.equal(bundle.chatId, "chat/main");
|
|
assert.equal(bundle.settings.authorityApiKey, "[REDACTED]");
|
|
assert.equal(bundle.graphSummary.nodeCount, 2);
|
|
assert.equal(bundle.graphSummary.activeNodeCount, 1);
|
|
assert.equal(bundle.graphSummary.archivedNodeCount, 1);
|
|
assert.equal(bundle.graphSummary.edgeCount, 1);
|
|
assert.equal(bundle.lastInjection.textLength, 4500);
|
|
assert.equal(bundle.lastInjection.textPreview.length, 4000);
|
|
assert.equal(bundle.recentExtractedItems.length, 1);
|
|
assert.equal(bundle.recentRecalledItems.length, 1);
|
|
assert.equal(bundle.performanceBaseline?.graphRevision, 9);
|
|
assert.equal(bundle.performanceBaselineComparison?.deltaGraphRevision, 2);
|
|
}
|
|
|
|
{
|
|
const path = buildAuthorityDiagnosticsBundlePath("chat/main", "manual-export");
|
|
assert.match(
|
|
path,
|
|
/^user\/files\/ST-BME_diagnostics_chat_main-manual-export-[a-z0-9]+-\d{8}-\d{6}\.json$/,
|
|
);
|
|
}
|
|
|
|
{
|
|
const manifestPath = buildAuthorityDiagnosticsManifestPath("chat/main");
|
|
assert.match(
|
|
manifestPath,
|
|
/^user\/files\/ST-BME_diagnostics_manifest_chat_main-[a-z0-9]+\.json$/,
|
|
);
|
|
}
|
|
|
|
{
|
|
const adapter = createMockAdapter();
|
|
const bundle = buildAuthorityDiagnosticsBundle({
|
|
chatId: "chat-main",
|
|
reason: "manual-export",
|
|
settings: {},
|
|
});
|
|
const result = await writeAuthorityDiagnosticsBundle(adapter, bundle, {
|
|
chatId: "chat-main",
|
|
reason: "manual-export",
|
|
});
|
|
assert.equal(result.ok, true);
|
|
assert.match(
|
|
result.path,
|
|
/^user\/files\/ST-BME_diagnostics_chat-main-manual-export-[a-z0-9]+-\d{8}-\d{6}\.json$/,
|
|
);
|
|
assert.equal(adapter.calls.length, 1);
|
|
assert.equal(adapter.calls[0][2]?.metadata?.kind, "diagnostics-bundle");
|
|
assert.equal(adapter.calls[0][2]?.metadata?.chatId, "chat-main");
|
|
}
|
|
|
|
{
|
|
const adapter = createMockAdapter();
|
|
await upsertAuthorityDiagnosticsManifestEntry(adapter, {
|
|
chatId: "chat-main",
|
|
path: "user/files/diag-a.json",
|
|
reason: "manual-export",
|
|
size: 100,
|
|
updatedAt: "2026-01-01T00:00:00.000Z",
|
|
});
|
|
await upsertAuthorityDiagnosticsManifestEntry(adapter, {
|
|
chatId: "chat-main",
|
|
path: "user/files/diag-b.json",
|
|
reason: "scheduled-export",
|
|
size: 120,
|
|
updatedAt: "2026-01-02T00:00:00.000Z",
|
|
});
|
|
const readResult = await readAuthorityDiagnosticsManifest(adapter, {
|
|
chatId: "chat-main",
|
|
});
|
|
assert.equal(readResult.exists, true);
|
|
assert.equal(readResult.entries.length, 2);
|
|
assert.equal(readResult.entries[0].path, "user/files/diag-b.json");
|
|
assert.equal(readResult.entries[1].path, "user/files/diag-a.json");
|
|
|
|
const removeResult = await removeAuthorityDiagnosticsManifestEntry(
|
|
adapter,
|
|
"user/files/diag-a.json",
|
|
{ chatId: "chat-main" },
|
|
);
|
|
assert.equal(removeResult.removed, true);
|
|
assert.equal(removeResult.entries.length, 1);
|
|
assert.equal(removeResult.entries[0].path, "user/files/diag-b.json");
|
|
}
|
|
|
|
{
|
|
const adapter = createMockAdapter();
|
|
await upsertAuthorityDiagnosticsManifestEntry(adapter, {
|
|
chatId: "chat-main",
|
|
path: "user/files/diag-1.json",
|
|
reason: "first",
|
|
size: 80,
|
|
updatedAt: "2026-01-01T00:00:00.000Z",
|
|
}, { limit: 2 });
|
|
await upsertAuthorityDiagnosticsManifestEntry(adapter, {
|
|
chatId: "chat-main",
|
|
path: "user/files/diag-2.json",
|
|
reason: "second",
|
|
size: 90,
|
|
updatedAt: "2026-01-02T00:00:00.000Z",
|
|
}, { limit: 2 });
|
|
const pruneResult = await upsertAuthorityDiagnosticsManifestEntry(adapter, {
|
|
chatId: "chat-main",
|
|
path: "user/files/diag-3.json",
|
|
reason: "third",
|
|
size: 100,
|
|
updatedAt: "2026-01-03T00:00:00.000Z",
|
|
}, { limit: 2 });
|
|
assert.equal(pruneResult.entries.length, 2);
|
|
assert.equal(pruneResult.prunedEntries.length, 1);
|
|
assert.equal(pruneResult.prunedEntries[0].path, "user/files/diag-1.json");
|
|
}
|
|
|
|
console.log("authority-diagnostics-bundle tests passed");
|