@mindscraft/branch-video-agent-cli 0.3.5 → 0.4.0

package/dist/playtest/errors.js

@@ -0,0 +1,10 @@
+export class PlaytestError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = 'PlaytestError';
+        this.code = code;
+        this.details = details;
+    }
+}

package/dist/playtest/fingerprint.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeScriptForFingerprint(script: unknown): unknown;
+export declare function createScriptFingerprint(script: unknown): string;

package/dist/playtest/fingerprint.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+const EMPTY_ASSETS = {
+    videos: {},
+    images: {},
+    audios: {},
+    speeches: {},
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => canonicalize(item));
+    }
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, canonicalize(item)]));
+}
+export function normalizeScriptForFingerprint(script) {
+    if (!isRecord(script))
+        return canonicalize(script);
+    const normalized = { ...script };
+    delete normalized.editorData;
+    normalized.assets = {
+        ...EMPTY_ASSETS,
+        ...(isRecord(script.assets) ? script.assets : {}),
+    };
+    normalized.resources = {
+        variables: [],
+        ...(isRecord(script.resources) ? script.resources : {}),
+    };
+    if (isRecord(script.metadata)) {
+        const metadata = { ...script.metadata };
+        delete metadata.createdAt;
+        delete metadata.updatedAt;
+        normalized.metadata = metadata;
+    }
+    return canonicalize(normalized);
+}
+export function createScriptFingerprint(script) {
+    const canonicalJson = JSON.stringify(normalizeScriptForFingerprint(script));
+    return `sha256:${createHash('sha256').update(canonicalJson).digest('hex')}`;
+}

package/dist/playtest/graph.d.ts

@@ -0,0 +1,7 @@
+import type { PlaytestEdge } from './types.js';
+export declare function extractPlaytestEdges(script: unknown): PlaytestEdge[];
+export declare function getReachablePlaytestGraph(script: unknown): {
+    entryNodeId: string;
+    reachableNodeIds: string[];
+    reachableEdges: PlaytestEdge[];
+};

package/dist/playtest/graph.js

@@ -0,0 +1,115 @@
+function actionTarget(action, from) {
+    const candidate = action;
+    if (candidate?.type === 'goto' && typeof candidate.target === 'string')
+        return candidate.target;
+    if (candidate?.type === 'end')
+        return '@ended';
+    if (candidate?.type === 'restart' || candidate?.type === 'loop' || candidate?.type === 'seek' || candidate?.type === 'segment')
+        return from;
+    return null;
+}
+function addEdge(edges, from, owner, ownerId, trigger, action, isDefault = false, effects = {}) {
+    const actionRecord = action;
+    const to = actionTarget(action, from);
+    if (!to)
+        return;
+    const valuePart = trigger.value === undefined ? '' : `:${JSON.stringify(trigger.value)}`;
+    const defaultPart = isDefault ? ':default' : '';
+    edges.push({
+        id: `${from}:${owner}:${ownerId}:${trigger.type}${valuePart}${defaultPart}->${to}`,
+        from,
+        to,
+        owner,
+        ownerId,
+        trigger,
+        condition: effects.condition,
+        variableActions: effects.variableActions,
+        inventoryActions: effects.inventoryActions,
+        actionType: String(actionRecord?.type || ''),
+        action: { ...(actionRecord || {}) },
+        default: isDefault || undefined,
+    });
+}
+function addBranchConfigEdges(edges, from, owner, ownerId, config) {
+    for (const rule of config?.rules || []) {
+        const rawTrigger = rule.trigger || { type: 'unknown' };
+        const trigger = {
+            type: rawTrigger.type,
+            value: rawTrigger.value ?? rawTrigger.optionId ?? rawTrigger.optionIds,
+        };
+        addEdge(edges, from, owner, ownerId, trigger, rule.action, false, {
+            condition: rule.condition,
+            variableActions: rule.variableActions,
+            inventoryActions: rule.inventoryActions,
+        });
+    }
+    addEdge(edges, from, owner, ownerId, { type: 'default' }, config?.defaultAction, true);
+}
+export function extractPlaytestEdges(script) {
+    const graph = script?.graph;
+    const nodes = graph?.nodes || {};
+    const edges = [];
+    for (const [nodeId, rawNode] of Object.entries(nodes)) {
+        const node = rawNode || {};
+        if (node.type === 'start')
+            addEdge(edges, nodeId, 'node', nodeId, { type: 'enter' }, node.config?.next);
+        if (node.type === 'video' || node.type === 'image') {
+            addEdge(edges, nodeId, 'node', nodeId, { type: 'complete' }, node.config?.onComplete);
+        }
+        addBranchConfigEdges(edges, nodeId, 'node', nodeId, node.branchConfig);
+        for (const handler of node.config?.messageHandlers || []) {
+            addEdge(edges, nodeId, 'node', nodeId, handler.when || { type: 'message' }, handler.then, false, {
+                variableActions: handler.variableActions,
+                inventoryActions: handler.inventoryActions,
+            });
+        }
+        for (const legacy of node.branches || []) {
+            addEdge(edges, nodeId, 'node', nodeId, { type: 'legacy', value: legacy.when }, legacy.then, false, {
+                condition: typeof legacy.when === 'object' ? legacy.when : undefined,
+                variableActions: legacy.variableActions,
+                inventoryActions: legacy.inventoryActions,
+            });
+        }
+        for (const interaction of node.interactions || []) {
+            addBranchConfigEdges(edges, nodeId, 'interaction', interaction.id, interaction.branchConfig);
+            for (const legacy of interaction.branches || []) {
+                addEdge(edges, nodeId, 'interaction', interaction.id, { type: 'legacy', value: legacy.when }, legacy.then, false, {
+                    condition: typeof legacy.when === 'object' ? legacy.when : undefined,
+                    variableActions: legacy.variableActions,
+                    inventoryActions: legacy.inventoryActions,
+                });
+            }
+            addEdge(edges, nodeId, 'interaction', interaction.id, { type: 'timeout' }, interaction.fallback?.onTimeout);
+            addEdge(edges, nodeId, 'interaction', interaction.id, { type: 'default' }, interaction.fallback?.onDefault, true);
+        }
+    }
+    for (const edge of edges) {
+        if (edge.actionType !== 'restart')
+            continue;
+        const oldTarget = edge.to;
+        edge.to = String(graph?.entryNodeId || edge.from);
+        edge.id = edge.id.replace(`->${oldTarget}`, `->${edge.to}`);
+    }
+    return [...new Map(edges.map((edge) => [edge.id, edge])).values()];
+}
+export function getReachablePlaytestGraph(script) {
+    const graph = script?.graph;
+    const nodes = graph?.nodes || {};
+    const entryNodeId = String(graph?.entryNodeId || '');
+    const allEdges = extractPlaytestEdges(script);
+    const reachableNodeIds = new Set();
+    const reachableEdges = [];
+    const queue = entryNodeId ? [entryNodeId] : [];
+    while (queue.length) {
+        const nodeId = queue.shift();
+        if (reachableNodeIds.has(nodeId))
+            continue;
+        reachableNodeIds.add(nodeId);
+        for (const edge of allEdges.filter((candidate) => candidate.from === nodeId)) {
+            reachableEdges.push(edge);
+            if (nodes[edge.to] && !reachableNodeIds.has(edge.to))
+                queue.push(edge.to);
+        }
+    }
+    return { entryNodeId, reachableNodeIds: [...reachableNodeIds], reachableEdges };
+}

