@kontourai/survey 0.4.6 → 0.4.8

package/dist/src/review-workbench/review-queue-session.js

@@ -0,0 +1,275 @@
+import { publicDirectoryReviewItemFixture, reviewWorkbenchQueueFixtures } from "./review-workbench-data.js";
+import { reviewResourceApiVersion, } from "../../src/review-resource.js";
+export const reviewWorkbenchSessionStorageKey = "kontourai.survey.review-workbench.session-events.v1";
+export const defaultReviewSessionName = "review-workbench-session";
+export const workbenchDecisionDefinitions = {
+    "accept-proposed": {
+        label: "Accept proposed",
+        effect: "Proposed value becomes the verified review outcome.",
+        candidateRole: "proposed",
+        status: "verified",
+    },
+    "keep-current": {
+        label: "Keep current",
+        effect: "Current value remains the verified review outcome.",
+        candidateRole: "current",
+        status: "verified",
+    },
+    "reject-proposed": {
+        label: "Reject proposed",
+        effect: "Proposed value is rejected and the current value remains unmodified.",
+        candidateRole: "proposed",
+        status: "rejected",
+    },
+};
+export function initialReviewWorkbenchState(item = publicDirectoryReviewItemFixture) {
+    return {
+        item,
+        note: "",
+        decision: undefined,
+        reviewedAt: "2026-06-04T00:00:00.000Z",
+        actorId: "review-workbench-operator",
+    };
+}
+export function initialReviewQueueSessionState(items = reviewWorkbenchQueueFixtures) {
+    return {
+        items,
+        activeItemName: items[0]?.metadata.name ?? "",
+        notesByItemName: {},
+        decisionsByItemName: {},
+        reviewedAt: "2026-06-04T00:00:00.000Z",
+        actorId: "review-workbench-operator",
+    };
+}
+export function currentReviewWorkbenchState(session) {
+    const item = currentReviewItem(session);
+    return {
+        item,
+        note: session.notesByItemName[item.metadata.name] ?? "",
+        decision: session.decisionsByItemName[item.metadata.name],
+        reviewedAt: session.reviewedAt,
+        actorId: session.actorId,
+    };
+}
+export function currentReviewItem(session) {
+    const item = session.items.find((entry) => entry.metadata.name === session.activeItemName) ?? session.items[0];
+    if (!item) {
+        throw new Error("Review queue session has no ReviewItems.");
+    }
+    return item;
+}
+export function deriveQueueRowStatus(item, session) {
+    const decision = session.decisionsByItemName[item.metadata.name];
+    if (decision === "reject-proposed") {
+        return "rejected";
+    }
+    if (decision === "accept-proposed" || decision === "keep-current" || item.spec.candidateSetStatus === "resolved") {
+        return "resolved";
+    }
+    if (item.spec.candidateSetStatus === "escalated") {
+        return "escalated";
+    }
+    if (item.metadata.name === session.activeItemName) {
+        return "in-review";
+    }
+    return "pending";
+}
+export function nextUnresolvedItemName(session) {
+    const activeIndex = session.items.findIndex((item) => item.metadata.name === session.activeItemName);
+    const orderedItems = [
+        ...session.items.slice(Math.max(activeIndex, 0) + 1),
+        ...session.items.slice(0, Math.max(activeIndex, 0) + 1),
+    ];
+    return orderedItems.find((item) => deriveQueueRowStatus(item, session) === "pending")?.metadata.name;
+}
+export function reviewSessionSummary(session) {
+    return session.items.reduce((summary, item) => {
+        const decision = session.decisionsByItemName[item.metadata.name];
+        if (decision === "accept-proposed") {
+            return { ...summary, accepted: summary.accepted + 1 };
+        }
+        if (decision === "keep-current") {
+            return { ...summary, keptCurrent: summary.keptCurrent + 1 };
+        }
+        if (decision === "reject-proposed") {
+            return { ...summary, rejected: summary.rejected + 1 };
+        }
+        if (item.spec.candidateSetStatus === "escalated") {
+            return { ...summary, escalated: summary.escalated + 1 };
+        }
+        if (item.spec.candidateSetStatus === "resolved") {
+            return { ...summary, accepted: summary.accepted + 1 };
+        }
+        return { ...summary, unresolved: summary.unresolved + 1 };
+    }, {
+        accepted: 0,
+        keptCurrent: 0,
+        rejected: 0,
+        escalated: 0,
+        unresolved: 0,
+    });
+}
+export function candidateForDecision(item, decision) {
+    const definition = workbenchDecisionDefinitions[decision];
+    const candidate = item.spec.candidates.find((entry) => entry.role === definition.candidateRole);
+    if (!candidate) {
+        throw new Error(`ReviewItem ${item.metadata.name} has no ${definition.candidateRole} candidate.`);
+    }
+    return candidate;
+}
+export function selectedCandidateRole(state) {
+    if (!state.decision) {
+        return undefined;
+    }
+    return workbenchDecisionDefinitions[state.decision].candidateRole;
+}
+export function buildReviewSessionResource(session, events = [], sessionName = defaultReviewSessionName) {
+    const summary = reviewSessionSummary(session);
+    const completedAt = summary.unresolved === 0 ? session.reviewedAt : undefined;
+    return {
+        apiVersion: reviewResourceApiVersion,
+        kind: "ReviewSession",
+        metadata: {
+            name: sessionName,
+        },
+        spec: {
+            reviewItemNames: session.items.map((item) => item.metadata.name),
+            actor: {
+                id: session.actorId,
+            },
+            startedAt: session.reviewedAt,
+            completedAt,
+        },
+        status: {
+            activeItemName: session.activeItemName,
+            eventCount: events.length,
+            decisionCount: Object.keys(session.decisionsByItemName).length,
+        },
+    };
+}
+export function buildReviewSessionEvents(session, sessionName = defaultReviewSessionName) {
+    const events = [
+        buildReviewSessionEvent(session, {
+            sessionName,
+            sequence: 1,
+            eventType: "session-started",
+            occurredAt: session.reviewedAt,
+        }),
+        buildReviewSessionEvent(session, {
+            sessionName,
+            sequence: 2,
+            eventType: "item-selected",
+            occurredAt: session.reviewedAt,
+            activeItemName: session.activeItemName,
+            reviewItemName: session.activeItemName,
+        }),
+    ];
+    for (const item of session.items) {
+        const note = session.notesByItemName[item.metadata.name];
+        if (note) {
+            events.push(buildReviewSessionEvent(session, {
+                sessionName,
+                sequence: events.length + 1,
+                eventType: "note-changed",
+                occurredAt: session.reviewedAt,
+                reviewItemName: item.metadata.name,
+                rationale: note,
+            }));
+        }
+        const decision = session.decisionsByItemName[item.metadata.name];
+        if (!decision) {
+            continue;
+        }
+        const candidate = candidateForDecision(item, decision);
+        const definition = workbenchDecisionDefinitions[decision];
+        const reviewDecisionName = `${item.metadata.name}-${decision}`;
+        const data = { workbenchDecision: decision };
+        events.push(buildReviewSessionEvent(session, {
+            sessionName,
+            sequence: events.length + 1,
+            eventType: "decision-changed",
+            occurredAt: session.reviewedAt,
+            reviewItemName: item.metadata.name,
+            reviewDecisionName,
+            candidateId: candidate.id,
+            status: definition.status,
+            data,
+        }));
+        events.push(buildReviewSessionEvent(session, {
+            sessionName,
+            sequence: events.length + 1,
+            eventType: "decision-submitted",
+            occurredAt: session.reviewedAt,
+            reviewItemName: item.metadata.name,
+            reviewDecisionName,
+            candidateId: candidate.id,
+            status: definition.status,
+            rationale: note,
+            data,
+        }));
+    }
+    if (reviewSessionSummary(session).unresolved === 0) {
+        events.push(buildReviewSessionEvent(session, {
+            sessionName,
+            sequence: events.length + 1,
+            eventType: "session-completed",
+            occurredAt: session.reviewedAt,
+        }));
+    }
+    return events;
+}
+export function replayReviewSessionEvents(startState, events) {
+    const sortedEvents = [...events].sort((left, right) => left.spec.sequence - right.spec.sequence);
+    return sortedEvents.reduce((session, event) => {
+        if (event.spec.eventType === "item-selected") {
+            const activeItemName = event.spec.activeItemName ?? event.spec.reviewItemName;
+            return activeItemName && session.items.some((item) => item.metadata.name === activeItemName)
+                ? { ...session, activeItemName }
+                : session;
+        }
+        if (event.spec.eventType === "note-changed" && event.spec.reviewItemName) {
+            return {
+                ...session,
+                notesByItemName: {
+                    ...session.notesByItemName,
+                    [event.spec.reviewItemName]: event.spec.rationale ?? "",
+                },
+            };
+        }
+        if ((event.spec.eventType === "decision-changed" || event.spec.eventType === "decision-submitted")
+            && event.spec.reviewItemName) {
+            const decision = workbenchDecisionFromEvent(event);
+            return decision
+                ? {
+                    ...session,
+                    decisionsByItemName: {
+                        ...session.decisionsByItemName,
+                        [event.spec.reviewItemName]: decision,
+                    },
+                }
+                : session;
+        }
+        return session;
+    }, startState);
+}
+export function buildReviewSessionEvent(session, spec) {
+    return {
+        apiVersion: reviewResourceApiVersion,
+        kind: "ReviewSessionEvent",
+        metadata: {
+            name: `${spec.sessionName}-${String(spec.sequence).padStart(4, "0")}-${spec.eventType}`,
+        },
+        spec: {
+            ...spec,
+            actor: {
+                id: session.actorId,
+            },
+        },
+    };
+}
+function workbenchDecisionFromEvent(event) {
+    const decision = event.spec.data?.workbenchDecision;
+    return typeof decision === "string" && decision in workbenchDecisionDefinitions
+        ? decision
+        : undefined;
+}

