@evomap/evolver-webui 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/observabilityRelations.js

@@ -0,0 +1,93 @@
+import { redactDiagnosticText } from './diagnosticSanitize.js';
+const MAX_ID = 160;
+const MAX_RELATIONS = 50;
+const OPAQUE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,159}$/;
+function safeOpaqueId(value) {
+    if (typeof value !== 'string')
+        return '';
+    const id = value.trim();
+    return OPAQUE_ID_RE.test(id) ? id : '';
+}
+function safeDisplayText(value) {
+    if (typeof value !== 'string')
+        return '';
+    return redactDiagnosticText(value, MAX_ID);
+}
+function safePrUrl(value) {
+    if (typeof value !== 'string')
+        return '';
+    const raw = value.replace(/[\r\n\t]/g, '').trim();
+    if (!raw)
+        return '';
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== 'https:')
+            return '';
+        const host = url.hostname.toLowerCase();
+        if ((host !== 'github.com' && !host.endsWith('.github.com')) || url.port)
+            return '';
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString().slice(0, MAX_ID);
+    }
+    catch {
+        return '';
+    }
+}
+function positivePrNumber(value) {
+    const number = typeof value === 'number' ? value : Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : null;
+}
+function addAsset(out, value, type) {
+    const id = safeOpaqueId(value);
+    if (!id || out.size >= MAX_RELATIONS)
+        return;
+    const key = `${type}:${id}`;
+    if (!out.has(key))
+        out.set(key, { id, assetId: id, type });
+}
+function addAssetArray(out, value, type) {
+    if (!Array.isArray(value))
+        return;
+    for (const item of value)
+        addAsset(out, item, type);
+}
+function relationsFromPayload(payload) {
+    const assets = new Map();
+    addAsset(assets, payload['assetId'] ?? payload['asset_id'], 'asset');
+    addAsset(assets, payload['geneId'] ?? payload['gene'], 'gene');
+    addAsset(assets, payload['capsuleId'] ?? payload['capsule_id'], 'capsule');
+    addAssetArray(assets, payload['assetIds'] ?? payload['asset_ids'], 'asset');
+    addAssetArray(assets, payload['genesUsed'] ?? payload['genes_used'] ?? payload['genes'], 'gene');
+    const traceId = safeOpaqueId(payload['traceId'] ?? payload['trace_id'] ?? payload['trajectoryId'] ?? payload['trajectory_id']);
+    const sessionId = safeOpaqueId(payload['sessionId'] ?? payload['session_id']);
+    const trajectories = traceId || sessionId ? [{ traceId, sessionId }] : [];
+    const url = safePrUrl(payload['pullRequestUrl'] ?? payload['pull_request_url'] ?? payload['prUrl'] ?? payload['pr_url'] ?? payload['githubPrUrl']);
+    const number = positivePrNumber(payload['pullRequestNumber'] ?? payload['pull_request_number'] ?? payload['prNumber'] ?? payload['pr_number'] ?? payload['githubPrNumber']);
+    const repo = safeDisplayText(payload['repo'] ?? payload['repository'] ?? payload['githubRepo']);
+    const pullRequests = url || number !== null ? [{ number, url, repo }] : [];
+    return { assets: [...assets.values()], trajectories, pullRequests };
+}
+function dedupe(items, key) {
+    const out = new Map();
+    for (const item of items) {
+        const itemKey = key(item);
+        if (!itemKey || out.has(itemKey) || out.size >= MAX_RELATIONS)
+            continue;
+        out.set(itemKey, item);
+    }
+    return [...out.values()];
+}
+export function eventRelations(event) {
+    return relationsFromPayload((event.payload ?? {}));
+}
+export function eventListRelations(events) {
+    const relations = events.map(eventRelations);
+    return {
+        assets: dedupe(relations.flatMap((entry) => entry.assets), (item) => `${item.type}:${item.assetId}`),
+        trajectories: dedupe(relations.flatMap((entry) => entry.trajectories), (item) => `${item.traceId}:${item.sessionId}`),
+        pullRequests: dedupe(relations.flatMap((entry) => entry.pullRequests), (item) => `${item.url}:${item.repo}:${item.number ?? ''}`),
+    };
+}

package/dist/personalityDiagnostics.d.ts

