Expand /persona-lock command for type - Add new main alias for /lock, renamed to /persona-lock - Allow no state to be provided to return the current lock state - Deprecate the old usage of /lock without state, without breaking it

745453264160344a2a52accdcad4c5afc71ec027

Wolfsblvt <wolfsblvt@gmail.com>

Parents: 91dabeff53cfc769bcfca32a7fcf2bd499aa9742

public/scripts/personas.js+16 -7 Viewed

  * @param {PersonaLockType} type - Lock type
  * @returns {boolean} Whether the persona is locked
  */
 export function isPersonaLocked(type = 'chat') {
     switch (type) {
         case 'default':
             return power_user.default_persona === user_avatar;

 /**
  * Locks or unlocks the persona
  * @param {boolean} state Desired lock state
 + * @param {PersonaLockType} type - Lock type
  * @returns {Promise<void>}
  */
 export async function setPersonaLockState(state, type = 'chat') {
     return state ? await lockPersona(type) : await unlockPersona(type);
+}
 /**
  * Toggle the persona lock state
  * @param {PersonaLockType} type - Lock type
  * @returns {Promise<voidboolean>} - Whether the persona was locked
  */
 export async function togglePersonaLock(type = 'chat') {
     returnif (isPersonaLocked(type)) {
         ? await unlockPersona(type);
 -        : await lockPersona(type);
 +        return false;
 +    } else {
 +        await lockPersona(type);
 +        return true;
 +    }
+}
 /**

@@ -810,6 +815,8 @@ async function unlockPersona(type = 'chat') {
810	815	}
811	816	break;
812	817	}
	818	+ default:
	819	+ throw new Error(`Unknown persona lock type: ${type}`);
813	820	}
814	821
815	822	updatePersonaLockIcons();

@@ -889,6 +896,8 @@ async function lockPersona(type = 'chat') {
889	896	}
890	897	break;
891	898	}
	899	+ default:
	900	+ throw new Error(`Unknown persona lock type: ${type}`);
892	901	}
893	902
894	903	updatePersonaLockIcons();

public/scripts/slash-commands.js+65 -11 Viewed

 import { getRegexedString, regex_placement } from './extensions/regex/engine.js';
 import { findGroupMemberId, groups, is_group_generating, openGroupById, resetSelectedGroup, saveGroupChat, selected_group } from './group-chats.js';
 import { chat_completion_sources, oai_settings, promptManager } from './openai.js';
 import { autoSelectPersona, isPersonaLocked, retriggerFirstMessageOnEmptyChat, setPersonaLockState, togglePersonaLock, user_avatar } from './personas.js';
 import { addEphemeralStoppingString, chat_styles, flushEphemeralStoppingStrings, power_user } from './power-user.js';
 import { SERVER_INPUTS, textgen_types, textgenerationwebui_settings } from './textgen-settings.js';
 import { decodeTextTokens, getAvailableTokenizers, getFriendlyTokenizerName, getTextTokens, getTokenCountAsync, selectTokenizer } from './tokenizers.js';

 import { SlashCommandBreakController } from './slash-commands/SlashCommandBreakController.js';
 import { SlashCommandExecutionError } from './slash-commands/SlashCommandExecutionError.js';
 import { slashCommandReturnHelper } from './slash-commands/SlashCommandReturnHelper.js';
 +import { t } from './i18n.js';
 export {
     executeSlashCommands, executeSlashCommandsWithOptions, getSlashCommandsHelp, registerSlashCommand,
 };

         helpString: 'Syncs the user persona in user-attributed messages in the current chat.',
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'persona-lock',
         callback: lockPersonaCallback,
 +        returns: 'The current lock state for the given type',
 +        helpString: 'Locks/unlocks a persona (name and avatar) to the current chat. Gets the current lock state for the given type if no state is provided.',
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'type',
 +                description: 'The type of the lock, where it should apply to',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'chat',
 +                enumList: [
 +                    new SlashCommandEnumValue('chat', 'Lock the persona to the current chat.'),
 +                    new SlashCommandEnumValue('character', 'Lock this persona to the currently selected character. If the setting is enabled, mutliple personas can be locked to the same character.'),
 +                    new SlashCommandEnumValue('default', 'Lock this persona as the default persona for all new chats.'),
 +                ],
 +            }),
 +        ],
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'state',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                enumProvider: commonEnumProviders.boolean('onOffToggle'),
 +            }),
 +        ],
 +    }));
 +    // TODO: Legacy command. Might be removed in the future and replaced by /persona-lock with aliases.
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'lock',
 +        callback: (args, value) => {
 +            if (!value) {
 +                value = 'toggle';
 +                toastr.warning(t`Using /lock without a provided state to toggle the persona is deprecated. Please use /persona-lock instead.
 +                    In the future this command with no state provided will return the current state, instead of toggling it.`, t`Deprecation Warning`);
 +            }
 +            return lockPersonaCallback(args, value);
 +        },
 +        returns: 'The current lock state for the given type',
         aliases: ['bind'],
         helpString: 'Locks/unlocks a persona (name and avatar) to the current chat. Gets the current lock state for the given type if no state is provided.',
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'type',
 +                description: 'The type of the lock, where it should apply to',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'chat',
 +                enumList: [
 +                    new SlashCommandEnumValue('chat', 'Lock the persona to the current chat.'),
 +                    new SlashCommandEnumValue('character', 'Lock this persona to the currently selected character. If the setting is enabled, mutliple personas can be locked to the same character.'),
 +                    new SlashCommandEnumValue('default', 'Lock this persona as the default persona for all new chats.'),
 +                ],
 +            }),
 +        ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'state',
                 typeList: [ARGUMENT_TYPE.STRING],
 -                isRequired: true,
                 defaultValue: 'toggle',
                 enumProvider: commonEnumProviders.boolean('onOffToggle'),
             }),

+}
 async function lockPersonaCallback(_args, value) {
 -    if (['toggle', 't', ''].includes(value.trim().toLowerCase())) {
 +    const type = _args.type ?? 'chat';
 -        await togglePersonaLock();
++
 -        return '';
 +    if (!value) {
 +        return String(isPersonaLocked(type));
 +    }
++
 +    if (['toggle', 't'].includes(value.trim().toLowerCase())) {
 +        const result = await togglePersonaLock(type);
 +        return String(result);
+    }
     if (isTrueBoolean(value)) {
         await setPersonaLockState(true, type);
         return 'true';
+    }
     if (isFalseBoolean(value)) {
         await setPersonaLockState(false, type);
         return 'false';
+    }