narraeon 0.7.10 → 0.8.1

package/dist/node/shared/prompt-arrangement.js

@@ -0,0 +1,205 @@
+import { defaultEnabledBuiltin, } from "./ordered-play-prompts.js";
+export const retiredBuiltinReplacements = {
+    "play.style": [{ builtin: "play.prose" }, { builtin: "play.scene" }],
+    "play.adjudication": [
+        { builtin: "play.agency-default" },
+        { builtin: "play.agency-strict", selected: false },
+        { builtin: "play.agency-open", selected: false },
+        { builtin: "play.facts" },
+        { builtin: "play.npc" },
+    ],
+    "play.narrative": [
+        { builtin: "play.stop-beat" },
+        { builtin: "play.stop-scene", selected: false },
+        { builtin: "play.ending" },
+        { builtin: "play.output" },
+    ],
+    "play.state": [
+        { builtin: "play.save-timing" },
+        { builtin: "play.ownership" },
+        { builtin: "play.situation" },
+        { builtin: "play.checkpoint-policy" },
+    ],
+};
+export function promptArrangementKey(entry) {
+    return entry.kind === "builtin"
+        ? `builtin:${entry.builtin}`
+        : `entry:${entry.id}`;
+}
+function reserveBuiltinPromptId(preferred, builtin, used) {
+    let id = preferred;
+    let suffix = 0;
+    while (used.has(id))
+        id = `builtin-${builtin}-${++suffix}`;
+    used.add(id);
+    return id;
+}
+/** Expand retired identities in place; an explicit successor always wins. */
+export function expandRetiredPrompts(entries) {
+    const explicit = new Set(entries.flatMap((e) => (e.kind === "builtin" ? [e.builtin] : [])));
+    const usedIds = new Set(entries
+        .filter((entry) => entry.kind !== "builtin" ||
+        !retiredBuiltinReplacements[entry.builtin])
+        .map((entry) => entry.id));
+    return entries.flatMap((entry) => {
+        if (entry.kind !== "builtin")
+            return [entry];
+        const replacements = retiredBuiltinReplacements[entry.builtin];
+        if (!replacements)
+            return [entry];
+        return replacements
+            .filter((r) => !explicit.has(r.builtin))
+            .map(({ builtin, selected }) => {
+            const id = reserveBuiltinPromptId(builtin, builtin, usedIds);
+            return {
+                ...entry,
+                id,
+                builtin,
+                enabled: selected === false ? false : entry.enabled,
+            };
+        });
+    });
+}
+/**
+ * Missing defaults follow the nearest preceding catalog neighbor, otherwise the
+ * nearest following neighbor. Existing entries never move relative to each other.
+ */
+export function resolvePromptArrangement(arrangement, catalog, worldRequired = true) {
+    const defaults = catalog.map((item) => ({
+        id: item.id,
+        kind: "builtin",
+        builtin: item.id,
+        enabled: defaultEnabledBuiltin(item, catalog),
+    }));
+    if (worldRequired)
+        defaults.push({ id: "world", kind: "world" });
+    const overrides = expandRetiredPrompts((arrangement.overrides ?? []).map((o) => ({
+        ...o,
+        id: o.id ?? o.builtin,
+        kind: "builtin",
+        enabled: o.enabled ??
+            (catalog.some((c) => c.id === o.builtin)
+                ? defaultEnabledBuiltin(catalog.find((c) => c.id === o.builtin), catalog)
+                : true),
+    })));
+    const values = defaults.map((entry) => {
+        if (entry.kind !== "builtin")
+            return entry;
+        const override = overrides.find((o) => o.kind === "builtin" && o.builtin === entry.builtin);
+        const item = catalog.find((c) => c.id === entry.builtin);
+        const selection = item.group === undefined ? undefined : arrangement.groups?.[item.group];
+        const selected = selection?.flatMap((id) => retiredBuiltinReplacements[id]
+            ?.filter((r) => r.selected !== false)
+            .map((r) => r.builtin) ?? [id]);
+        return {
+            ...entry,
+            ...override,
+            ...(selected === undefined
+                ? {}
+                : { enabled: selected.includes(item.id) }),
+        };
+    });
+    const custom = structuredClone(arrangement.entries ?? []);
+    const world = custom.find((e) => e.kind === "world");
+    if (world !== undefined)
+        values.splice(values.findIndex((e) => e.kind === "world"), 1, world);
+    values.push(...custom.filter((e) => e.kind !== "world"));
+    // A newly shipped identity must not collide with an existing user's identity.
+    const aliases = new Map((arrangement.overrides ?? []).flatMap((override) => override.id === undefined ||
+        !catalog.some((item) => item.id === override.builtin)
+        ? []
+        : [[override.builtin, override.id]]));
+    const usedIds = new Set([...custom.map((e) => e.id), ...aliases.values()]);
+    for (const entry of values) {
+        if (entry.kind !== "builtin")
+            continue;
+        entry.id =
+            aliases.get(entry.builtin) ??
+                reserveBuiltinPromptId(entry.id, entry.builtin, usedIds);
+    }
+    const byKey = new Map(values.map((e) => [promptArrangementKey(e), e]));
+    const explicitOrder = new Set(arrangement.order ?? []);
+    const order = (arrangement.order ?? []).flatMap((key) => {
+        const old = key.startsWith("builtin:")
+            ? retiredBuiltinReplacements[key.slice(8)]
+            : undefined;
+        return old
+            ? old
+                .filter((r) => !explicitOrder.has(`builtin:${r.builtin}`))
+                .map((r) => `builtin:${r.builtin}`)
+            : [key];
+    });
+    const result = [];
+    for (const key of order) {
+        const entry = byKey.get(key);
+        if (entry && !result.includes(entry))
+            result.push(entry);
+    }
+    const defaultKeys = defaults.map(promptArrangementKey);
+    for (const entry of values) {
+        if (result.includes(entry))
+            continue;
+        const position = defaultKeys.indexOf(promptArrangementKey(entry));
+        const previous = defaultKeys
+            .slice(0, position)
+            .reverse()
+            .map((key) => result.findIndex((e) => promptArrangementKey(e) === key))
+            .find((i) => i >= 0);
+        const following = defaultKeys
+            .slice(position + 1)
+            .map((key) => result.findIndex((e) => promptArrangementKey(e) === key))
+            .find((i) => i >= 0);
+        const at = position < 0
+            ? result.length
+            : previous !== undefined
+                ? previous + 1
+                : (following ?? result.length);
+        result.splice(at, 0, entry);
+    }
+    return result;
+}
+export function customizePromptArrangement(input, catalog, worldRequired = true) {
+    const entries = expandRetiredPrompts(input);
+    const arrangement = {};
+    const custom = entries.filter((e) => e.kind !== "builtin" &&
+        !(e.kind === "world" && e.id === "world" && e.messageRole === undefined));
+    if (custom.length)
+        arrangement.entries = structuredClone(custom);
+    const overrides = [];
+    for (const entry of entries) {
+        if (entry.kind !== "builtin")
+            continue;
+        const item = catalog.find((c) => c.id === entry.builtin);
+        if (!item)
+            throw new Error(`Unknown builtin: ${entry.builtin}`);
+        const override = {
+            builtin: entry.builtin,
+        };
+        if (entry.id !== entry.builtin)
+            override.id = entry.id;
+        if (item.group === undefined &&
+            (!entry.enabled || entry.enabled !== defaultEnabledBuiltin(item, catalog)))
+            override.enabled = entry.enabled;
+        if (entry.messageRole !== undefined)
+            override.messageRole = entry.messageRole;
+        if (entry.turnGuide !== undefined)
+            override.turnGuide = entry.turnGuide;
+        if (Object.keys(override).length > 1)
+            overrides.push(override);
+        if (item.group !== undefined) {
+            arrangement.groups ??= {};
+            arrangement.groups[item.group] ??= [];
+            if (entry.enabled)
+                arrangement.groups[item.group].push(item.id);
+        }
+    }
+    if (overrides.length)
+        arrangement.overrides = overrides;
+    const keys = entries.map(promptArrangementKey);
+    const effective = resolvePromptArrangement(arrangement, catalog, worldRequired);
+    const existing = new Set(keys);
+    if (JSON.stringify(keys) !==
+        JSON.stringify(effective.map(promptArrangementKey).filter((key) => existing.has(key))))
+        arrangement.order = keys;
+    return arrangement;
+}