package/dist/playtest/report.d.ts

@@ -0,0 +1,6 @@
+import type { PlaytestReport } from './types.js';
+export declare function createJUnitXml(report: PlaytestReport): string;
+export declare function writePlaytestReport(reportDir: string, report: PlaytestReport): Promise<{
+    jsonPath: string;
+    junitPath: string;
+}>;

package/dist/playtest/report.js

@@ -0,0 +1,34 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+function escapeXml(value) {
+    return String(value)
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;');
+}
+export function createJUnitXml(report) {
+    const scenarioFindingKeys = new Set(report.scenarios.flatMap((scenario) => scenario.findings.map((finding) => `${finding.code}\u0000${finding.message}`)));
+    const gateFindings = report.findings.filter((finding) => !scenarioFindingKeys.has(`${finding.code}\u0000${finding.message}`));
+    const failures = report.scenarios.filter((scenario) => scenario.status === 'failed').length + gateFindings.length;
+    const duration = report.scenarios.reduce((sum, scenario) => sum + scenario.durationMs, 0) / 1000;
+    const scenarioCases = report.scenarios.map((scenario) => {
+        const finding = scenario.findings[0];
+        const failure = finding
+            ? `<failure type="${escapeXml(finding.code)}" message="${escapeXml(finding.message)}">${escapeXml(JSON.stringify(finding.details ?? null))}</failure>`
+            : '';
+        return `<testcase classname="branch-video-playtest" name="${escapeXml(scenario.id)}" time="${(scenario.durationMs / 1000).toFixed(3)}">${failure}</testcase>`;
+    }).join('');
+    const gateCases = gateFindings.map((finding, index) => (`<testcase classname="branch-video-playtest.gate" name="gate-${index + 1}-${escapeXml(finding.code)}" time="0.000"><failure type="${escapeXml(finding.code)}" message="${escapeXml(finding.message)}">${escapeXml(JSON.stringify(finding.details ?? null))}</failure></testcase>`)).join('');
+    const tests = report.scenarios.length + gateFindings.length;
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<testsuite name="branch-video-playtest" tests="${tests}" failures="${failures}" time="${duration.toFixed(3)}">${scenarioCases}${gateCases}</testsuite>\n`;
+}
+export async function writePlaytestReport(reportDir, report) {
+    await mkdir(reportDir, { recursive: true });
+    const jsonPath = path.join(reportDir, 'branch-video-playtest-report.json');
+    const junitPath = path.join(reportDir, 'junit.xml');
+    await writeFile(jsonPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+    await writeFile(junitPath, createJUnitXml(report), 'utf8');
+    return { jsonPath, junitPath };
+}

package/dist/playtest/runner.d.ts

@@ -0,0 +1,23 @@
+import type { PlaytestContract, PlaytestLimits, PlaytestScenario, PlaytestScenarioResult } from './types.js';
+type ScriptRecord = Record<string, any>;
+interface RunnerOptions {
+    script: ScriptRecord;
+    contract: PlaytestContract;
+    scenarios: PlaytestScenario[];
+    playerUrl: string;
+    draftScriptUrl?: string;
+    reportDir: string;
+    concurrency: number;
+    limits: PlaytestLimits;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+export declare function runPlaytestScenarios(options: RunnerOptions): Promise<PlaytestScenarioResult[]>;
+export declare function createDraftPlayerUrl(baseUrl: string): {
+    playerUrl: string;
+    scriptUrl: string;
+};
+export declare function createPublishedPlayerUrl(playUrl: string): string;
+export {};