@@ -0,0 +1,41 @@
+import { type personality as PersonalityNamespace } from '@evomap/evolver-core';
+export declare const PERSONALITY_DIAGNOSTICS_MAX_STATS = 40;
+export declare const PERSONALITY_DIAGNOSTICS_MAX_HISTORY = 60;
+export type PersonalityAxisValues = Pick<PersonalityNamespace.PersonalityState, 'rigor' | 'creativity' | 'verbosity' | 'risk_tolerance' | 'obedience'>;
+export interface PersonalityDiagnosticStat {
+    key: string;
+    success: number;
+    fail: number;
+    avgScore: number;
+    n: number;
+    updatedAt: string | null;
+}
+export interface PersonalityDiagnosticHistoryEntry {
+    at: string;
+    key: string;
+    outcome: string;
+    score: number | null;
+}
+export interface PersonalityDiagnosticData {
+    current: PersonalityAxisValues;
+    updatedAt: string | null;
+    stats: PersonalityDiagnosticStat[];
+    history: PersonalityDiagnosticHistoryEntry[];
+    truncated: {
+        stats: boolean;
+        history: boolean;
+    };
+}
+export type PersonalityDiagnosticsResult = {
+    available: true;
+    data: PersonalityDiagnosticData;
+} | {
+    available: false;
+    error: 'personality_unavailable';
+};
+export type PersonalityDiagnosticsReader = () => unknown | Promise<unknown>;
+export interface PersonalityDiagnosticsOptions {
+    maxStats?: number;
+    maxHistory?: number;
+}
+export declare function readPersonalityDiagnostics(reader: PersonalityDiagnosticsReader | undefined, options?: PersonalityDiagnosticsOptions): Promise<PersonalityDiagnosticsResult>;

package/dist/personalityDiagnostics.js

@@ -0,0 +1,101 @@
+import { personality } from '@evomap/evolver-core';
+import { redactDiagnosticText } from './diagnosticSanitize.js';
+export const PERSONALITY_DIAGNOSTICS_MAX_STATS = 40;
+export const PERSONALITY_DIAGNOSTICS_MAX_HISTORY = 60;
+const MAX_TEXT_CHARS = 240;
+function boundedInteger(value, fallback, maximum) {
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(maximum, Math.floor(value)));
+}
+function finiteNumber(value, fallback = 0) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function nonnegativeInteger(value) {
+    return Math.max(0, Math.floor(finiteNumber(value)));
+}
+function replaceControlCharacters(value) {
+    let out = '';
+    for (const char of value) {
+        const code = char.codePointAt(0) ?? 0;
+        out += code < 0x20 || code === 0x7f ? ' ' : char;
+    }
+    return out;
+}
+function boundedText(value, maxChars = MAX_TEXT_CHARS) {
+    return replaceControlCharacters(String(value ?? '')).slice(0, maxChars);
+}
+function nullableTimestamp(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = boundedText(value, 64);
+    return Number.isNaN(Date.parse(text)) ? null : text;
+}
+function axisValue(value) {
+    return Math.max(0, Math.min(1, finiteNumber(value)));
+}
+function currentAxes(value) {
+    const record = value && typeof value === 'object' ? value : {};
+    return {
+        rigor: axisValue(record['rigor']),
+        creativity: axisValue(record['creativity']),
+        verbosity: axisValue(record['verbosity']),
+        risk_tolerance: axisValue(record['risk_tolerance']),
+        obedience: axisValue(record['obedience']),
+    };
+}
+function statRows(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    return Object.entries(value).map(([key, raw]) => {
+        const record = raw && typeof raw === 'object' ? raw : {};
+        return {
+            key: redactDiagnosticText(key, MAX_TEXT_CHARS),
+            success: nonnegativeInteger(record['success']),
+            fail: nonnegativeInteger(record['fail']),
+            avgScore: axisValue(record['avgScore']),
+            n: nonnegativeInteger(record['n']),
+            updatedAt: nullableTimestamp(record['updatedAt']),
+        };
+    }).sort((left, right) => (right.updatedAt ?? '').localeCompare(left.updatedAt ?? ''));
+}
+function historyRows(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((raw) => {
+        const record = raw && typeof raw === 'object' ? raw : {};
+        return {
+            at: nullableTimestamp(record['at']) ?? '',
+            key: redactDiagnosticText(record['key'], MAX_TEXT_CHARS),
+            outcome: redactDiagnosticText(record['outcome'], MAX_TEXT_CHARS),
+            score: record['score'] === null ? null : axisValue(record['score']),
+        };
+    });
+}
+export async function readPersonalityDiagnostics(reader, options = {}) {
+    if (!reader)
+        return { available: false, error: 'personality_unavailable' };
+    try {
+        const raw = await reader();
+        const parsed = personality.personalityModel.safeParse(raw);
+        if (!parsed.success)
+            return { available: false, error: 'personality_unavailable' };
+        const maxStats = boundedInteger(options.maxStats, PERSONALITY_DIAGNOSTICS_MAX_STATS, PERSONALITY_DIAGNOSTICS_MAX_STATS);
+        const maxHistory = boundedInteger(options.maxHistory, PERSONALITY_DIAGNOSTICS_MAX_HISTORY, PERSONALITY_DIAGNOSTICS_MAX_HISTORY);
+        const stats = statRows(parsed.data.stats);
+        const history = historyRows(parsed.data.history);
+        return {
+            available: true,
+            data: {
+                current: currentAxes(parsed.data.current),
+                updatedAt: nullableTimestamp(parsed.data.updatedAt),
+                stats: stats.slice(0, maxStats),
+                history: history.slice(-maxHistory).reverse(),
+                truncated: { stats: stats.length > maxStats, history: history.length > maxHistory },
+            },
+        };
+    }
+    catch {
+        return { available: false, error: 'personality_unavailable' };
+    }
+}

