@lingjingai/scriptctl 0.15.0 → 0.19.0

package/dist/domain/direct-core.js

@@ -1,4 +1,4 @@
-import { ACTION_TYPE_VALUES, ACTOR_REUSE_SCENE_LIMIT, CliError, DEFAULT_BATCH_MAX_CHARS, DEFAULT_BATCH_MIN_LINES, DEFAULT_BATCH_MODE, DEFAULT_BATCH_TARGET_LINES, DEFAULT_PROVIDER_ATTEMPTS, EXIT_NEEDS_AGENT, EXIT_RUNTIME, PROP_REUSE_SCENE_LIMIT, SCRIPT_SCHEMA_VERSION, SCRIPT_TARGET_KINDS, WORLDVIEW_VALUES, fmtId, } from "../common.js";
+import { ACTION_TYPE_VALUES, ACTOR_REUSE_SCENE_LIMIT, CliError, DEFAULT_BATCH_MAX_CHARS, DEFAULT_BATCH_MIN_LINES, DEFAULT_BATCH_MODE, DEFAULT_BATCH_TARGET_LINES, DEFAULT_PROVIDER_ATTEMPTS, EXIT_NEEDS_AGENT, EXIT_RUNTIME, PROP_REUSE_SCENE_LIMIT, ROLE_TYPE_VALUES, SCRIPT_SCHEMA_VERSION, SCRIPT_TARGET_KINDS, WORLDVIEW_VALUES, fmtId, } from "../common.js";
 // ---------------------------------------------------------------------------
 // Regexes & lookup tables (shared with infra/converters.ts via re-export)
 // ---------------------------------------------------------------------------
@@ -1133,13 +1133,6 @@ export async function providerExtractBatch(provider, sourceText, batch) {
         return await provider.extractEpisode(sourceText, batch);
     throw new Error("Provider has neither extractBatch nor extractEpisode");
 }
