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
  */
-function isPersonaLocked(type = 'chat') {
+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) {
+export async function setPersonaLockState(state, type = 'chat') {
-    return state ? await lockPersona() : await unlockPersona();
+    return state ? await lockPersona(type) : await unlockPersona(type);
+}
 /**
  * Toggle the persona lock state
  * @param {PersonaLockType} type - Lock type
- * @returns {Promise<void>}
+ * @returns {Promise<boolean>} - Whether the persona was locked
  */
 export async function togglePersonaLock(type = 'chat') {
-    return isPersonaLocked(type)
+    if (isPersonaLocked(type)) {
-        ? await unlockPersona(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	break;	816	break;
812	}	817	}
		818	default:
		819	throw new Error(`Unknown persona lock type: ${type}`);
813	}	820	}
814		821
815	updatePersonaLockIcons();	822	updatePersonaLockIcons();

@@ -889,6 +896,8 @@ async function lockPersona(type = 'chat') {
889	}	896	}
890	break;	897	break;
891	}	898	}
		899	default:
		900	throw new Error(`Unknown persona lock type: ${type}`);
892	}	901	}
893		902
894	updatePersonaLockIcons();	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, retriggerFirstMessageOnEmptyChat, setPersonaLockState, togglePersonaLock, user_avatar } from './personas.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: 'lock',
+        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',
+        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'),
             }),

@@ -3346,19 +3394,25 @@ function syncCallback() {
3346	}	3394	}
3347		3395
3348	async function lockPersonaCallback(_args, value) {	3396	async function lockPersonaCallback(_args, value) {
3349	if (['toggle', 't', ''].includes(value.trim().toLowerCase())) {	3397	const type = _args.type ?? 'chat';
3350	await togglePersonaLock();	3398
3351	return '';	3399	if (!value) {
		3400	return String(isPersonaLocked(type));
		3401	}
		3402
		3403	if (['toggle', 't'].includes(value.trim().toLowerCase())) {
		3404	const result = await togglePersonaLock(type);
		3405	return String(result);
3352	}	3406	}
3353		3407
3354	if (isTrueBoolean(value)) {	3408	if (isTrueBoolean(value)) {
3355	await setPersonaLockState(true);	3409	await setPersonaLockState(true, type);
3356	return '';	3410	return 'true';
3357	}	3411	}
3358		3412
3359	if (isFalseBoolean(value)) {	3413	if (isFalseBoolean(value)) {
3360	await setPersonaLockState(false);	3414	await setPersonaLockState(false, type);
3361	return '';	3415	return 'false';
3362		3416
3363	}	3417	}
3364		3418