1026e1f8 · permissionBRICK/SillyTavern

public/scripts/chats.js+3 -1 Viewed

  * @param {number} start Starting message ID
  * @param {number} end Ending message ID (inclusive)
  * @param {boolean} unhide If true, unhide the messages instead.
+ * @param {string} nameFitler Optional name filter
  * @returns {Promise<void>}
  */
-export async function hideChatMessageRange(start, end, unhide) {
+export async function hideChatMessageRange(start, end, unhide, nameFitler = null) {
     if (isNaN(start)) return;
     if (!end) end = start;
     const hide = !unhide;

     for (let messageId = start; messageId <= end; messageId++) {
         const message = chat[messageId];
         if (!message) continue;
+        if (nameFitler && message.name !== nameFitler) continue;
         message.is_system = hide;

public/scripts/slash-commands.js+38 -18 Viewed

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'hide',
         callback: hideMessageCallback,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'name',
+                description: 'only hide messages from a certain character or persona',
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.messageNames,
+                isRequired: false,
+                acceptsMultiple: false,
+            }),
+        ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'message index (starts with 0) or range',
+                description: 'message index (starts with 0) or range, defaults to the last message index if not provided',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.RANGE],
-                isRequired: true,
+                isRequired: false,
                 enumProvider: commonEnumProviders.messages(),
             }),
         ],

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'unhide',
         callback: unhideMessageCallback,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'name',
+                description: 'only unhide messages from a certain character or persona',
+                typeList: [ARGUMENT_TYPE.STRING],
+                enumProvider: commonEnumProviders.messageNames,
+                isRequired: false,
+                acceptsMultiple: false,
+            }),
+        ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
-                description: 'message index (starts with 0) or range',
+                description: 'message index (starts with 0) or range, defaults to the last message index if not provided',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.RANGE],
-                isRequired: true,
+                isRequired: false,
                 enumProvider: commonEnumProviders.messages(),
             }),
         ],

@@ -3034,37 +3054,37 @@ async function askCharacter(args, text) {
3034	return await slashCommandReturnHelper.doReturn(args.return ?? 'pipe', message, { objectToStringFunc: x => x.mes });	3054	return await slashCommandReturnHelper.doReturn(args.return ?? 'pipe', message, { objectToStringFunc: x => x.mes });
3035	}	3055	}
3036		3056
3037	async function hideMessageCallback(_, arg) {	3057	async function hideMessageCallback(args, value) {
3038	if (!arg) {	3058	if (!value) {
3039	console.warn('WARN: No argument provided for /hide command');	3059	console.log('No range provided. Hiding the last message.');
3040	return '';
3041	}	3060	}
3042		3061
3043	const range = stringToRange(arg, 0, chat.length - 1);	3062	const range = value ? stringToRange(value, 0, chat.length - 1) : { start: chat.length - 1, end: chat.length - 1 };
3044		3063
3045	if (!range) {	3064	if (!range) {
3046	console.warn(`WARN: Invalid range provided for /hide command: ${arg}`);	3065	console.warn(`WARN: Invalid range provided for /hide command: ${value}`);
3047	return '';	3066	return '';
3048	}	3067	}
3049		3068
3050	await hideChatMessageRange(range.start, range.end, false);	3069	const nameFilter = String(args.name ?? '').trim();
		3070	await hideChatMessageRange(range.start, range.end, false, nameFilter);
3051	return '';	3071	return '';
3052	}	3072	}
3053		3073
3054	async function unhideMessageCallback(_, arg) {	3074	async function unhideMessageCallback(args, value) {
3055	if (!arg) {	3075	if (!value) {
3056	console.warn('WARN: No argument provided for /unhide command');	3076	console.log('No range provided. Unhiding the last message');
3057	return '';
3058	}	3077	}
3059		3078
3060	const range = stringToRange(arg, 0, chat.length - 1);	3079	const range = value ? stringToRange(value, 0, chat.length - 1) : { start: chat.length - 1, end: chat.length - 1 };
3061		3080
3062	if (!range) {	3081	if (!range) {
3063	console.warn(`WARN: Invalid range provided for /unhide command: ${arg}`);	3082	console.warn(`WARN: Invalid range provided for /unhide command: ${value}`);
3064	return '';	3083	return '';
3065	}	3084	}
3066		3085
3067	await hideChatMessageRange(range.start, range.end, true);	3086	const nameFilter = String(args.name ?? '').trim();
		3087	await hideChatMessageRange(range.start, range.end, true, nameFilter);
3068	return '';	3088	return '';
3069	}	3089	}
3070		3090

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+12 -3 Viewed

 import { getGroupMembers, groups } from '../group-chats.js';
 import { power_user } from '../power-user.js';
 import { searchCharByName, getTagsList, tags, tag_map } from '../tags.js';