-export async function providerExtractAssetCuration(provider, sourceText, script) {
-    if (provider.extractAssetCuration) {
-        const payload = await provider.extractAssetCuration(sourceText, script);
-        return isDict(payload) ? payload : {};
-    }
-    return {};
-}
 function sleepMs(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1749,6 +1742,104 @@ export function parseAssetDoc(text, kind) {
     return { actors, locations, props, speakers, state_definitions: stateDefs };
 }
 // ---------------------------------------------------------------------------
+// Asset doc serialization (inverse of parseAssetDoc / parseMetaDoc)
+//
+// Turn an assembled script back into the per-kind 资产 md so `parse
+// --extract-assets` can seed reviewable 人物/场景/道具/发声源.md from an
+// LLM-enriched script. Output must round-trip through parseAssetDoc: every
+// asset becomes a top-level `- 名: 描述` bullet, each state a `  - 状态名:`
+// sub-bullet. State appearance text is not stored on the script (states are
+// {state_id, state_name}); we emit the state name only and leave the appearance
+// blank for the human to fill — the file is a review seed, not the final word.
+// ---------------------------------------------------------------------------
+const _ASSET_DOC_HEADER = {
+    actors: "人物",
+    locations: "场景",
+    props: "道具",
+    speakers: "发声源",
+};
+const _ASSET_DOC_NAME_KEY = {
+    actors: "actor_name",
+    locations: "location_name",
+    props: "prop_name",
+};
+// Collapse any whitespace run (incl. newlines) to a single space. A description
+// or single-value field spanning physical lines would break the line-oriented
+// grammar (continuation lines don't start with `-` / a known key → dropped).
+function _oneLine(s) {
+    return s.replace(/\s+/g, " ").trim();
+}
+// Sanitize a name for emission. The md grammar can't represent a name containing
+// its own structural delimiters: `:`/`：` start a description (truncating the
+// name), `|` flags a flat `名|状态` state def (the asset disappears), and the meta
+// `主角:` value is re-split on `,`/`，`/`、`. None of these belong in a canonical
+// entity name, so replace them with spaces — the doc is a review seed and the
+// human fixes oddities; we just never emit a name that re-parses to something else.
+function _safeName(name) {
+    return name.replace(/[\r\n:：|,，、]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function _assetBullet(name, description) {
+    const desc = _oneLine(description);
+    return desc ? `- ${name}: ${desc}` : `- ${name}`;
+}
+export function serializeAssetDoc(script, kind) {
+    const lines = [`# ${_ASSET_DOC_HEADER[kind]}`, ""];
+    if (kind === "speakers") {
+        for (const sp of asList(script["speakers"])) {
+            if (!isDict(sp))
+                continue;
+            const name = _safeName(strOf(sp["display_name"]));
+            if (!name)
+                continue;
+            const sourceKind = strOf(sp["source_kind"]).trim();
+            // 发声源.md is for NON-人物 sources only; actor-kind speakers are real
+            // characters already registered in 人物.md. Every non-actor kind round-trips
+            // as `名(kind)` (parseSpeakerAsset reads the (...) annotation).
+            if (!sourceKind || sourceKind === "actor")
+                continue;
+            lines.push(_assetBullet(`${name}(${sourceKind})`, strOf(sp["description"])));
+        }
+        return lines.join("\n") + "\n";
+    }
+    const nameKey = _ASSET_DOC_NAME_KEY[kind];
+    for (const asset of asList(script[kind])) {
+        if (!isDict(asset))
+            continue;
+        const name = _safeName(strOf(asset[nameKey]));
+        if (!name)
+            continue;
+        lines.push(_assetBullet(name, strOf(asset["description"])));
+        for (const stateName of compactStateNames(asset)) {
+            const safeState = _safeName(stateName);
+            if (!safeState)
+                continue;
+            // Bare sub-bullet (no trailing colon): the script stores no appearance text
+            // for a state, and `- 名:` with an empty description fails _MD_ASSET_ENTRY_RE.
+            lines.push(`  - ${safeState}`);
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+export function serializeMetaDoc(script) {
+    const lines = ["# 元信息", ""];
+    const worldview = _oneLine(strOf(script["worldview"]));
+    const style = _oneLine(strOf(script["style"]));
+    const title = _oneLine(strOf(script["title"]));
+    if (title)
+        lines.push(`title: ${title}`);
+    if (worldview)
+        lines.push(`worldview: ${worldview}`);
+    if (style)
+        lines.push(`style: ${style}`);
+    const leads = asList(script["actors"])
+        .filter((a) => isDict(a) && strOf(a["role_type"]).trim() === "主角")
+        .map((a) => _safeName(strOf(a["actor_name"])))
+        .filter(Boolean);
+    if (leads.length > 0)
+        lines.push(`主角: ${leads.join(", ")}`);
+    return lines.join("\n") + "\n";
+}
+// ---------------------------------------------------------------------------
 // Compact / expand transforms
 // ---------------------------------------------------------------------------
 export function expandCompactEpisodeResult(result, episodePlan) {
@@ -1881,6 +1972,11 @@ export function expandCompactEpisodeResult(result, episodePlan) {
         expanded["speakers"] = result["speakers"];
     if ("state_definitions" in result)
         expanded["state_definitions"] = result["state_definitions"];
+    // Restore the synopsis carried through compaction (short key `syn`, or a
+    // plain `synopsis` if the on-disk form was never compacted).
+    const synopsis = readCarriedSynopsis(result);
+    if (synopsis)
+        expanded["synopsis"] = synopsis;
     return expanded;
 }
 export function compactEpisodeResult(result) {
@@ -1967,7 +2063,14 @@ export function compactEpisodeResult(result) {
         compactScene["a"] = compactActions;
         compactScenes.push(compactScene);
     }
-    return { sc: compactScenes };
+    const compacted = { sc: compactScenes };
+    // Carry the synopsis through the compact round-trip (short key `syn`). Without
+    // this, any synopsis written upstream (## 梗概 → batch result, or the episode
+    // reduce) would silently evaporate the moment the result is persisted.
+    const synopsis = strOf(result["synopsis"]).trim();
+    if (synopsis)
+        compacted["syn"] = synopsis;
+    return compacted;
 }
 export function compactBatchResult(result) {
     const compact = compactEpisodeResult(result);
@@ -2002,6 +2105,79 @@ export function compactBatchResult(result) {
     }
     return compact;
 }
+/**
+ * Plan ONE level of the whole-script synopsis reduce.
+ *
+ * We can only char-group the items we actually have (their lengths are known);
+ * a merged group's output length isn't known until the LLM produces it. So this
+ * stays single-level and the orchestrator loops — call it on the episode
+ * synopses, merge each group, then call it again on the merged outputs until it
+ * returns fitsInOnePass, then run the final extractScriptSynopsis on whatever
+ * survives. Pure: it never calls the provider.
+ *
+ * Boundaries: total ≤ threshold (or ≤1 item) → one pass; total ≫ threshold →
+ * multiple bounded groups; every item alone already over threshold → no
+ * grouping can make progress, so degrade to one pass rather than loop forever.
+ */
+export function planSynopsisReduction(synopses, thresholdChars, groupSize) {
+    const items = asList(synopses).map((s) => strOf(s));
+    const onePass = () => ({
+        fitsInOnePass: true,
+        groups: items.map((_, i) => [i]),
+    });
+    const total = items.reduce((sum, s) => sum + s.length, 0);
+    if (items.length <= 1 || total <= thresholdChars)
+        return onePass();
+    const cap = Math.max(1, groupSize);
+    const groups = [];
+    let current = [];
+    let currentChars = 0;
+    for (let i = 0; i < items.length; i++) {
+        const len = items[i].length;
+        if (current.length > 0 && (current.length >= cap || currentChars + len > thresholdChars)) {
+            groups.push(current);
+            current = [];
+            currentChars = 0;
+        }
+        current.push(i);
+        currentChars += len;
+    }
+    if (current.length > 0)
+        groups.push(current);
+    // No progress possible (every item alone exceeds threshold → all singletons).
+    if (groups.length >= items.length)
+        return onePass();
+    return { fitsInOnePass: false, groups };
+}
+// ---------------------------------------------------------------------------
+// Synopsis utilities (shared by providers + the reduce orchestration)
+// ---------------------------------------------------------------------------
+// Trim + drop-empty an unknown list of synopsis strings. Single source for the
+// "clean beats" rule, so MockProvider, AnthropicProvider, and the orchestrator
+// can never diverge on what counts as a non-empty beat.
+export function cleanSynopsisList(items) {
+    return asList(items).map((s) => strOf(s).trim()).filter((s) => s.length > 0);
+}
+// Read the synopsis carried through the compact round-trip: the short key `syn`
+// (current) or a plain `synopsis` (uncompacted / legacy). One definition so the
+// key precedence can't drift between the expand path and the reuse readers.
+export function readCarriedSynopsis(d) {
+    return isDict(d) ? strOf(d["syn"] ?? d["synopsis"]).trim() : "";
+}
+// Recursively sort object keys for a stable JSON serialization (cache keys /
+// content hashes). Canonical home for the helper duplicated in the script/parse
+// usecases — re-exported there for back-compat.
+export 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;
+}
 // ---------------------------------------------------------------------------
 // Normalize episode result
 // ---------------------------------------------------------------------------
@@ -2380,6 +2556,95 @@ export function deterministicExtractMetadata(script) {
         })),
     };
 }
+// Split a metadata markdown document (see METADATA_MD_SPEC) into its raw pieces.
+// Tolerant by design: unknown headings reset the section, non-bullet lines under
+// asset sections are ignored, and a missing field just yields "". The id-keyed
+// maps and the raw worldview line are validated/backfilled by the caller.
+function parseMetadataMdSections(raw) {
+    const actors = new Map();
+    const locations = new Map();
+    const props = new Map();
+    let worldviewRaw = "";
+    let section = "";
+    for (const lineRaw of raw.split("\n")) {
+        const line = lineRaw.trim();
+        if (!line)
+            continue;
+        if (line.startsWith("#")) {
+            const heading = line.replace(/^#+/, "").trim();
+            if (heading.includes("世界观"))
+                section = "worldview";
+            else if (heading.includes("人物"))
+                section = "actors";
+            else if (heading.includes("场景"))
+                section = "locations";
+            else if (heading.includes("道具"))
+                section = "props";
+            else
+                section = "";
+            continue;
+        }
+        if (section === "worldview") {
+            if (!worldviewRaw)
+                worldviewRaw = line;
+            continue;
+        }
+        if (section === "")
+            continue;
+        const body = line.replace(/^[-*]\s*/, "").trim();
+        const parts = body.split("|").map((s) => s.trim());
+        const id = parts[0] ?? "";
+        if (!id)
+            continue;
+        if (section === "actors")
+            actors.set(id, { role: parts[1] ?? "", description: parts[2] ?? "" });
+        else if (section === "locations")
+            locations.set(id, parts[1] ?? "");
+        else
+            props.set(id, parts[1] ?? "");
+    }
+    return { worldviewRaw, actors, locations, props };
+}
+// Parse a metadata markdown response into the same dict shape as
+// deterministicExtractMetadata. Strategy: start from the deterministic baseline
+// (guarantees every script asset is present with a valid role/description), then
+// overlay the model's worldview/role/description wherever it supplied a usable
+// value. So a truncated or partial response still produces a complete,
+// schema-valid result — missing assets simply keep their deterministic default.
+export function parseMarkdownMetadata(raw, script) {
+    const base = deterministicExtractMetadata(script);
+    const parsed = parseMetadataMdSections(raw);
+    const worldviewRaw = parsed.worldviewRaw.trim();
+    if (worldviewRaw) {
+        const matched = WORLDVIEW_VALUES.includes(worldviewRaw)
+            ? worldviewRaw
+            : WORLDVIEW_VALUES.find((v) => worldviewRaw.includes(v));
+        if (matched)
+            base["worldview"] = matched;
+        base["worldview_raw"] = worldviewRaw;
+    }
+    for (const actor of base["actors"]) {
+        const item = parsed.actors.get(strOf(actor["actor_id"]));
+        if (!item)
+            continue;
+        if (ROLE_TYPE_VALUES.includes(item.role))
+            actor["role_type"] = item.role;
+        if (item.description)
+            actor["description"] = item.description;
+    }
+    for (const loc of base["locations"]) {
+        const desc = parsed.locations.get(strOf(loc["location_id"]));
+        if (desc)
+            loc["description"] = desc;
+    }
+    for (const prop of base["props"]) {
+        const desc = parsed.props.get(strOf(prop["prop_id"]));
+        if (desc)
+            prop["description"] = desc;
+    }
+    base["confidence"] = "high";
+    return base;
+}
 export function applyMetadataToScript(script, metadata) {
     script["worldview"] = metadata["worldview"];
     script["worldview_raw"] = strOf(metadata["worldview_raw"]).trim();
@@ -2452,52 +2717,6 @@ function compactStateNames(asset) {
     }
     return out;
 }
-function usagePayload(usage) {
-    return {
-        episode_count: usage.episodes.size,
-        scene_count: usage.scenes.size,
-        episodes: [...usage.episodes].sort().slice(0, 12),
-        scenes: [...usage.scenes].sort().slice(0, 12),
-    };
-}
-export function buildAssetCurationContext(script) {
-    const locationUsage = sceneAssetUsage(script, "locations", "location_id");
-    return {
-        title: script["title"],
-        guidance: [
-            "Decide from the script context, not from asset names alone.",
-            "Merge a location only when it is clearly the same stable space as an existing target location.",
-            "Keep a location whenever no stable parent location is clear.",
-        ],
-        locations: asList(script["locations"]).filter(isDict).map((loc) => ({
-            location_id: loc["location_id"],
-            location_name: loc["location_name"],
-            description: loc["description"],
-            aliases: isList(loc["aliases"]) ? loc["aliases"] : [],
-            states: compactStateNames(loc),
-            usage: usagePayload(locationUsage.get(strOf(loc["location_id"])) ?? { episodes: new Set(), scenes: new Set() }),
-            examples: locationUsageExamples(script, strOf(loc["location_id"])),
-        })),
-    };
-}
-export function locationUsageExamples(script, locationId) {
-    const examples = [];
-    for (const ep of asList(script["episodes"])) {
-        for (const scene of asList(ep["scenes"])) {
-            const refs = asList(sceneContext(scene)["locations"]);
-            const found = refs.some((ref) => isDict(ref) && ref["location_id"] === locationId);
-            if (!found)
-                continue;
-            const example = sceneExample(scene);
-            if (example) {
-                examples.push({ episode_id: ep["episode_id"], scene_id: scene["scene_id"], example });
-            }
-            if (examples.length >= 4)
-                return examples;
-        }
-    }
-    return examples;
-}
 function compactAssetRefs(refs, idKey, replacements, droppedIds) {
     const compacted = [];
     const seen = new Set();
@@ -3165,6 +3384,13 @@ export function mergeEpisodeResults(results, title) {
         worldview: "",
         worldview_raw: "",
         style: "",
+        // Whole-script overview placeholders — filled by the summary stage (the
+        // synopsis reduce) after merge. Present-but-empty keeps consumer fields
+        // stable and gives the summary stage a well-defined slot to write into.
+        synopsis: "",
+        theme: "",
+        logline: "",
+        main_characters: [],
         actors,
         locations,
         props,