mirror of
https://github.com/Youzini-afk/ST-Bionic-Memory-Ecology.git
synced 2026-05-15 22:30:38 +08:00
383 lines
13 KiB
JavaScript
383 lines
13 KiB
JavaScript
function safeClone(value, fallback = null) {
|
|
if (value == null) return fallback;
|
|
try {
|
|
if (typeof structuredClone === "function") {
|
|
return structuredClone(value);
|
|
}
|
|
} catch {
|
|
}
|
|
try {
|
|
return JSON.parse(JSON.stringify(value));
|
|
} catch {
|
|
return fallback ?? value;
|
|
}
|
|
}
|
|
|
|
function normalizeRecordId(value) {
|
|
return String(value ?? "").trim();
|
|
}
|
|
|
|
function truncateText(value, maxLength = 4000) {
|
|
const text = String(value ?? "");
|
|
if (!text) return "";
|
|
if (!Number.isFinite(maxLength) || maxLength < 1 || text.length <= maxLength) {
|
|
return text;
|
|
}
|
|
return `${text.slice(0, Math.max(1, maxLength - 1))}…`;
|
|
}
|
|
|
|
function buildHash(input = "") {
|
|
let hash = 2166136261;
|
|
const text = String(input ?? "");
|
|
for (let index = 0; index < text.length; index += 1) {
|
|
hash ^= text.charCodeAt(index);
|
|
hash = Math.imul(hash, 16777619);
|
|
}
|
|
return (hash >>> 0).toString(36);
|
|
}
|
|
|
|
function buildSafeSlug(input = "", fallback = "unknown") {
|
|
const normalized = String(input || fallback)
|
|
.trim()
|
|
.replace(/[^A-Za-z0-9._-]+/g, "_")
|
|
.replace(/_+/g, "_")
|
|
.replace(/^[_.-]+|[_.-]+$/g, "")
|
|
.slice(0, 96);
|
|
return normalized || fallback;
|
|
}
|
|
|
|
function buildCompactTimestamp(date = new Date()) {
|
|
const year = date.getUTCFullYear();
|
|
const month = String(date.getUTCMonth() + 1).padStart(2, "0");
|
|
const day = String(date.getUTCDate()).padStart(2, "0");
|
|
const hour = String(date.getUTCHours()).padStart(2, "0");
|
|
const minute = String(date.getUTCMinutes()).padStart(2, "0");
|
|
const second = String(date.getUTCSeconds()).padStart(2, "0");
|
|
return `${year}${month}${day}-${hour}${minute}${second}`;
|
|
}
|
|
|
|
function isSensitiveKey(key = "") {
|
|
return /(api[_-]?key|token|secret|password|authorization|auth[_-]?header|cookie)/i.test(
|
|
String(key || ""),
|
|
);
|
|
}
|
|
|
|
function sanitizeValue(value, key = "", depth = 0) {
|
|
if (depth > 8) {
|
|
return "[Truncated]";
|
|
}
|
|
if (value == null) return value;
|
|
if (isSensitiveKey(key)) {
|
|
return String(value || "") ? "[REDACTED]" : "";
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return value.map((entry) => sanitizeValue(entry, "", depth + 1));
|
|
}
|
|
if (typeof value === "object") {
|
|
const result = {};
|
|
for (const [childKey, childValue] of Object.entries(value)) {
|
|
result[childKey] = sanitizeValue(childValue, childKey, depth + 1);
|
|
}
|
|
return result;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function buildGraphSummary(graph = null) {
|
|
const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
|
|
const edges = Array.isArray(graph?.edges) ? graph.edges : [];
|
|
const activeNodes = nodes.filter((node) => !node?.archived);
|
|
const archivedNodes = nodes.filter((node) => node?.archived);
|
|
const typeCounts = {};
|
|
for (const node of activeNodes) {
|
|
const type = String(node?.type || "unknown");
|
|
typeCounts[type] = (typeCounts[type] || 0) + 1;
|
|
}
|
|
return {
|
|
nodeCount: nodes.length,
|
|
activeNodeCount: activeNodes.length,
|
|
archivedNodeCount: archivedNodes.length,
|
|
edgeCount: edges.length,
|
|
typeCounts,
|
|
historyState: safeClone(
|
|
{
|
|
chatId: graph?.historyState?.chatId || "",
|
|
extractionCount: Number(graph?.historyState?.extractionCount || 0),
|
|
lastProcessedAssistantFloor: Number(
|
|
graph?.historyState?.lastProcessedAssistantFloor ?? -1,
|
|
),
|
|
activeRegion: String(graph?.historyState?.activeRegion || ""),
|
|
activeStorySegmentId: String(
|
|
graph?.historyState?.activeStorySegmentId || "",
|
|
),
|
|
activeStoryTimeLabel: String(
|
|
graph?.historyState?.activeStoryTimeLabel || "",
|
|
),
|
|
activeRecallOwnerKey: String(
|
|
graph?.historyState?.activeRecallOwnerKey || "",
|
|
),
|
|
activeRecallOwnerKeys: Array.isArray(
|
|
graph?.historyState?.activeRecallOwnerKeys,
|
|
)
|
|
? graph.historyState.activeRecallOwnerKeys.map((value) => String(value || ""))
|
|
: [],
|
|
lastRecoveryResult: graph?.historyState?.lastRecoveryResult || null,
|
|
},
|
|
null,
|
|
),
|
|
vectorIndexState: safeClone(
|
|
{
|
|
mode: String(graph?.vectorIndexState?.mode || ""),
|
|
source: String(graph?.vectorIndexState?.source || ""),
|
|
dirty: Boolean(graph?.vectorIndexState?.dirty),
|
|
dirtyReason: String(graph?.vectorIndexState?.dirtyReason || ""),
|
|
lastWarning: String(graph?.vectorIndexState?.lastWarning || ""),
|
|
collectionId: String(graph?.vectorIndexState?.collectionId || ""),
|
|
indexedCount: Number(
|
|
Object.keys(graph?.vectorIndexState?.hashToNodeId || {}).length || 0,
|
|
),
|
|
},
|
|
null,
|
|
),
|
|
summaryState: safeClone(
|
|
{
|
|
enabled: graph?.summaryState?.enabled !== false,
|
|
lastSummarizedExtractionCount: Number(
|
|
graph?.summaryState?.lastSummarizedExtractionCount || 0,
|
|
),
|
|
lastSummarizedAssistantFloor: Number(
|
|
graph?.summaryState?.lastSummarizedAssistantFloor ?? -1,
|
|
),
|
|
},
|
|
null,
|
|
),
|
|
};
|
|
}
|
|
|
|
function buildStatusSnapshot(status = null) {
|
|
if (!status || typeof status !== "object" || Array.isArray(status)) {
|
|
return null;
|
|
}
|
|
return safeClone(
|
|
{
|
|
text: String(status.text || ""),
|
|
meta: truncateText(status.meta || "", 2000),
|
|
level: String(status.level || "idle"),
|
|
updatedAt: Number(status.updatedAt || 0),
|
|
},
|
|
null,
|
|
);
|
|
}
|
|
|
|
export function buildAuthorityPerformanceBaseline({
|
|
chatId = "",
|
|
graphPersistence = null,
|
|
graph = null,
|
|
consistencyAudit = null,
|
|
} = {}) {
|
|
const persistence =
|
|
graphPersistence && typeof graphPersistence === "object" && !Array.isArray(graphPersistence)
|
|
? graphPersistence
|
|
: {};
|
|
const runtimeGraph = graph && typeof graph === "object" && !Array.isArray(graph) ? graph : {};
|
|
const audit =
|
|
consistencyAudit && typeof consistencyAudit === "object" && !Array.isArray(consistencyAudit)
|
|
? consistencyAudit
|
|
: persistence.authorityConsistencyAudit &&
|
|
typeof persistence.authorityConsistencyAudit === "object" &&
|
|
!Array.isArray(persistence.authorityConsistencyAudit)
|
|
? persistence.authorityConsistencyAudit
|
|
: null;
|
|
const loadDiagnostics =
|
|
persistence.loadDiagnostics && typeof persistence.loadDiagnostics === "object"
|
|
? persistence.loadDiagnostics
|
|
: {};
|
|
const persistDelta =
|
|
persistence.persistDelta && typeof persistence.persistDelta === "object"
|
|
? persistence.persistDelta
|
|
: {};
|
|
const recentJobs = Array.isArray(persistence.authorityRecentJobs)
|
|
? persistence.authorityRecentJobs
|
|
: [];
|
|
const failedJobs = recentJobs.filter((job) => {
|
|
const queueState = String(job?.queueState || "").trim();
|
|
return queueState === "failed" || queueState === "error";
|
|
});
|
|
const runningJobs = recentJobs.filter(
|
|
(job) => String(job?.queueState || "").trim() === "running",
|
|
);
|
|
const graphRevision = Number(
|
|
runtimeGraph?.meta?.revision || persistence.revision || 0,
|
|
);
|
|
return {
|
|
kind: "authority-performance-baseline",
|
|
capturedAt: new Date().toISOString(),
|
|
chatId: normalizeRecordId(chatId || persistence.chatId || runtimeGraph?.chatId),
|
|
graphRevision: Number.isFinite(graphRevision) ? graphRevision : 0,
|
|
graphNodeCount: Array.isArray(runtimeGraph?.nodes) ? runtimeGraph.nodes.length : 0,
|
|
graphEdgeCount: Array.isArray(runtimeGraph?.edges) ? runtimeGraph.edges.length : 0,
|
|
extractionCount: Number(runtimeGraph?.historyState?.extractionCount || 0),
|
|
load: safeClone(
|
|
{
|
|
state: String(persistence.loadState || ""),
|
|
source: String(loadDiagnostics.source || ""),
|
|
totalMs: Number(loadDiagnostics.totalMs || 0),
|
|
preApplyMs: Number(loadDiagnostics.preApplyMs || 0),
|
|
exportSnapshotMs: Number(loadDiagnostics.exportSnapshotMs || 0),
|
|
hydrateMs: Number(loadDiagnostics.hydrateMs || 0),
|
|
hydrateNativeRecordsMs: Number(loadDiagnostics.hydrateNativeRecordsMs || 0),
|
|
applyRuntimeMs: Number(loadDiagnostics.applyRuntimeMs || 0),
|
|
updatedAt: String(loadDiagnostics.updatedAt || ""),
|
|
},
|
|
null,
|
|
),
|
|
persist: safeClone(
|
|
{
|
|
totalMs: Number(persistDelta.totalMs || persistDelta.buildMs || 0),
|
|
buildMs: Number(persistDelta.buildMs || 0),
|
|
baseSnapshotReadMs: Number(persistDelta.baseSnapshotReadMs || 0),
|
|
snapshotBuildMs: Number(persistDelta.snapshotBuildMs || 0),
|
|
prepareMs: Number(persistDelta.prepareMs || 0),
|
|
nativeAttemptMs: Number(persistDelta.nativeAttemptMs || 0),
|
|
lookupMs: Number(persistDelta.lookupMs || 0),
|
|
jsDiffMs: Number(persistDelta.jsDiffMs || 0),
|
|
hydrateMs: Number(persistDelta.hydrateMs || 0),
|
|
commitQueueWaitMs: Number(persistDelta.commitQueueWaitMs || 0),
|
|
commitMs: Number(persistDelta.commitMs || 0),
|
|
commitPayloadBytes: Number(persistDelta.commitPayloadBytes || 0),
|
|
commitWalBytes: Number(persistDelta.commitWalBytes || 0),
|
|
updatedAt: String(persistDelta.updatedAt || ""),
|
|
},
|
|
null,
|
|
),
|
|
soak: {
|
|
recentJobCount: recentJobs.length,
|
|
runningJobCount: runningJobs.length,
|
|
failedJobCount: failedJobs.length,
|
|
lastJobId: String(persistence.authorityLastJobId || ""),
|
|
lastJobStatus: String(persistence.authorityLastJobStatus || ""),
|
|
lastJobUpdatedAt: String(persistence.authorityLastJobUpdatedAt || ""),
|
|
},
|
|
audit: safeClone(
|
|
{
|
|
state: String(persistence.authorityConsistencyState || audit?.summary?.level || "idle"),
|
|
issueCount: Array.isArray(audit?.issues) ? audit.issues.length : 0,
|
|
sqlRevision: Number(audit?.sql?.revision || 0),
|
|
triviumRevision: Number(audit?.trivium?.revision || 0),
|
|
blobRevision: Number(
|
|
audit?.blob?.revision || persistence.authorityBlobCheckpointRevision || 0,
|
|
),
|
|
},
|
|
null,
|
|
),
|
|
artifacts: safeClone(
|
|
{
|
|
diagnosticsBundlePath: String(persistence.authorityDiagnosticsBundlePath || ""),
|
|
diagnosticsBundleReason: String(persistence.authorityDiagnosticsBundleReason || ""),
|
|
diagnosticsBundleUpdatedAt: String(
|
|
persistence.authorityDiagnosticsBundleUpdatedAt || "",
|
|
),
|
|
diagnosticsBundleSize: Number(persistence.authorityDiagnosticsBundleSize || 0),
|
|
blobCheckpointPath: String(persistence.authorityBlobCheckpointPath || ""),
|
|
blobCheckpointRevision: Number(persistence.authorityBlobCheckpointRevision || 0),
|
|
blobCheckpointUpdatedAt: String(
|
|
persistence.authorityBlobCheckpointUpdatedAt || "",
|
|
),
|
|
},
|
|
null,
|
|
),
|
|
};
|
|
}
|
|
|
|
export function sanitizeDiagnosticsSettings(settings = {}) {
|
|
return sanitizeValue(settings, "settings", 0);
|
|
}
|
|
|
|
export function buildAuthorityDiagnosticsBundlePath(chatId = "", reason = "diagnostics") {
|
|
const normalizedChatId = normalizeRecordId(chatId);
|
|
const safeChatId = buildSafeSlug(normalizedChatId || "global");
|
|
const safeReason = buildSafeSlug(reason || "diagnostics", "diagnostics");
|
|
const hash = buildHash(`${normalizedChatId}:${safeReason}`);
|
|
const timestamp = buildCompactTimestamp(new Date());
|
|
return `user/files/ST-BME_diagnostics_${safeChatId}-${safeReason}-${hash}-${timestamp}.json`;
|
|
}
|
|
|
|
export function buildAuthorityDiagnosticsBundle({
|
|
chatId = "",
|
|
reason = "diagnostics-bundle",
|
|
settings = {},
|
|
runtimeStatus = null,
|
|
runtimeDebug = null,
|
|
graphPersistence = null,
|
|
graph = null,
|
|
lastExtractionStatus = null,
|
|
lastVectorStatus = null,
|
|
lastRecallStatus = null,
|
|
lastBatchStatus = null,
|
|
lastInjection = "",
|
|
lastExtract = [],
|
|
lastRecall = [],
|
|
performanceBaseline = null,
|
|
} = {}) {
|
|
const createdAt = new Date().toISOString();
|
|
return {
|
|
kind: "st-bme-authority-diagnostics",
|
|
bundleVersion: 1,
|
|
createdAt,
|
|
chatId: normalizeRecordId(chatId),
|
|
reason: String(reason || "diagnostics-bundle"),
|
|
settings: sanitizeDiagnosticsSettings(settings || {}),
|
|
runtimeStatus: buildStatusSnapshot(runtimeStatus),
|
|
runtimeDebug: safeClone(runtimeDebug, null),
|
|
graphPersistence: safeClone(graphPersistence, null),
|
|
graphSummary: buildGraphSummary(graph),
|
|
performanceBaseline: safeClone(performanceBaseline, null),
|
|
lastStatuses: {
|
|
extraction: buildStatusSnapshot(lastExtractionStatus),
|
|
vector: buildStatusSnapshot(lastVectorStatus),
|
|
recall: buildStatusSnapshot(lastRecallStatus),
|
|
batch: safeClone(lastBatchStatus, null),
|
|
},
|
|
lastInjection: {
|
|
textPreview: truncateText(lastInjection, 4000),
|
|
textLength: String(lastInjection || "").length,
|
|
},
|
|
recentExtractedItems: safeClone(
|
|
(Array.isArray(lastExtract) ? lastExtract : []).slice(0, 20),
|
|
[],
|
|
),
|
|
recentRecalledItems: safeClone(
|
|
(Array.isArray(lastRecall) ? lastRecall : []).slice(0, 20),
|
|
[],
|
|
),
|
|
};
|
|
}
|
|
|
|
export async function writeAuthorityDiagnosticsBundle(adapter, bundle = null, options = {}) {
|
|
if (!adapter || typeof adapter.writeJson !== "function") {
|
|
throw new Error("Authority diagnostics adapter unavailable");
|
|
}
|
|
const chatId = normalizeRecordId(options.chatId || bundle?.chatId);
|
|
const reason = String(options.reason || bundle?.reason || "diagnostics-bundle");
|
|
const path =
|
|
options.path || buildAuthorityDiagnosticsBundlePath(chatId, reason);
|
|
const result = await adapter.writeJson(path, safeClone(bundle, bundle), {
|
|
signal: options.signal,
|
|
metadata: safeClone(
|
|
{
|
|
chatId,
|
|
reason,
|
|
kind: "diagnostics-bundle",
|
|
bundleVersion: Number(bundle?.bundleVersion || 1),
|
|
createdAt: bundle?.createdAt || new Date().toISOString(),
|
|
},
|
|
{},
|
|
),
|
|
});
|
|
return {
|
|
ok: result?.ok !== false,
|
|
path: String(result?.path || path),
|
|
result,
|
|
};
|
|
}
|