package/dist/node/shared/sillytavern-preset.js

@@ -0,0 +1,454 @@
+import { stringify } from "yaml";
+import { applicationPresetFilesForLocale } from "./application-preset-files.js";
+import { builtinPlayPrompts, } from "./ordered-play-prompts.js";
+import { customizePromptArrangement } from "./prompt-arrangement.js";
+const builtins = new Set([
+    "main",
+    "nsfw",
+    "jailbreak",
+    "dialogueExamples",
+    "chatHistory",
+    "worldInfoAfter",
+    "worldInfoBefore",
+    "enhanceDefinitions",
+    "charDescription",
+    "charPersonality",
+    "scenario",
+    "personaDescription",
+]);
+const fields = new Set([
+    "identifier",
+    "name",
+    "role",
+    "content",
+    "system_prompt",
+    "marker",
+    "injection_position",
+    "injection_depth",
+    "injection_order",
+    "injection_trigger",
+    "forbid_overrides",
+    "extension",
+    "position",
+    "enabled",
+]);
+const structuralErrorCodes = {
+    "expected object": "st_expected_object",
+    "expected array": "st_expected_array",
+    "expected string": "st_expected_string",
+    "expected boolean": "st_expected_boolean",
+    "expected number": "st_expected_number",
+    "invalid JSON": "st_invalid_json",
+    "legacy prompt format is unsupported": "st_legacy_prompt_format_is_unsupported",
+    "unsupported preset format": "st_unsupported_preset_format",
+    "expected nonempty string": "st_expected_nonempty_string",
+    "duplicate identifier": "st_duplicate_identifier",
+    "expected string or number": "st_expected_string_or_number",
+    "expected string array": "st_expected_string_array",
+    "expected prompt content": "st_expected_prompt_content",
+    "unsupported role": "st_unsupported_role",
+    "unknown order field": "st_unknown_order_field",
+    "duplicate order identifier": "st_duplicate_order_identifier",
+    "unknown prompt reference": "st_unknown_prompt_reference",
+    "unknown group field": "st_unknown_group_field",
+    "expected character identifier": "st_expected_character_identifier",
+    "duplicate character group": "st_duplicate_character_group",
+    "unknown group": "st_unknown_group",
+    "choose a character group": "st_choose_a_character_group",
+    "invalid selection": "st_invalid_selection",
+};
+function fail(path, message) {
+    throw new Error(`${path}: ${message} [${structuralErrorCodes[message]}]`);
+}
+function object(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        fail(path, "expected object");
+    return value;
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        fail(path, "expected array");
+    return value;
+}
+function optional(value, type, path) {
+    if (value !== undefined &&
+        (typeof value !== type || (type === "number" && !Number.isFinite(value))))
+        fail(path, `expected ${type}`);
+}
+function parse(raw, groupId) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return fail("$", "invalid JSON");
+    }
+    const root = object(parsed, "$");
+    if ("main_prompt" in root ||
+        "nsfw_prompt" in root ||
+        "jailbreak_prompt" in root)
+        fail("$", "legacy prompt format is unsupported");
+    const manager = root.version === 1 && (root.type === "full" || root.type === "character");
+    const data = manager ? object(root.data, "$.data") : root;
+    if (!manager &&
+        ("version" in root ||
+            "type" in root ||
+            !Array.isArray(root.prompts) ||
+            !Array.isArray(root.prompt_order)))
+        fail("$", "unsupported preset format");
+    const prefix = manager ? "$.data" : "$";
+    const prompts = array(data.prompts, `${prefix}.prompts`);
+    const byId = new Map();
+    prompts.forEach((entry, index) => {
+        const path = `${prefix}.prompts[${index}]`;
+        const value = object(entry, path);
+        if (typeof value.identifier !== "string" || !value.identifier)
+            fail(`${path}.identifier`, "expected nonempty string");
+        if (byId.has(value.identifier))
+            fail(`${path}.identifier`, "duplicate identifier");
+        for (const key of ["name", "role", "content"])
+            optional(value[key], "string", `${path}.${key}`);
+        for (const key of [
+            "system_prompt",
+            "marker",
+            "forbid_overrides",
+            "extension",
+            "enabled",
+        ])
+            optional(value[key], "boolean", `${path}.${key}`);
+        for (const key of [
+            "injection_position",
+            "injection_depth",
+            "injection_order",
+        ])
+            optional(value[key], "number", `${path}.${key}`);
+        if (value.position !== undefined &&
+            typeof value.position !== "number" &&
+            typeof value.position !== "string")
+            fail(`${path}.position`, "expected string or number");
+        if (value.injection_trigger !== undefined &&
+            (!Array.isArray(value.injection_trigger) ||
+                value.injection_trigger.some((v) => typeof v !== "string")))
+            fail(`${path}.injection_trigger`, "expected string array");
+        if (value.marker !== true && typeof value.content !== "string")
+            fail(`${path}.content`, "expected prompt content");
+        if (value.role !== undefined &&
+            !["system", "user", "assistant"].includes(value.role))
+            fail(`${path}.role`, "unsupported role");
+        byId.set(value.identifier, { value, path });
+    });
+    function order(value, path) {
+        const seen = new Set();
+        return array(value, path).map((entry, index) => {
+            const itemPath = `${path}[${index}]`;
+            const item = object(entry, itemPath);
+            if (Object.keys(item).some((key) => !["identifier", "enabled"].includes(key)))
+                fail(itemPath, "unknown order field");
+            if (typeof item.identifier !== "string" || !item.identifier)
+                fail(`${itemPath}.identifier`, "expected nonempty string");
+            if (typeof item.enabled !== "boolean")
+                fail(`${itemPath}.enabled`, "expected boolean");
+            if (seen.has(item.identifier))
+                fail(`${itemPath}.identifier`, "duplicate order identifier");
+            seen.add(item.identifier);
+            if (!byId.has(item.identifier) && !builtins.has(item.identifier))
+                fail(`${itemPath}.identifier`, "unknown prompt reference");
+            return { id: item.identifier, enabled: item.enabled, path: itemPath };
+        });
+    }
+    const groups = [];
+    const orders = new Map();
+    if (manager)
+        orders.set("manager", order(data.prompt_order, `${prefix}.prompt_order`));
+    else
+        array(data.prompt_order, "$.prompt_order").forEach((entry, index) => {
+            const path = `$.prompt_order[${index}]`;
+            const value = object(entry, path);
+            if (Object.keys(value).some((key) => !["character_id", "order"].includes(key)))
+                fail(path, "unknown group field");
+            if ((typeof value.character_id !== "string" &&
+                typeof value.character_id !== "number") ||
+                String(value.character_id).length === 0)
+                fail(`${path}.character_id`, "expected character identifier");
+            const id = String(value.character_id);
+            if (orders.has(id))
+                fail(`${path}.character_id`, "duplicate character group");
+            groups.push({ id, label: id });
+            orders.set(id, order(value.order, `${path}.order`));
+        });
+    const selectedId = manager
+        ? "manager"
+        : (groupId ??
+            (orders.has("100001")
+                ? "100001"
+                : groups.length === 1
+                    ? groups[0].id
+                    : undefined));
+    if (groupId !== undefined && (!orders.has(groupId) || manager))
+        fail("$.prompt_order", "unknown group");
+    const selectedOrder = selectedId === undefined ? undefined : orders.get(selectedId);
+    const result = [];
+    const seen = new Set();
+    function add(id, ordered, enabled, orderPath) {
+        seen.add(id);
+        const found = byId.get(id);
+        if (!found) {
+            result.push({
+                id,
+                path: orderPath,
+                name: id,
+                enabled,
+                ordered,
+                marker: false,
+                missing: true,
+                macros: [],
+                reasons: ["missing_builtin"],
+                unsupportedPaths: [],
+            });
+            return;
+        }
+        const { value, path } = found;
+        const content = value.content;
+        const macros = [
+            ...new Set(content?.match(/\{\{[^{}]*\}\}|<(?:USER|BOT|CHAR|CHARIFNOTGROUP|GROUP)>/giu) ?? []),
+        ];
+        const reasons = [];
+        const unsupportedPaths = Object.keys(value)
+            .filter((key) => !fields.has(key))
+            .map((key) => `${path}.${key}`);
+        if (value.marker === true)
+            reasons.push("marker");
+        if (macros.length)
+            reasons.push("unsupported_macro");
+        if (value.injection_position !== undefined &&
+            value.injection_position !== 0)
+            reasons.push("depth_injection");
+        if (Array.isArray(value.injection_trigger) &&
+            value.injection_trigger.length)
+            reasons.push("trigger");
+        if ((id === "main" || id === "jailbreak") &&
+            value.forbid_overrides !== true)
+            reasons.push("overrides");
+        if (value.extension === true || unsupportedPaths.length > 0)
+            reasons.push("unsupported_fields");
+        if (!ordered)
+            reasons.push("unplaced");
+        result.push({
+            id,
+            path,
+            name: value.name ?? id,
+            role: value.role,
+            content,
+            enabled,
+            ordered,
+            marker: value.marker === true,
+            missing: false,
+            injectionPosition: value.injection_position,
+            injectionDepth: value.injection_depth,
+            injectionOrder: value.injection_order,
+            triggers: value.injection_trigger,
+            macros,
+            forbidOverrides: value.forbid_overrides,
+            reasons,
+            unsupportedPaths,
+            systemPrompt: value.system_prompt,
+            extension: value.extension,
+            position: value.position,
+        });
+    }
+    selectedOrder?.forEach((entry) => add(entry.id, true, entry.enabled, entry.path));
+    if (selectedOrder)
+        for (const id of byId.keys())
+            if (!seen.has(id))
+                add(id, false, undefined);
+    function settingsCategory(key) {
+        if (/password|key|token|proxy|url|endpoint|header|auth/iu.test(key) &&
+            !/max_tokens/iu.test(key))
+            return "connection";
+        if (/temperature|penalty|top_|min_p|repetition|context|tokens|sampl/iu.test(key))
+            return "sampling";
+        if (/model|source|api/iu.test(key))
+            return "model";
+        if (/extension|regex|script/iu.test(key))
+            return "extension";
+        return "generation";
+    }
+    const safeNumericSettings = new Set([
+        "temperature",
+        "top_p",
+        "top_k",
+        "top_a",
+        "min_p",
+        "frequency_penalty",
+        "presence_penalty",
+        "repetition_penalty",
+        "openai_max_context",
+        "openai_max_tokens",
+    ]);
+    const setting = (key, path, value) => ({
+        path,
+        category: settingsCategory(key),
+        ...(safeNumericSettings.has(key) &&
+            typeof value === "number" &&
+            Number.isFinite(value)
+            ? { value }
+            : {}),
+    });
+    const settings = [
+        ...Object.keys(root)
+            .filter((key) => manager
+            ? !["version", "type", "data"].includes(key)
+            : !["prompts", "prompt_order"].includes(key))
+            .map((key) => setting(key, `$.${key}`, root[key])),
+        ...(manager
+            ? Object.keys(data)
+                .filter((key) => !["prompts", "prompt_order"].includes(key))
+                .map((key) => setting(key, `$.data.${key}`, data[key]))
+            : []),
+    ];
+    return {
+        inspection: {
+            groups,
+            selectedGroupId: manager ? undefined : selectedId,
+            prompts: result,
+            settings,
+        },
+        selected: selectedOrder !== undefined,
+    };
+}
+export function inspectSillyTavernPreset(raw, groupId) {
+    return parse(raw, groupId).inspection;
+}
+export function convertSillyTavernPreset(raw, options) {
+    const { inspection, selected } = parse(raw, options.groupId);
+    if (!selected)
+        fail("$.prompt_order", "choose a character group");
+    if (new Set(options.selected).size !== options.selected.length ||
+        options.selected.some((id) => !inspection.prompts.some((item) => item.id === id)))
+        fail("selection", "invalid selection");
+    const catalog = builtinPlayPrompts(options.locale);
+    const entries = catalog
+        .filter((item) => item.required)
+        .map((item) => ({
+        id: item.id,
+        kind: "builtin",
+        builtin: item.id,
+        enabled: true,
+    }));
+    const report = inspection.settings.map((setting) => ({
+        code: "ignored_setting",
+        path: setting.path,
+        result: "ignored",
+    }));
+    const targetIds = new Map();
+    for (const item of inspection.prompts) {
+        const chosen = options.selected.includes(item.id);
+        report.push({
+            code: "prompt_selection",
+            path: item.path,
+            name: item.name,
+            result: !chosen
+                ? "not_selected"
+                : item.marker || item.missing
+                    ? "not_imported"
+                    : item.enabled === true && item.reasons.length === 0
+                        ? "enabled"
+                        : "disabled",
+        });
+        for (const code of item.reasons)
+            report.push({
+                code,
+                path: item.path,
+                name: item.name,
+                result: chosen && !item.marker && !item.missing ? "disabled" : "not_imported",
+            });
+        for (const path of item.unsupportedPaths)
+            report.push({
+                code: "unsupported_field",
+                path,
+                name: item.name,
+                result: chosen ? "disabled" : "not_imported",
+            });
+        if (!chosen || item.marker || item.missing)
+            continue;
+        const targetId = `st-${entries.length}`;
+        targetIds.set(item.id, targetId);
+        entries.push({
+            id: targetId,
+            kind: "user",
+            name: item.name,
+            body: item.content,
+            messageRole: (item.role ?? "system"),
+            enabled: item.enabled === true && item.reasons.length === 0,
+        });
+    }
+    entries.push({ id: "world", kind: "world" });
+    entries.push(...catalog
+        .filter((item) => !item.required)
+        .map((item) => ({
+        id: item.id,
+        kind: "builtin",
+        builtin: item.id,
+        enabled: false,
+    })));
+    const arrangement = customizePromptArrangement(entries, catalog);
+    const files = applicationPresetFilesForLocale(options.locale);
+    files["preset.yaml"] = stringify({
+        format: "narraeon.play-preset/v3",
+        name: options.name,
+        callChain: "call-chain.yaml",
+        playPrompts: arrangement,
+        authorPrompts: {},
+        mergeConsecutiveMessages: false,
+        mounts: [],
+        extensions: [],
+    });
+    files["assets/sillytavern-import-report.json"] = JSON.stringify({
+        format: "narraeon.sillytavern-import/v1",
+        sourceGroupId: inspection.selectedGroupId,
+        prompts: inspection.prompts.flatMap((item, index) => options.selected.includes(item.id)
+            ? [
+                {
+                    sourceId: item.id,
+                    path: item.path,
+                    name: item.name,
+                    role: item.role,
+                    sourceEnabled: item.enabled,
+                    ordered: item.ordered,
+                    orderIndex: item.ordered ? index : undefined,
+                    marker: item.marker,
+                    missing: item.missing,
+                    injectionPosition: item.injectionPosition,
+                    injectionDepth: item.injectionDepth,
+                    injectionOrder: item.injectionOrder,
+                    triggers: item.triggers,
+                    macros: item.macros,
+                    forbidOverrides: item.forbidOverrides,
+                    systemPrompt: item.systemPrompt,
+                    extension: item.extension,
+                    position: item.position,
+                    unsupportedPaths: item.unsupportedPaths,
+                    targetId: targetIds.get(item.id),
+                },
+            ]
+            : []),
+        report: report.filter((item) => item.code === "ignored_setting" ||
+            (item.name !== undefined &&
+                inspection.prompts.some((prompt) => options.selected.includes(prompt.id) &&
+                    (item.path === prompt.path ||
+                        item.path.startsWith(`${prompt.path}.`))))),
+    }, null, 2);
+    return {
+        files,
+        report,
+        target: entries.map((entry) => ({
+            name: entry.kind === "user"
+                ? entry.name
+                : entry.kind === "builtin"
+                    ? catalog.find((item) => item.id === entry.builtin).name
+                    : "World",
+            kind: entry.kind,
+            enabled: entry.kind === "world" || entry.enabled,
+        })),
+    };
+}