package/dist/server.d.ts

@@ -1,11 +1,57 @@
 import { events as ev, assetstore, mailbox as mb, ops } from '@evomap/evolver-core';
 import { type EventSnapshotSource } from './eventSnapshot.js';
+export interface MemoryGraphStatus {
+    recovery: 'healthy' | 'degraded' | 'recovered' | 'empty';
+    compactedRecords: number;
+    activeRecords: number;
+    corruptLines: number;
+    oversizedLines: number;
+    oversizedFiles: number;
+    archives: number;
+    selectionReason?: string;
+}
+export type MemoryGraphStatusResponse = ({
+    available: true;
+} & MemoryGraphStatus) | {
+    available: false;
+    error?: 'memory_graph_unavailable';
+};
+type MaybePromise<T> = T | Promise<T>;
+export interface WorkflowRunSummary {
+    runId: string;
+    workflowId: string;
+    status: string;
+    currentStep: string | null;
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+}
+export interface WorkflowHistoryEntry {
+    sequence: number;
+    timestamp: string;
+    type: string;
+    status?: string | null;
+    stepId?: string | null;
+    executionId?: string | null;
+    gateId?: string | null;
+    attempt?: number | null;
+    actorId?: string | null;
+    errorClass?: string | null;
+}
+/** Operator-safe workflow projection. Filesystem paths and raw durable state remain owned by the composition layer. */
+export interface WorkflowProvider {
+    listRuns(): MaybePromise<readonly WorkflowRunSummary[]>;
+    getRun(runId: string): MaybePromise<WorkflowRunSummary | null>;
+    getHistory(runId: string): MaybePromise<readonly WorkflowHistoryEntry[] | null>;
+}
 export interface WebUIServerDeps {
     eventsPath: string;
     ingestor?: ev.Ingestor;
     store?: assetstore.AssetStoreProvider;
     /** 人审队列用的 review ledger(#117 人审门）。缺省由 LocalJsonlProvider store 的 baseDir 推导。 */
     review?: assetstore.ReviewLedger;
+    /** Optional provenance sidecar; inferred for a LocalJsonlProvider when absent. */
+    provenance?: assetstore.ProvenanceStore;
     mailbox?: mb.MailboxStore;
     now?: () => number;
     host?: string;
@@ -22,8 +68,16 @@ export interface WebUIServerDeps {
     valueSummary?: (window: ops.SummaryWindow, events: readonly ev.ReportEvent[]) => ops.ValueSummary;
     /** Shared core retention report provider. Kept injectable so WebUI never owns filesystem policy or paths. */
     retentionReport?: () => ev.RetentionReport;
+    /** Read-only, already scoped MemoryGraph operator status. Re-read for every request; WebUI only exposes a sanitized allowlist. */
+    memoryGraphStatus?: () => MemoryGraphStatus;
     /** Injectable file/source seam for versioned root-event snapshots. */
     eventSource?: EventSnapshotSource;
+    /** Optional bounded diagnostics providers. Each source degrades independently. */
+    personalityDiagnostics?: () => unknown | Promise<unknown>;
+    logDiagnostics?: () => unknown | Promise<unknown>;
+    githubPrDiagnostics?: () => unknown | Promise<unknown>;
+    /** Durable workflow visibility provider. Only safe summaries/history metadata may cross this boundary. */
+    workflow?: WorkflowProvider;
 }
 /**
  * WebUI 控台(M7): 可观测 + 保活. node:http + 自包含 HTML, 仅绑 loopback.
@@ -38,6 +92,7 @@ export declare class WebUIServer {
     private readonly actorId;
     /** Review ledger backing the human-review queue. Undefined when no LocalJsonlProvider store is available. */
     private readonly review;
+    private readonly provenance;
     /** Token guarding /api/*; supplied by the browser via Bearer, with ?token= retained for compatibility. */
     readonly token: string;
     readonly launchTicket: string;
@@ -50,5 +105,8 @@ export declare class WebUIServer {
     private handle;
     private readJson;
     private json;
+    private apiError;
+    private methodNotAllowed;
     private send;
-}
+}
+export {};