package/dist/{examples → src}/review-workbench/review-surface-preview.d.ts

@@ -1,4 +1,4 @@
-import { type ReviewDecision, type ReviewItem } from "../../src/review-resource.js";
+import { type ReviewDecision, type ReviewItem } from "../review-resource.js";
 export interface SurfaceProjectionPreview {
     readonly canonicalClaim: PreviewClaim;
     readonly candidateHistory: PreviewCandidateHistory[];

package/dist/{examples → src}/review-workbench/review-surface-preview.js

@@ -15,7 +15,24 @@ export function buildSurfaceProjectionPreview(item, decision) {
     };
 }
 export function formatValue(value) {
-    return typeof value === "string" ? value : JSON.stringify(value);
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined) {
+        return "";
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
 }
 function selectedPreviewCandidate(item, decision) {
     if (!decision?.spec.candidateId) {

package/dist/{examples → src}/review-workbench/review-workbench-data.d.ts

@@ -1,4 +1,4 @@
-import { type ReviewItem } from "../../src/review-resource.js";
+import { type ReviewItem } from "../review-resource.js";
 export declare const publicDirectoryReviewItemFixture: {
     apiVersion: "survey.kontourai.io/v1alpha1";
     kind: "ReviewItem";

package/dist/{examples → src}/review-workbench/review-workbench-data.js

@@ -1,4 +1,4 @@
-import { reviewResourceApiVersion } from "../../src/review-resource.js";
+import { reviewResourceApiVersion } from "../review-resource.js";
 // Browser-safe mirror of fixtures/public-directory-review-resource.ts.
 // scripts/check-review-workbench.cjs fails if this data drifts from the canonical fixture.
 export const publicDirectoryReviewItemFixture = {