+import { onlyUnique } from '../utils.js';
 import { world_names } from '../world-info.js';
 import { SlashCommandClosure } from './SlashCommandClosure.js';
 import { SlashCommandEnumValue, enumTypes } from './SlashCommandEnumValue.js';

      * @param {boolean} [options.allowVars=false] - Whether to add enum option for variable names
      * @returns {(executor:SlashCommandExecutor, scope:SlashCommandScope) => SlashCommandEnumValue[]}
      */
-    messages: ({ allowIdAfter = false, allowVars = false } = {}) => (_, scope) => {
+    messages: ({ allowIdAfter = false, allowVars = false } = {}) => (executor, scope) => {
+        const nameFilter = executor.namedArgumentList.find(it => it.name == 'name')?.value || '';
         return [
-            ...chat.map((message, index) => new SlashCommandEnumValue(String(index), `${message.name}: ${message.mes}`, enumTypes.number, message.is_user ? enumIcons.user : message.is_system ? enumIcons.system : enumIcons.assistant)),
+            ...chat.map((message, index) => new SlashCommandEnumValue(String(index), `${message.name}: ${message.mes}`, enumTypes.number, message.is_user ? enumIcons.user : message.is_system ? enumIcons.system : enumIcons.assistant)).filter(value => !nameFilter || value.description.startsWith(`${nameFilter}:`)),
             ...allowIdAfter ? [new SlashCommandEnumValue(String(chat.length), '>> After Last Message >>', enumTypes.enum, '➕')] : [],
-            ...allowVars ? commonEnumProviders.variables('all')(_, scope) : [],
+            ...allowVars ? commonEnumProviders.variables('all')(executor, scope) : [],
         ];
     },
     /**
+     * All names used in the current chat.
+     *
+     * @returns {SlashCommandEnumValue[]}
+     */
+    messageNames: () => chat.map((message) => message.name).filter(onlyUnique).sort(Intl.Collator().compare).map(name => new SlashCommandEnumValue(name)),
+    /**
      * All existing worlds / lorebooks
+     *
      * @returns {SlashCommandEnumValue[]}

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

 } from '../lib.js';
 import { getContext } from './extensions.js';
-import { characters, getRequestHeaders, this_chid } from '../script.js';
+import { characters, getRequestHeaders, this_chid, user_avatar } from '../script.js';
 import { isMobile } from './RossAscends-mods.js';
 import { collapseNewlines, power_user } from './power-user.js';
 import { debounce_timeout } from './constants.js';

+}
 /**
+ * Finds a persona by name, with optional filtering and precedence for avatars
+ * @param {object} [options={}] - The options for the search
+ * @param {string?} [options.name=null] - The name to search for
+ * @param {boolean} [options.allowAvatar=true] - Whether to allow searching by avatar
+ * @param {boolean} [options.insensitive=true] - Whether the search should be case insensitive
+ * @param {boolean} [options.preferCurrentPersona=true] - Whether to prefer the current persona(s)
+ * @param {boolean} [options.quiet=false] - Whether to suppress warnings
+ * @returns {PersonaViewModel} The persona object
+ * @typedef {object} PersonaViewModel
+ * @property {string} avatar - The avatar of the persona
+ * @property {string} name - The name of the persona
+ */
+export function findPersona({ name = null, allowAvatar = true, insensitive = true, preferCurrentPersona = true, quiet = false } = {}) {
+    /** @type {PersonaViewModel[]} */
+    const personas = Object.entries(power_user.personas).map(([avatar, name]) => ({ avatar, name }));
+    const matches = (/** @type {PersonaViewModel} */ persona) => !name || (allowAvatar && persona.avatar === name) || (insensitive ? equalsIgnoreCaseAndAccents(persona.name, name) : persona.name === name);
+    // If we have a current persona and prefer it, return that if it matches
+    const currentPersona = personas.find(a => a.avatar === user_avatar);
+    if (preferCurrentPersona && currentPersona && matches(currentPersona)) {
+        return currentPersona;
+    }
+    // If allowAvatar is true, search by avatar first
+    if (allowAvatar && name) {
+        const personaByAvatar = personas.find(a => a.avatar === name);
+        if (personaByAvatar && matches(personaByAvatar)) {
+            return personaByAvatar;
+        }
+    }
+    // Search for matching personas by name
+    const matchingPersonas = personas.filter(a => matches(a));
+    if (matchingPersonas.length > 1) {
+        if (!quiet) toastr.warning('Multiple personas found for given conditions.');
+        else console.warn('Multiple personas found for given conditions. Returning the first match.');
+    }
+    return matchingPersonas[0] || null;
+}
+/**
  * Finds a character by name, with optional filtering and precedence for avatars
  * @param {object} [options={}] - The options for the search
  * @param {string?} [options.name=null] - The name to search for

Add "name" argument to /hide and /unhide. Add default value for unnamed argument