Allow create new world books via `/getpersonabook` and `/getcharbook` (#4597) * feat: allow create new world books via /getpersonabook and /getcharbook Refactor character world info management into dedicated functions Extract character world assignment logic from UI handlers into reusable functions Add support for automatic lorebook creation in slash commands Improve code maintainability by centralizing world info operations * refactor: update boolean enum provider from onOffToggle to trueFalse in world info commands * fix: improve world info name uniqueness check using getUniqueName utility * Unset current persona WI on file deletion --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

a65f708fd81817783a6a50e1ba2d9448ab4cc03d

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: 23b13602045d8ed020b7c37ef05c22b867fdf01a

public/script.js+11 -54 Viewed

     wi_anchor_position,
     world_info_include_names,
     initWorldInfo,
+    charUpdatePrimaryWorld,
+    charSetAuxWorlds,
 } from './scripts/world-info.js';
 import {

         const selectedValue = $(this).val();
         const worldIndex = selectedValue !== '' ? Number(selectedValue) : NaN;
         const name = !isNaN(worldIndex) ? world_names[worldIndex] : '';
-        const previousValue = $('#character_world').val();
+        await charUpdatePrimaryWorld(name);
-        $('#character_world').val(name);
-        console.debug('Character world selected:', name);
-        if (menu_type == 'create') {
-            create_save.world = name;
-        } else {
-            if (previousValue && !name) {
-                try {
-                    // Dirty hack to remove embedded lorebook from character JSON data.
-                    const data = JSON.parse(String($('#character_json_data').val()));
-                    if (data?.data?.character_book) {
-                        data.data.character_book = undefined;
-                    }
-                    $('#character_json_data').val(JSON.stringify(data));
-                    toastr.info(t`Embedded lorebook will be removed from this character.`);
-                } catch {
-                    console.error('Failed to parse character JSON data.');
-                }
-            }
-            await createOrEditCharacter();
-        }
-        setWorldInfoButtonClass(undefined, !!name);
+    }
-    function handleExtrasWorldSelect() {
+    function handleExtrasWorldSelect(evt) {
-        const selectedValues = $(this).val();
+        const el = evt?.currentTarget ?? this;
-        const selectedWorlds = Array.isArray(selectedValues) ? selectedValues : [];
+        const selectedValues = $(el).val();
-        let charLore = world_info.charLore ?? [];
+        const selected = Array.isArray(selectedValues) ? selectedValues : [];
-        const tempExtraBooks = selectedWorlds.map((index) => world_names[index]).filter(Boolean);
+        const fileName = getCharaFilename(null, {});
-        const existingCharIndex = charLore.findIndex((e) => e.name === fileName);
+        const nextList = selected.map(i => world_names[i]).filter(Boolean);
+        charSetAuxWorlds(fileName, nextList);
-        if (menu_type == 'create') {
-            create_save.extra_books = tempExtraBooks;
-            return;
-        }
-        if (existingCharIndex === -1) {
-            // Add record only if at least 1 lorebook is selected.
-            if (tempExtraBooks.length > 0) {
-                charLore.push({ name: fileName, extraBooks: tempExtraBooks });
-            }
-        } else if (tempExtraBooks.length === 0) {
-            charLore.splice(existingCharIndex, 1);
-        } else {
-            charLore[existingCharIndex].extraBooks = tempExtraBooks;
-        }
-        Object.assign(world_info, { charLore: charLore });
-        saveSettingsDebounced();
+    }
     // --- Populate Dropdowns ---

  * Creates or edits a character based on the form data.
  * @param {Event} [e] Event that triggered the function call.
  */
-async function createOrEditCharacter(e) {
+export async function createOrEditCharacter(e) {
     $('#rm_info_avatar').html('');
     const formData = new FormData(/** @type {HTMLFormElement} */($('#form_create').get(0)));
     formData.set('fav', String(fav_ch_checked));

public/scripts/personas.js+1 -1 Viewed

     $('#persona_depth_position_settings').toggle(power_user.persona_description_position === persona_description_positions.AT_DEPTH);
+}
-function getOrCreatePersonaDescriptor() {
+export function getOrCreatePersonaDescriptor() {
     let object = power_user.persona_descriptions[user_avatar];
     if (!object) {

public/scripts/utils.js+10 -1 Viewed

+}
 /**
+ * Normalizes an array by removing duplicates, trimming strings, and filtering out empty values.
+ * @param {any[]} arr - The array to normalize.
+ * @returns {any[]} The normalized array.
+ */
+export function normalizeArray(arr) {
+    return [...new Set((arr ?? []).map(s => typeof s === 'string' ? s.trim() : s).filter(Boolean))];
+}
+/**
  * Checks if a string only contains digits.
  * @param {string} str The string to check.
  * @returns {boolean} True if the string only contains digits, false otherwise.

 /**
  * Returns a name that is unique among the names that exist.
  * @param {string} name The name to check.
- * @param {{ (y: any): boolean; }} exists Function to check if name exists.
+ * @param {{ (name: string): boolean; }} exists Function to check if name exists.
  * @returns {string} A unique name.
  */
 export function getUniqueName(name, exists) {

public/scripts/world-info.js+205 -23 Viewed

 import { Fuse } from '../lib.js';
-import { saveSettings, substituteParams, getRequestHeaders, chat_metadata, this_chid, characters, saveCharacterDebounced, menu_type, eventSource, event_types, getExtensionPromptByName, saveMetadata, getCurrentChatId, extension_prompt_roles } from '../script.js';
+import { saveSettings, substituteParams, getRequestHeaders, chat_metadata, this_chid, characters, saveCharacterDebounced, menu_type, eventSource, event_types, getExtensionPromptByName, saveMetadata, getCurrentChatId, extension_prompt_roles, create_save, createOrEditCharacter, name1 } from '../script.js';
-import { download, debounce, initScrollHeight, resetScrollHeight, parseJsonFile, extractDataFromPng, getFileBuffer, getCharaFilename, getSortableDelay, escapeRegex, PAGINATION_TEMPLATE, navigation_option, waitUntilCondition, isTrueBoolean, setValueByPath, flashHighlight, select2ModifyOptions, getSelect2OptionId, dynamicSelect2DataViaAjax, highlightRegex, select2ChoiceClickSubscribe, isFalseBoolean, getSanitizedFilename, checkOverwriteExistingData, getStringHash, parseStringArray, cancelDebounce, findChar, onlyUnique, equalsIgnoreCaseAndAccents } from './utils.js';
+import { download, debounce, initScrollHeight, resetScrollHeight, parseJsonFile, extractDataFromPng, getFileBuffer, getCharaFilename, getSortableDelay, escapeRegex, PAGINATION_TEMPLATE, navigation_option, waitUntilCondition, isTrueBoolean, setValueByPath, flashHighlight, select2ModifyOptions, getSelect2OptionId, dynamicSelect2DataViaAjax, highlightRegex, select2ChoiceClickSubscribe, isFalseBoolean, getSanitizedFilename, checkOverwriteExistingData, getStringHash, parseStringArray, cancelDebounce, findChar, onlyUnique, equalsIgnoreCaseAndAccents, uuidv4, normalizeArray, getUniqueName } from './utils.js';
 import { extension_settings, getContext } from './extensions.js';
 import { NOTE_MODULE_NAME, metadata_keys, shouldWIAddPrompt } from './authors-note.js';
 import { isMobile } from './RossAscends-mods.js';

 import { renderTemplateAsync } from './templates.js';
 import { t } from './i18n.js';
 import { accountStorage } from './util/AccountStorage.js';
+import { getOrCreatePersonaDescriptor, setPersonaDescription, user_avatar } from './personas.js';
 export const world_info_insertion_strategy = {
     evenly: 0,

     /**
      * Gets the name of the persona-bound lorebook.
-     * @returns {string} The name of the persona-bound lorebook
+     * @param {import('./slash-commands/SlashCommand.js').NamedArguments} args Named arguments
+     * @param {string} _unnamedArg not used
+     * @returns {Promise<string>} The name of the persona-bound lorebook
      */
-    function getPersonaBookCallback() {
+    async function getPersonaBookCallback({ name, create }, _unnamedArg) {
-        return power_user.persona_description_lorebook || '';
+        let bookName = power_user.persona_description_lorebook || '';
+        if (bookName) {
+            return bookName;
+        }
+        if (isTrueBoolean(String(create))) {
+            const newName = await createWorldWithName(name, `Persona Book ${name1}`.replace(/[^a-z0-9 -]/gi, '_').replace(/_{2,}/g, '_').substring(0, 64));
+            power_user.persona_description_lorebook = newName;
+            setPersonaDescription();
+            saveSettingsDebounced();
+            return newName;
+        }
+        return '';
+    }
     /**
      * Gets the name of the character-bound lorebook.
      * @param {import('./slash-commands/SlashCommand.js').NamedArguments} args Named arguments
-     * @param {string} name Character name
+     * @param {string} characterIdentifier Character name
-     * @returns {string} The name of the character-bound lorebook, a JSON string of the character's lorebooks, or an empty string
+     * @returns {Promise<string>} The name of the character-bound lorebook, a JSON string of the character's lorebooks, or an empty string
      */
-    function getCharBookCallback({ type }, name) {
+    async function getCharBookCallback({ type, name, create }, characterIdentifier) {
         const context = getContext();
-        if (context.groupId && !name) throw new Error('This command is not available in groups without providing a character name');
+        if (context.groupId && !characterIdentifier) throw new Error('This command is not available in groups without providing a character name');
         type = String(type ?? '').trim().toLowerCase() || 'primary';
-        name = String(name ?? '') || context.characters[context.characterId]?.avatar || null;
+        characterIdentifier = String(characterIdentifier ?? '') || context.characters[context.characterId]?.avatar || null;
-        const character = findChar({ name });
+        const character = findChar({ name: characterIdentifier });
         if (!character) {
             toastr.error(t`Character not found.`);
             return '';
+        }
         const books = [];
-        if (type === 'all' || type === 'primary') {
+        if (type === 'all' || type === 'primary' && character.data?.extensions?.world) {
-            books.push(character.data?.extensions?.world);
+            books.push(character.data.extensions.world);
+        }
         if (type === 'all' || type === 'additional') {
             const fileName = getCharaFilename(context.characters.indexOf(character));
             const extraCharLore = world_info.charLore?.find((e) => e.name === fileName);
             if (extraCharLore && Array.isArray(extraCharLore.extraBooks)) {
-                books.push(...extraCharLore.extraBooks);
+                books.push(...extraCharLore.extraBooks.filter(onlyUnique).filter(Boolean));
+            }
+        }
+        if (isTrueBoolean(String(create)) && books.length === 0) {
+            const newName = await createWorldWithName(name, `Character Book ${character.name}`.replace(/[^a-z0-9 -]/gi, '_').replace(/_{2,}/g, '_').substring(0, 64));
+            // Also assign the book now - additional if requested, otherwise as primary
+            if (type === 'additional') {
+                await charUpdateAddAuxWorld(character.avatar, newName);
+            }
+            else {
+                await charUpdatePrimaryWorld(newName);
+            }
+            // Refresh UI, if needed
+            setWorldInfoButtonClass(this_chid);
+            books.push(newName);
+        }
         return type === 'primary' ? (books[0] ?? '') : JSON.stringify(books.filter(onlyUnique).filter(Boolean));
+    }

             return chat_metadata[METADATA_KEY];
+        }
-        const name = (() => {
+        if (isFalseBoolean(String(args.create))) {
+            return '';
+        }
+        const name = await createWorldWithName(args.name, `Chat Book ${getCurrentChatId()}`.replace(/[^a-z0-9 -]/gi, '_').replace(/_{2,}/g, '_').substring(0, 64));
+        chat_metadata[METADATA_KEY] = name;
+        await saveMetadata();
+        $('.chat_lorebook_button').addClass('world_set');
+        return name;
+    }
+    async function createWorldWithName(possibleName = undefined, fallbackName = undefined) {
+        let newName = (() => {
             // Use the provided name if it's not in use
-            if (typeof args.name === 'string') {
+            if (typeof possibleName === 'string') {
-                const name = String(args.name);
+                const name = String(possibleName);
                 if (world_names.includes(name)) {
                     throw new Error('This World Info file name is already in use');
+                }

+            }
             // Replace non-alphanumeric characters with underscores, cut to 64 characters
-            return `Chat Book ${getCurrentChatId()}`.replace(/[^a-z0-9]/gi, '_').replace(/_{2,}/g, '_').substring(0, 64);
+            return fallbackName ?? `Lorebook (${uuidv4()})`;
         })();
-        await createNewWorldInfo(name);
-        chat_metadata[METADATA_KEY] = name;
+        // Make sure the name is unique
-        await saveMetadata();
+        newName = getUniqueName(newName, world_names.includes.bind(world_names));
-        $('.chat_lorebook_button').addClass('world_set');
-        return name;
+        await createNewWorldInfo(newName);
+        return newName;
+    }
     async function findBookEntryCallback(args, value) {

                 isRequired: false,
                 acceptsMultiple: false,
             }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'create',
+                description: 'create a new lorebook if it doesn\'t exist',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                isRequired: false,
+                acceptsMultiple: false,
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+                defaultValue: 'true',
+            }),
         ],
         aliases: ['getchatlore', 'getchatwi'],
     }));

         name: 'getpersonabook',
         callback: getPersonaBookCallback,
         returns: 'lorebook name',
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'name',
+                description: 'lorebook name if creating a new one, will be auto-generated otherwise',
+                typeList: [ARGUMENT_TYPE.STRING],
+                isRequired: false,
+                acceptsMultiple: false,
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'create',
+                description: 'create a new lorebook if it doesn\'t exist',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                isRequired: false,
+                acceptsMultiple: false,
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+                defaultValue: 'false',
+            }),
+        ],
         helpString: 'Get a name of the current persona-bound lorebook and pass it down the pipe. Returns empty string if persona lorebook is not set.',
         aliases: ['getpersonalore', 'getpersonawi'],
     }));

                 enumList: ['primary', 'additional', 'all'],
                 defaultValue: 'primary',
             }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'name',
