@lingjingai/scriptctl 0.1.0

package/dist/usecases/script.js

@@ -0,0 +1,949 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { CliError, EXIT_INPUT, EXIT_NEEDS_AGENT, EXIT_OK, EXIT_RUNTIME, EXIT_USAGE, directDir, exists, readJson, readText, scriptJsonPath, sha256Text, writeJson, } from "../common.js";
+import { applyPatchOperations, collectStateRefs, parseStateTarget, validateScript, } from "../domain/script-core.js";
+import { ScriptOutputApiError, ScriptOutputClient } from "../infra/script-output-api.js";
+import { markMetadataConfidenceReviewed, readRunState, reviewBlockers, summarizeIssues, updateRunState, markPatched, } from "./direct.js";
+function strOf(v) {
+    if (v === null || v === undefined)
+        return "";
+    return String(v);
+}
+function isDict(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isList(v) {
+    return Array.isArray(v);
+}
+function asList(v) {
+    return Array.isArray(v) ? v : [];
+}
+// ---------------------------------------------------------------------------
+// ScriptEditSession
+// ---------------------------------------------------------------------------
+export class ScriptEditSession {
+    workspace;
+    script;
+    scriptPath;
+    client;
+    projectGroupNo;
+    revision;
+    constructor(opts) {
+        this.workspace = opts.workspace;
+        this.script = opts.script;
+        this.scriptPath = opts.scriptPath ?? null;
+        this.client = opts.client ?? null;
+        this.projectGroupNo = opts.projectGroupNo ?? null;
+        this.revision = opts.revision ?? null;
+    }
+    get remote() {
+        return this.client !== null;
+    }
+    get artifactLabel() {
+        if (this.remote) {
+            return `db:/script-output/project-groups/${this.projectGroupNo}@revision/${this.revision ?? 0}`;
+        }
+        return this.scriptPath ?? "";
+    }
+}
+function scriptOutputClient(opts) {
+    try {
+        return ScriptOutputClient.fromEnv(strOf(opts["project_group_no"]).trim() || null);
+    }
+    catch (exc) {
+        const msg = exc instanceof Error ? exc.message : String(exc);
+        throw new CliError("SCRIPT API BLOCKED: Gateway configuration missing", msg, {
+            exitCode: EXIT_INPUT,
+            required: ["SCRIPTCTL_GATEWAY_URL/AWB_BASE_URL, SANDBOX_PROJECT_GROUP_NO/--project-group-no, and X-Access-Key credentials"],
+            received: [msg],
+            nextSteps: ["Run inside a project sandbox or pass the missing configuration explicitly."],
+            errorCode: "SCRIPT_API_CONFIG_MISSING",
+        });
+    }
+}
+function apiErrorToCli(title, exc) {
+    const message = exc.message || "script-output API failed";
+    const isConflict = message.includes("版本冲突") || message.toLowerCase().includes("revision");
+    return new CliError(title, message, {
+        exitCode: exc.status !== null && exc.status >= 500 ? EXIT_RUNTIME : EXIT_INPUT,
+        required: ["successful script-output gateway request"],
+        received: [message],
+        nextSteps: [isConflict ? "Reload the latest script revision and retry." : "Check gateway URL, access key, project id, and workbench service status."],
+        errorCode: isConflict ? "SCRIPT_REVISION_CONFLICT" : "SCRIPT_API_FAILED",
+    });
+}
+async function currentRevisionOrZero(client) {
+    try {
+        const revision = await client.getRevision();
+        if (!revision)
+            return 0;
+        return Number(revision["revision"] ?? 0);
+    }
+    catch (exc) {
+        if (exc instanceof ScriptOutputApiError) {
+            throw apiErrorToCli("SCRIPT API BLOCKED: Revision query failed", exc);
+        }
+        throw exc;
+    }
+}
+async function loadRemoteScript(opts, workspace) {
+    const client = scriptOutputClient(opts);
+    let script;
+    let revision;
+    try {
+        script = await client.getScript();
+        revision = await client.getRevision();
+    }
+    catch (exc) {
+        if (exc instanceof ScriptOutputApiError) {
+            throw apiErrorToCli("SCRIPT API BLOCKED: Script query failed", exc);
+        }
+        throw exc;
+    }
+    if (script === null) {
+        throw new CliError("SCRIPT BLOCKED: Final script not found", "Final script data not found.", {
+            exitCode: EXIT_INPUT,
+            required: ["existing script-output project document"],
+            received: [`projectGroupNo=${client.projectGroupNo}`],
+            nextSteps: ["Run scriptctl direct export first, or pass --script-path to edit a local intermediate script JSON."],
+            errorCode: "SCRIPT_NOT_FOUND",
+        });
+    }
+    if (!isDict(script)) {
+        throw new CliError("SCRIPT BLOCKED: script root invalid", "script root invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["script root object"],
+            received: [typeof script],
+            nextSteps: ["Replace the final script with a valid script document object."],
+            errorCode: "SCRIPT_ROOT_INVALID",
+        });
+    }
+    return new ScriptEditSession({
+        workspace,
+        script,
+        client,
+        projectGroupNo: client.projectGroupNo,
+        revision: Number((revision ?? {})["revision"] ?? 0),
+    });
+}
+async function loadScriptForEdit(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    if (!opts["script_path"]) {
+        return loadRemoteScript(opts, workspace);
+    }
+    const p = scriptJsonPath(opts);
+    if (!exists(p)) {
+        throw new CliError("SCRIPT BLOCKED: Local script file not found", "Local script file not found.", {
+            exitCode: EXIT_INPUT,
+            required: ["--script-path existing local script JSON"],
+            received: [p],
+            nextSteps: ["Pass --script-path to an existing local intermediate script JSON, or omit --script-path to use DB-backed script-output."],
+            errorCode: "SCRIPT_NOT_FOUND",
+        });
+    }
+    let data;
+    try {
+        data = readJson(p);
+    }
+    catch (exc) {
+        throw new CliError("SCRIPT BLOCKED: script JSON invalid", "script JSON invalid.", {
+            exitCode: EXIT_INPUT,
+            required: ["valid JSON"],
+            received: [`${p}: ${exc.message}`],
+            nextSteps: ["Fix the local script JSON syntax before editing."],
+            errorCode: "SCRIPT_JSON_INVALID",
+        });
+    }
+    if (!isDict(data)) {
+        throw new CliError("SCRIPT BLOCKED: script root invalid", "script root invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["script root object"],
+            received: [Array.isArray(data) ? "array" : typeof data],
+            nextSteps: ["Use a valid script document object."],
+            errorCode: "SCRIPT_ROOT_INVALID",
+        });
+    }
+    return new ScriptEditSession({ workspace, scriptPath: p, script: data });
+}
+function validateSession(session, opts = {}) {
+    const requireSource = opts.requireSource ?? false;
+    if (!session.remote) {
+        return validateScript(session.workspace, session.scriptPath, { requireSource });
+    }
+    const tmpPath = path.join(os.tmpdir(), `scriptctl-db-script-${randomUUID()}.json`);
+    try {
+        fs.writeFileSync(tmpPath, JSON.stringify(session.script, null, 2) + "\n", "utf-8");
+        const validation = validateScript(session.workspace, tmpPath, { requireSource });
+        validation["script_path"] = session.artifactLabel;
+        writeJson(path.join(directDir(session.workspace), "validation.json"), validation);
+        return validation;
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function validationIssuePath(issue) {
+    if (issue["path"])
+        return strOf(issue["path"]);
+    const parts = [];
+    if (issue["episode"] !== null && issue["episode"] !== undefined)
+        parts.push(strOf(issue["episode"]));
+    if (issue["scene"] !== null && issue["scene"] !== undefined)
+        parts.push(strOf(issue["scene"]));
+    if (issue["action_index"] !== null && issue["action_index"] !== undefined)
+        parts.push(`action[${issue["action_index"]}]`);
+    return parts.length > 0 ? parts.join("/") : null;
+}
+function validationIssueSeverity(raw) {
+    const severity = strOf(raw || "info");
+    if (severity === "blocking" || severity === "error")
+        return "error";
+    if (severity === "warning")
+        return "warning";
+    return "info";
+}
+function validationToApiPayload(validation) {
+    const issues = asList(validation["issues"]);
+    const status = validation["passed"] ? "valid" : "invalid";
+    const summary = {
+        passed: Boolean(validation["passed"]),
+        hasBlocking: Boolean(validation["has_blocking"]),
+        stats: validation["stats"] ?? {},
+        issueCount: issues.length,
+    };
+    const apiIssues = [];
+    for (const issue of issues) {
+        if (!isDict(issue))
+            continue;
+        const payload = { ...issue };
+        for (const key of ["severity", "code", "path", "summary", "repair_hint"])
+            delete payload[key];
+        apiIssues.push({
+            severity: validationIssueSeverity(issue["severity"]),
+            code: strOf(issue["code"] || "SCRIPT_VALIDATION_ISSUE"),
+            path: validationIssuePath(issue),
+            summary: strOf(issue["summary"]),
+            repairHint: issue["repair_hint"],
+            payload,
+        });
+    }
+    return [status, summary, apiIssues];
+}
+async function syncValidationResult(session, validation, revision) {
+    if (!session.remote || session.client === null)
+        return;
+    const targetRevision = Number(revision ?? session.revision ?? 0);
+    if (targetRevision <= 0)
+        return;
+    const [status, summary, issues] = validationToApiPayload(validation);
+    try {
+        await session.client.saveValidationResult({
+            revision: targetRevision,
+            validationStatus: status,
+            validationSummary: summary,
+            issues,
+        });
+    }
+    catch (exc) {
+        if (exc instanceof ScriptOutputApiError) {
+            throw apiErrorToCli("SCRIPT API BLOCKED: Validation sync failed", exc);
+        }
+        throw exc;
+    }
+}
+function requestIdForScriptWrite(opts, op) {
+    const explicit = strOf(opts["request_id"]).trim();
+    if (explicit)
+        return explicit;
+    return `scriptctl:${op}:${randomUUID()}`;
+}
+async function saveScriptSession(session, opts, op) {
+    if (!session.remote) {
+        writeJson(session.scriptPath, session.script);
+        return [null, false];
+    }
+    if (session.client === null)
+        throw new Error("remote script session missing client");
+    const requestId = requestIdForScriptWrite(opts, op);
+    let res;
+    try {
+        res = await session.client.replaceScript({
+            requestId,
+            baseRevision: Number(session.revision ?? 0),
+            script: session.script,
+            source: "ctl",
+        });
+    }
+    catch (exc) {
+        if (exc instanceof ScriptOutputApiError) {
+            throw apiErrorToCli("SCRIPT API BLOCKED: Script write failed", exc);
+        }
+        throw exc;
+    }
+    session.revision = Number(res["revision"] ?? session.revision ?? 0);
+    return [session.revision, Boolean(res["idempotent"])];
+}
+function scriptSourceText(workspace) {
+    const sourcePath = path.join(workspace, "source.txt");
+    return exists(sourcePath) ? readText(sourcePath) : "";
+}
+function patchOperationsFromPayload(payload) {
+    let operations;
+    if (isList(payload)) {
+        operations = payload;
+    }
+    else if (isDict(payload) && isList(payload["ops"])) {
+        operations = payload["ops"];
+    }
+    else if (isDict(payload) && isList(payload["operations"])) {
+        operations = payload["operations"];
+    }
+    else if (isDict(payload)) {
+        operations = [payload];
+    }
+    else {
+        throw new CliError("PATCH BLOCKED: Patch schema invalid", "Patch schema invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["object, array, object with ops[], or object with operations[]"],
+            received: [Array.isArray(payload) ? "array" : typeof payload],
+            nextSteps: ["Fix patch JSON and rerun patch."],
+        });
+    }
+    if (operations.some((op) => !isDict(op))) {
+        throw new CliError("PATCH BLOCKED: Patch operation invalid", "Patch operation invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["each operation must be an object"],
+            received: [JSON.stringify(operations).slice(0, 500)],
+            nextSteps: ["Fix patch JSON and rerun patch."],
+        });
+    }
+    return operations;
+}
+// ---------------------------------------------------------------------------
+// command_patch (legacy: applies to script.initial.json directly with source)
+// ---------------------------------------------------------------------------
+export function commandPatch(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const patchPath = strOf(opts["patch"]);
+    const scriptPath = path.join(directDir(workspace), "script.initial.json");
+    const sourcePath = path.join(workspace, "source.txt");
+    if (!exists(patchPath)) {
+        throw new CliError("PATCH BLOCKED: Patch file not found", "Patch file not found.", {
+            exitCode: EXIT_INPUT,
+            required: ["--patch: existing JSON file"],
+            received: [patchPath],
+            nextSteps: ["Write a patch JSON file and rerun patch."],
+        });
+    }
+    if (!exists(scriptPath) || !exists(sourcePath)) {
+        throw new CliError("PATCH BLOCKED: Required artifact missing", "Required artifact missing.", {
+            exitCode: EXIT_INPUT,
+            required: ["source.txt and script.initial.json"],
+            received: [scriptPath, sourcePath],
+            nextSteps: ["Run scriptctl direct init first."],
+        });
+    }
+    let payload;
+    try {
+        payload = readJson(patchPath);
+    }
+    catch (exc) {
+        throw new CliError("PATCH BLOCKED: Patch JSON invalid", "Patch JSON invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["valid JSON patch file"],
+            received: [`${patchPath}: ${exc.message}`],
+            nextSteps: ["Fix patch JSON and rerun patch."],
+        });
+    }
+    const operations = patchOperationsFromPayload(payload);
+    const script = readJson(scriptPath);
+    const applied = applyPatchOperations(script, readText(sourcePath), operations);
+    writeJson(scriptPath, script);
+    markMetadataConfidenceReviewed(workspace, operations);
+    const validation = validateScript(workspace, scriptPath);
+    markPatched(workspace, applied.length);
+    const passed = Boolean(validation["passed"]);
+    const report = {
+        title: passed ? "PATCH APPLIED: Validation passed" : "PATCH APPLIED: Repair issues remain",
+        result: [
+            `operations: ${applied.length}`,
+            `validation: ${passed ? "passed" : "needs repair"}`,
+        ],
+        artifacts: [scriptPath, path.join(directDir(workspace), "validation.json")],
+        issues: summarizeIssues(asList(validation["issues"])),
+        next: [passed ? "Export the final script." : "Inspect remaining issues and apply another patch."],
+    };
+    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+}
+// ---------------------------------------------------------------------------
+// commandScriptValidate / commandScriptInspect
+// ---------------------------------------------------------------------------
+export async function commandScriptValidate(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const session = await loadScriptForEdit(opts);
+    const validation = validateSession(session);
+    await syncValidationResult(session, validation);
+    const stats = validation["stats"] ?? {};
+    const passed = Boolean(validation["passed"]);
+    const report = {
+        title: passed ? "SCRIPT VALIDATE PASSED" : "SCRIPT VALIDATE NEEDS REPAIR",
+        op: "script.validate",
+        changed: false,
+        summary: `episodes=${stats["episodes"] ?? 0}, scenes=${stats["scenes"] ?? 0}, actions=${stats["actions"] ?? 0}`,
+        result: [
+            `episodes: ${stats["episodes"] ?? 0}`,
+            `scenes: ${stats["scenes"] ?? 0}`,
+            `actions: ${stats["actions"] ?? 0}`,
+            `speakers: ${stats["speakers"] ?? 0}`,
+        ],
+        issues: summarizeIssues(asList(validation["issues"])),
+        artifacts: [session.artifactLabel, path.join(directDir(workspace), "validation.json")],
+        next: [passed ? "Continue editing the final script." : "Inspect issues and apply a script patch."],
+    };
+    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+}
+export async function commandScriptInspect(opts) {
+    const session = await loadScriptForEdit(opts);
+    const script = session.script;
+    const target = strOf(opts["target"] || "summary").trim();
+    const itemId = strOf(opts["id"]).trim();
+    const lines = [];
+    if (target === "summary") {
+        const episodes = asList(script["episodes"]);
+        const scenes = [];
+        for (const ep of episodes)
+            scenes.push(...asList(ep["scenes"]));
+        const actions = [];
+        for (const scene of scenes)
+            actions.push(...asList(scene["actions"]));
+        lines.push(`title: ${script["title"] || "-"}`, `episodes: ${episodes.length}`, `scenes: ${scenes.length}`, `actions: ${actions.length}`, `actors: ${asList(script["actors"]).length}`, `locations: ${asList(script["locations"]).length}`, `props: ${asList(script["props"]).length}`, `speakers: ${asList(script["speakers"]).length}`);
+    }
+    else if (target === "episode") {
+        for (const ep of asList(script["episodes"])) {
+            if (itemId && itemId !== strOf(ep["episode_id"]))
+                continue;
+            const scenes = asList(ep["scenes"]);
+            let actionCount = 0;
+            for (const scene of scenes)
+                actionCount += asList(scene["actions"]).length;
+            lines.push(`${ep["episode_id"]}: scenes=${scenes.length}, actions=${actionCount}, title=${ep["title"] || "-"}`);
+        }
+    }
+    else if (target === "asset") {
+        for (const [key, idKey, nameKey] of [
+            ["actors", "actor_id", "actor_name"],
+            ["locations", "location_id", "location_name"],
+            ["props", "prop_id", "prop_name"],
+        ]) {
+            for (const asset of asList(script[key])) {
+                if (itemId && itemId !== strOf(asset[idKey]) && itemId !== strOf(asset[nameKey]))
+                    continue;
+                const singular = key.slice(0, -1);
+                lines.push(`${singular} ${asset[idKey]}: ${asset[nameKey]} states=${asList(asset["states"]).length}`);
+            }
+        }
+    }
+    else if (target === "speaker") {
+        for (const speaker of asList(script["speakers"])) {
+            if (itemId && itemId !== strOf(speaker["speaker_id"]))
+                continue;
+            lines.push(`${speaker["speaker_id"]}: ${speaker["display_name"]} [${speaker["source_kind"]}] source=${speaker["source_id"]}`);
+        }
+    }
+    else if (target === "issue") {
+        const validation = validateSession(session);
+        for (const issue of asList(validation["issues"])) {
+            if (itemId && itemId !== strOf(issue["code"]) && itemId !== strOf(issue["severity"]))
+                continue;
+            const whereParts = [];
+            for (const k of ["episode", "scene", "action_index"]) {
+                if (issue[k] !== null && issue[k] !== undefined)
+                    whereParts.push(strOf(issue[k]));
+            }
+            const where = whereParts.join(" ");
+            lines.push(`${issue["severity"]} ${issue["code"]}: ${issue["summary"]}${where ? ` [${where}]` : ""}`);
+        }
+    }
+    else {
+        throw new CliError("SCRIPT INSPECT BLOCKED: Target invalid", "Target invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["target: summary, episode, asset, speaker, or issue"],
+            received: [target],
+            nextSteps: ["Use a supported target."],
+            errorCode: "INSPECT_TARGET_INVALID",
+        });
+    }
+    const report = {
+        title: `SCRIPT INSPECT: ${target}`,
+        op: "script.inspect",
+        changed: false,
+        summary: `${target}: ${lines.length} item(s)`,
+        result: lines.length > 0 ? lines : ["No matching items."],
+        artifacts: [session.artifactLabel],
+        next: ["Use script subcommands or script patch for edits."],
+    };
+    return [report, EXIT_OK];
+}
+// ---------------------------------------------------------------------------
+// command_script_patch
+// ---------------------------------------------------------------------------
+export async function commandScriptPatch(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const session = await loadScriptForEdit(opts);
+    const script = session.script;
+    const patchPath = strOf(opts["patch"]);
+    if (!exists(patchPath)) {
+        throw new CliError("SCRIPT PATCH BLOCKED: Patch file not found", "Patch file not found.", {
+            exitCode: EXIT_INPUT,
+            required: ["--patch existing JSON file"],
+            received: [patchPath],
+            nextSteps: ["Write patch JSON and rerun."],
+            errorCode: "PATCH_NOT_FOUND",
+        });
+    }
+    let payload;
+    try {
+        payload = readJson(patchPath);
+    }
+    catch (exc) {
+        throw new CliError("SCRIPT PATCH BLOCKED: Patch JSON invalid", "Patch JSON invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["valid JSON patch"],
+            received: [`${patchPath}: ${exc.message}`],
+            nextSteps: ["Fix patch JSON and rerun."],
+            errorCode: "PATCH_JSON_INVALID",
+        });
+    }
+    const operations = patchOperationsFromPayload(payload);
+    const applied = applyPatchOperations(script, scriptSourceText(workspace), operations);
+    const [newRevision, idempotent] = await saveScriptSession(session, opts, applied.length === 1 ? applied[0] : "script.patch");
+    const validation = validateSession(session);
+    await syncValidationResult(session, validation, newRevision);
+    const passed = Boolean(validation["passed"]);
+    const resultLines = [
+        `operations: ${applied.length}`,
+        `validation: ${passed ? "passed" : "needs repair"}`,
+    ];
+    if (session.remote) {
+        resultLines.push(`revision: ${newRevision}`);
+        resultLines.push(`idempotent: ${String(idempotent).toLowerCase()}`);
+    }
+    const report = {
+        title: passed ? "SCRIPT PATCH APPLIED" : "SCRIPT PATCH APPLIED: Validation needs repair",
+        op: applied.length === 1 ? applied[0] : "script.patch",
+        changed: applied.length > 0,
+        summary: `applied ${applied.length} operation(s)`,
+        warnings: passed ? [] : summarizeIssues(asList(validation["issues"])),
+        result: resultLines,
+        issues: summarizeIssues(asList(validation["issues"])),
+        artifacts: [session.artifactLabel, path.join(directDir(workspace), "validation.json")],
+        next: [passed ? "Continue editing the final script." : "Inspect issues and apply another patch."],
+    };
+    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+}
+// ---------------------------------------------------------------------------
+// Single-op helpers
+// ---------------------------------------------------------------------------
+async function applySingleScriptOp(opts, op) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const session = await loadScriptForEdit(opts);
+    const script = session.script;
+    const applied = applyPatchOperations(script, scriptSourceText(workspace), [op]);
+    const opName = applied[0] ?? strOf(op["op"]);
+    const [newRevision, idempotent] = await saveScriptSession(session, opts, opName);
+    const validation = validateSession(session);
+    await syncValidationResult(session, validation, newRevision);
+    const passed = Boolean(validation["passed"]);
+    const resultLines = [
+        `operation: ${opName}`,
+        `validation: ${passed ? "passed" : "needs repair"}`,
+    ];
+    if (session.remote) {
+        resultLines.push(`revision: ${newRevision}`);
+        resultLines.push(`idempotent: ${String(idempotent).toLowerCase()}`);
+    }
+    const report = {
+        title: passed ? "SCRIPT OP APPLIED" : "SCRIPT OP APPLIED: Validation needs repair",
+        op: opName,
+        changed: applied.length > 0,
+        summary: summarizeScriptOp(script, op),
+        warnings: passed ? [] : summarizeIssues(asList(validation["issues"])),
+        result: resultLines,
+        issues: summarizeIssues(asList(validation["issues"])),
+        artifacts: [session.artifactLabel, path.join(directDir(workspace), "validation.json")],
+        next: [passed ? "Continue editing the final script." : "Inspect issues and apply another patch."],
+    };
+    return [report, passed ? EXIT_OK : EXIT_NEEDS_AGENT];
+}
+function summarizeScriptOp(_script, op) {
+    const kind = strOf(op["op"]);
+    if (kind === "state.add")
+        return `已为 ${op["target"]} 新增状态 ${op["state_id"]}: ${op["name"] || op["state_name"]}`;
+    if (kind === "action.state.change")
+        return `已在 ${op["at"]} 为 ${op["target"]} 设置状态切换到 ${op["to"] || op["to_state_id"]}`;
+    if (kind.startsWith("state."))
+        return `已执行 ${kind}: ${op["target"]}`;
+    if (kind.startsWith("dialogue."))
+        return `已执行 ${kind}: ${op["at"]}`;
+    return `已执行 ${kind}`;
+}
+async function commandStateRefs(opts, plan = false) {
+    const session = await loadScriptForEdit(opts);
+    const script = session.script;
+    const args = asList(opts["_args"]);
+    const [targetKind, targetId, stateId] = parseStateTarget(args[0] ?? "");
+    // Verify state exists (will throw if not)
+    const _asset = (() => {
+        for (const asset of asList(script[`${targetKind}s`])) {
+            if (strOf(asset[`${targetKind}_id`]) === targetId) {
+                for (const st of asList(asset["states"])) {
+                    if (strOf(st["state_id"]) === stateId)
+                        return st;
+                }
+            }
+        }
+        throw new CliError("SCRIPT OP BLOCKED: State not found", "State not found.", {
+            exitCode: EXIT_USAGE,
+            required: ["existing state_id on the target asset"],
+            received: [`${targetKind}:${targetId}/${stateId}`],
+            nextSteps: ["Inspect states and fix the target."],
+            errorCode: "STATE_NOT_FOUND",
+        });
+    })();
+    void _asset;
+    const refs = collectStateRefs(script, targetKind, targetId, stateId);
+    const report = {
+        title: plan ? "SCRIPT STATE DELETE PLAN" : "SCRIPT STATE REFS",
+        op: plan ? "state.delete-plan" : "state.refs",
+        changed: false,
+        summary: `${targetKind}:${targetId}/${stateId} refs=${refs.length}`,
+        result: refs.length > 0 ? refs.map((r) => JSON.stringify(r)) : ["No references."],
+        refs: refs,
+        artifacts: [session.artifactLabel],
+        next: plan && refs.length > 0
+            ? ["Choose replace/remove strategy. Do not delete silently when references affect story continuity."]
+            : [plan ? "State can be deleted directly." : "Use delete-plan before deleting a state."],
+    };
+    return [report, EXIT_OK];
+}
+export async function commandScriptState(opts, action) {
+    const args = asList(opts["_args"]);
+    if (action === "refs" || action === "delete-plan") {
+        return commandStateRefs(opts, action === "delete-plan");
+    }
+    if (args.length === 0) {
+        throw new CliError("SCRIPT STATE BLOCKED: Target missing", "Target missing.", {
+            exitCode: EXIT_USAGE,
+            required: ["state or asset target"],
+            received: ["<empty>"],
+            nextSteps: ["Run scriptctl script state --help."],
+            errorCode: "TARGET_MISSING",
+        });
+    }
+    let op;
+    if (action === "add") {
+        op = {
+            op: "state.add",
+            target: args[0],
+            name: opts["name"],
+            description: opts["description"],
+            state_id: opts["state_id"],
+        };
+    }
+    else if (action === "rename") {
+        op = { op: "state.rename", target: args[0], name: opts["name"] };
+    }
+    else if (action === "describe") {
+        op = { op: "state.describe", target: args[0], description: opts["description"] };
+    }
+    else if (action === "delete-apply") {
+        op = {
+            op: "state.delete",
+            target: args[0],
+            strategy: opts["strategy"],
+            replacement: opts["replacement"],
+        };
+    }
+    else {
+        throw new CliError("SCRIPT STATE BLOCKED: Command invalid", "Command invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["add, rename, describe, refs, delete-plan, delete-apply"],
+            received: [action],
+            nextSteps: ["Run scriptctl script state --help."],
+            errorCode: "STATE_COMMAND_INVALID",
+        });
+    }
+    return applySingleScriptOp(opts, op);
+}
+export async function commandScriptContext(opts, action) {
+    const args = asList(opts["_args"]);
+    if (args.length < 2) {
+        throw new CliError("SCRIPT CONTEXT BLOCKED: Arguments missing", "Arguments missing.", {
+            exitCode: EXIT_USAGE,
+            required: ["scene ref and target"],
+            received: args,
+            nextSteps: ["Run scriptctl script context --help."],
+            errorCode: "ARGS_MISSING",
+        });
+    }
+    if (action !== "set" && action !== "clear") {
+        throw new CliError("SCRIPT CONTEXT BLOCKED: Command invalid", "Command invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["set or clear"],
+            received: [action],
+            nextSteps: ["Run scriptctl script context --help."],
+            errorCode: "CONTEXT_COMMAND_INVALID",
+        });
+    }
+    const op = {
+        op: action === "set" ? "context.set" : "context.clear",
+        at: args[0],
+        target: args[1],
+        state: opts["state"],
+    };
+    return applySingleScriptOp(opts, op);
+}
+export async function commandScriptAction(opts, action) {
+    const args = asList(opts["_args"]);
+    if (args.length < 2) {
+        throw new CliError("SCRIPT ACTION BLOCKED: Arguments missing", "Arguments missing.", {
+            exitCode: EXIT_USAGE,
+            required: ["action ref and target"],
+            received: args,
+            nextSteps: ["Run scriptctl script action --help."],
+            errorCode: "ARGS_MISSING",
+        });
+    }
+    let op;
+    if (action === "state-change") {
+        op = {
+            op: "action.state.change",
+            at: args[0],
+            target: args[1],
+            to: opts["to"],
+            from: opts["from"],
+            effective: opts["effective"] || "after",
+        };
+    }
+    else if (action === "state-remove") {
+        op = { op: "action.state.remove", at: args[0], target: args[1] };
+    }
+    else if (action === "transition-set") {
+        op = {
+            op: "action.transition.set",
+            at: args[0],
+            target: args[1],
+            process: opts["process"],
+            contrast: opts["contrast"],
+        };
+    }
+    else if (action === "transition-clear") {
+        op = { op: "action.transition.clear", at: args[0], target: args[1] };
+    }
+    else {
+        throw new CliError("SCRIPT ACTION BLOCKED: Command invalid", "Command invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["state-change, state-remove, transition-set, transition-clear"],
+            received: [action],
+            nextSteps: ["Run scriptctl script action --help."],
+            errorCode: "ACTION_COMMAND_INVALID",
+        });
+    }
+    return applySingleScriptOp(opts, op);
+}
+export async function commandScriptSpeaker(opts, action) {
+    if (action !== "add") {
+        throw new CliError("SCRIPT SPEAKER BLOCKED: Command invalid", "Command invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["add"],
+            received: [action],
+            nextSteps: ["Run scriptctl script speaker --help."],
+            errorCode: "SPEAKER_COMMAND_INVALID",
+        });
+    }
+    const op = {
+        op: "speaker.add",
+        kind: opts["kind"],
+        name: opts["name"],
+        source_id: opts["source_id"],
+        voice_desc: opts["voice_desc"],
+        speaker_id: opts["speaker_id"],
+    };
+    return applySingleScriptOp(opts, op);
+}
+export async function commandScriptDialogue(opts, action) {
+    const args = asList(opts["_args"]);
+    if (args.length === 0) {
+        throw new CliError("SCRIPT DIALOGUE BLOCKED: Action ref missing", "Action ref missing.", {
+            exitCode: EXIT_USAGE,
+            required: ["action ref"],
+            received: ["<empty>"],
+            nextSteps: ["Run scriptctl script dialogue --help."],
+            errorCode: "ACTION_REF_MISSING",
+        });
+    }
+    let op;
+    if (action === "speakers") {
+        op = {
+            op: "dialogue.speakers",
+            at: args[0],
+            speakers: opts["speaker"] || [],
+            delivery: opts["delivery"] || "simultaneous",
+        };
+    }
+    else if (action === "overlap") {
+        op = {
+            op: "dialogue.overlap",
+            at: args[0],
+            lines: opts["line"] || [],
+        };
+    }
+    else {
+        throw new CliError("SCRIPT DIALOGUE BLOCKED: Command invalid", "Command invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["speakers or overlap"],
+            received: [action],
+            nextSteps: ["Run scriptctl script dialogue --help."],
+            errorCode: "DIALOGUE_COMMAND_INVALID",
+        });
+    }
+    return applySingleScriptOp(opts, op);
+}
+// ---------------------------------------------------------------------------
+// command_export (direct export)
+// ---------------------------------------------------------------------------
+export async function commandExport(opts) {
+    const workspace = strOf(opts["workspace_path"] || "workspace");
+    const force = Boolean(opts["force"]);
+    const scriptPath = path.join(directDir(workspace), "script.initial.json");
+    if (!exists(scriptPath)) {
+        throw new CliError("EXPORT BLOCKED: script.initial.json not found", "script.initial.json not found.", {
+            exitCode: EXIT_INPUT,
+            required: ["workspace/draft/scriptctl/direct/script.initial.json"],
+            received: [scriptPath],
+            nextSteps: ["Run scriptctl direct init first."],
+        });
+    }
+    const state = readRunState(workspace);
+    const provider = strOf(state["provider"]);
+    if (provider === "mock" && process.env.SCRIPTCTL_ALLOW_MOCK_EXPORT !== "1") {
+        const report = {
+            title: "EXPORT BLOCKED: Mock provider result",
+            result: ["script.initial.json was produced by --provider mock and was not exported."],
+            artifacts: [path.join(directDir(workspace), "run_state.json")],
+            next: ["Rerun init with --provider anthropic for deliverable conversion."],
+        };
+        return [report, EXIT_NEEDS_AGENT];
+    }
+    const missingReview = reviewBlockers(state);
+    if (missingReview.length > 0) {
+        const report = {
+            title: "EXPORT BLOCKED: Agent review incomplete",
+            result: ["script.initial.json was not exported.", `missing review: ${missingReview.join(", ")}`],
+            artifacts: [path.join(directDir(workspace), "run_state.json")],
+            next: ["Run inspect for each missing target, or apply a structured patch, then validate/export."],
+        };
+        return [report, EXIT_NEEDS_AGENT];
+    }
+    const validation = validateScript(workspace, scriptPath);
+    const blockingOrError = Boolean(validation["has_blocking"]) ||
+        asList(validation["issues"]).some((it) => isDict(it) && (it["severity"] === "blocking" || it["severity"] === "error"));
+    if (!validation["passed"] && (!force || blockingOrError)) {
+        const title = force
+            ? "EXPORT BLOCKED: Validation errors require repair"
+            : "EXPORT BLOCKED: Validation needs agent repair";
+        const report = {
+            title,
+            result: ["script.initial.json was not exported."],
+            artifacts: [path.join(directDir(workspace), "validation.json")],
+            issues: summarizeIssues(asList(validation["issues"])),
+            next: ["Inspect issues and apply structured patches, then validate/export."],
+        };
+        return [report, EXIT_NEEDS_AGENT];
+    }
+    let script;
+    try {
+        script = readJson(scriptPath);
+    }
+    catch (exc) {
+        throw new CliError("EXPORT BLOCKED: script.initial.json invalid", "script.initial.json invalid.", {
+            exitCode: EXIT_INPUT,
+            required: ["valid script.initial.json"],
+            received: [`${scriptPath}: ${exc.message}`],
+            nextSteps: ["Fix script.initial.json or rerun direct init."],
+            errorCode: "SCRIPT_JSON_INVALID",
+        });
+    }
+    if (!isDict(script)) {
+        throw new CliError("EXPORT BLOCKED: script root invalid", "script root invalid.", {
+            exitCode: EXIT_USAGE,
+            required: ["script root object"],
+            received: [Array.isArray(script) ? "array" : typeof script],
+            nextSteps: ["Use a valid script document object."],
+            errorCode: "SCRIPT_ROOT_INVALID",
+        });
+    }
+    const client = scriptOutputClient(opts);
+    const baseRevision = await currentRevisionOrZero(client);
+    // Sorted-keys serialization mirrors Python json.dumps(sort_keys=True, separators=(",",":"))
+    const sortedScript = sortDeep(script);
+    const scriptHash = sha256Text(JSON.stringify(sortedScript));
+    const requestId = strOf(opts["request_id"]).trim() || `scriptctl-direct-export:${scriptHash}`;
+    let replaceRes;
+    try {
+        replaceRes = await client.replaceScript({
+            requestId,
+            baseRevision,
+            script,
+            source: "ctl",
+        });
+    }
+    catch (exc) {
+        if (exc instanceof ScriptOutputApiError) {
+            throw apiErrorToCli("SCRIPT API BLOCKED: Export write failed", exc);
+        }
+        throw exc;
+    }
+    const revision = Number(replaceRes["revision"] ?? 0);
+    const remoteSession = new ScriptEditSession({
+        workspace,
+        script,
+        client,
+        projectGroupNo: client.projectGroupNo,
+        revision,
+    });
+    await syncValidationResult(remoteSession, validation, revision);
+    const outputLabel = remoteSession.artifactLabel;
+    updateRunState(workspace, { status: "exported", output_path: outputLabel });
+    const report = {
+        title: "EXPORT COMPLETE: Final script stored in DB",
+        result: [
+            `validation: ${validation["passed"] ? "passed" : "forced"}`,
+            `base_revision: ${baseRevision}`,
+            `revision: ${revision}`,
+            `idempotent: ${String(Boolean(replaceRes["idempotent"])).toLowerCase()}`,
+        ],
+        artifacts: [outputLabel, path.join(directDir(workspace), "validation.json")],
+        next: ["Proceed to downstream asset or footage stages."],
+    };
+    return [report, EXIT_OK];
+}
+function sortDeep(value) {
+    if (Array.isArray(value))
+        return value.map((v) => sortDeep(v));
+    if (isDict(value)) {
+        const sorted = {};
+        for (const k of Object.keys(value).sort())
+            sorted[k] = sortDeep(value[k]);
+        return sorted;
+    }
+    return value;
+}
+//# sourceMappingURL=script.js.map