+                description: 'lorebook name if creating a new one, will be auto-generated otherwise',
+                typeList: [ARGUMENT_TYPE.STRING],
+                isRequired: false,
+                acceptsMultiple: false,
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'create',
+                description: 'create a new lorebook if it doesn\'t exist',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                isRequired: false,
+                acceptsMultiple: false,
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+                defaultValue: 'false',
+            }),
         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({

@@ -3995,6 +4083,16 @@ export async function deleteWorldInfo(worldInfoName) {
3995	}	4083	}
3996	}	4084	}
3997		4085
		4086	if (power_user.persona_description_lorebook === worldInfoName) {
		4087	power_user.persona_description_lorebook = '';
		4088	if (power_user.personas[user_avatar]) {
		4089	const object = getOrCreatePersonaDescriptor();
		4090	object.lorebook = '';
		4091	}
		4092	$('#persona_lore_button').toggleClass('world_set', false);
		4093	saveSettingsDebounced();
		4094	}
		4095
3998	return true;	4096	return true;
3999	}	4097	}
4000		4098

+    }
+}
+/**
+ * Updates the primary world info linked to a character.
+ * Can also unset it to null.
+ * @param {string} name - The name of the world info to link to the character.
+ */
+export async function charUpdatePrimaryWorld(name) {
+    const previousValue = $('#character_world').val();
+    $('#character_world').val(name);
+    console.debug('Character world selected:', name);
+    if (menu_type == 'create') {
+        create_save.world = name;
+        return;
+    }
+    if (previousValue && !name) {
+        try {
+            // Dirty hack to remove embedded lorebook from character JSON data.
+            const data = JSON.parse(String($('#character_json_data').val()));
+            if (data?.data?.character_book) {
+                data.data.character_book = undefined;
+            }
+            $('#character_json_data').val(JSON.stringify(data));
+            toastr.info(t`Embedded lorebook will be removed from this character.`);
+        } catch {
+            console.error('Failed to parse character JSON data.');
+        }
+    }
+    await createOrEditCharacter();
+    setWorldInfoButtonClass(undefined, !!name);
+}
+/**
+ * Adds one or more auxiliary world books to a character.
+ * @param {string} characterKey - The key of the character to add auxiliary world books to
+ * @param {string|string[]} nameOrNames - The name or names of the auxiliary world books to add
+ */
+export async function charUpdateAddAuxWorld(characterKey, nameOrNames) {
+    const fileName = getCharaFilename(null, { manualAvatarKey: characterKey });
+    const toAdd = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
+    updateAuxBooks(fileName, curr => [...curr, ...toAdd]);
+}
+/**
+ * Replaces the entire list of auxiliary world books for a character.
+ * @param {string} fileName - The filename of the character to update
+ * @param {string[]} books - The new list of auxiliary world books to replace the existing list with
+ */
+export function charSetAuxWorlds(fileName, books) {
+    updateAuxBooks(fileName, _ => Array.isArray(books) ? books : []);
+}
+function updateAuxBooks(fileName, computeNext) {
+    if (!fileName) return;
+    if (menu_type === 'create') {
+        const current = create_save.extra_books ?? [];
+        create_save.extra_books = normalizeArray(computeNext(current));
+        return; // no debounced save in create flow
+    }
+    const charLore = world_info.charLore ?? [];
+    const idx = charLore.findIndex(e => e.name === fileName);
+    const current = idx !== -1 ? (charLore[idx].extraBooks ?? []) : [];
+    const next = normalizeArray(computeNext(current));
+    if (next.length === 0) {
+        if (idx !== -1) charLore.splice(idx, 1);
+    } else if (idx === -1) {
+        charLore.push({ name: fileName, extraBooks: next });
+    } else {
+        charLore[idx] = { ...charLore[idx], extraBooks: next };
+    }
+    Object.assign(world_info, { charLore });
+    saveSettingsDebounced();
+}
 export function initWorldInfo() {
     $('#world_info').on('mousedown change', async function (e) {
         // If there's no world names, don't do anything