Refactor /listinjects, deprecate its "format" arg

62fd450c592653fd256eaf631372cd05c72745ae

Wolfsblvt <wolfsblvt@gmail.com>

Parents: e3c0c5442c1646970802cb1243bb9e39279d28be

public/scripts/slash-commands.js+35 -19 Viewed

         name: 'listinjects',
         callback: listInjectsCallback,
         helpString: 'Lists all script injections for the current chat. Displays injects in a popup by default. Use the <code>format</code> argument to change the output format.',
         returns: 'Optionalls the JSON object of script injections',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'object',
 +                enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: 'DEPRECATED - use "return" instead - output format',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,

+}
 async function listInjectsCallback(args) {
 +    /** @type {import('./slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 +    let returnType = args.return;
++
 +    // Old legacy return type handling
 +    if (args.format) {
 +        toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
         const type = String(args?.format).toLowerCase().trim();
         if (!chat_metadata.script_injects || !Object.keys(chat_metadata.script_injects).length) {
             type !== 'none' && toastr.info('No script injections for the current chat');
 -        return JSON.stringify({});
+        }
+-
 -    const injects = Object.entries(chat_metadata.script_injects)
 -        .map(([id, inject]) => {
 -            const position = Object.entries(extension_prompt_types);
 -            const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? 'unknown';
 -            return `* **${id}**: <code>${inject.value}</code> (${positionName}, depth: ${inject.depth}, scan: ${inject.scan ?? false}, role: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
 -        })
 -        .join('\n');
+-
 -    const converter = new showdown.Converter();
 -    const messageText = `### Script injections:\n${injects}`;
 -    const htmlMessage = DOMPurify.sanitize(converter.makeHtml(messageText));
+-
         switch (type) {
             case 'none':
 +                returnType = 'none';
                 break;
             case 'chat':
 -            sendSystemMessage(system_message_types.GENERIC, htmlMessage);
 +                returnType = 'chat-html';
                 break;
             case 'popup':
             default:
 -            await callGenericPopup(htmlMessage, POPUP_TYPE.TEXT);
 +                returnType = 'popup-html';
                 break;
+        }
 +    }
++
 +    // Now the actual new return type handling
++
 +    const buildTextValue = (injects) => {
 +        const injectsStr = Object.entries(injects)
 +            .map(([id, inject]) => {
 +                const position = Object.entries(extension_prompt_types);
 +                const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? 'unknown';
 +                return `* **${id}**: <code>${inject.value}</code> (${positionName}, depth: ${inject.depth}, scan: ${inject.scan ?? false}, role: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
 +            })
 +            .join('\n');
 +        return `### Script injections:\n${injectsStr}`;
 +    };
 -    return JSON.stringify(chat_metadata.script_injects);
 +    return await slashCommandReturnHelper.doReturn(returnType ?? 'object', chat_metadata.script_injects, { objectToStringFunc: buildTextValue });
+}
 /**

public/scripts/slash-commands/SlashCommandReturnHelper.js+10 -6 Viewed

 /** @typedef {'pipe'|'object'|'chat-html'|'chat-text'|'popup-html'|'popup-text'|'toast-html'|'toast-text'|'console'|'none'} SlashCommandReturnType */
 export const slashCommandReturnHelper = {
 +    // Without this, VSCode formatter fucks up JS docs. Don't ask me why.
 +    _: false,
++
     /**
      * Gets/creates the enum list of types of return relevant for a slash command
+     *

      * @param {boolean} [options.allowObject=false] Allow option to return the value as an object
      * @param {boolean} [options.allowChat=false] Allow option to return the value as a chat message
      * @param {boolean} [options.allowPopup=false] Allow option to return the value as a popup
 +     * @param {boolean}[options.allowTextVersion=true] Used in combination with chat/popup/toast, some of them do not make sense for text versions, e.g.if you are building a HTML string anyway
      * @returns {SlashCommandEnumValue[]} The enum list
      */
     enumList: ({ allowPipe = true, allowObject = false, allowChat = false, allowPopup = false, allowTextVersion = true } = {}) => [
         allowPipe && new SlashCommandEnumValue('pipe', 'Return to the pipe for the next command', enumTypes.name, '|'),
         allowObject && new SlashCommandEnumValue('object', 'Return as an object to the pipe for the next command', enumTypes.variable, enumIcons.dictionary),
         allowChat && new SlashCommandEnumValue('chat-html', 'Sending a chat message with the return value - Can display HTML', enumTypes.command, enumIcons.message),
         allowChat && allowTextVersion && new SlashCommandEnumValue('chat-text', 'Sending a chat message with the return value - Will only display as text', enumTypes.qr, enumIcons.message),
         allowPopup && new SlashCommandEnumValue('popup-html', 'Showing as a popup with the return value - Can display HTML', enumTypes.command, enumIcons.popup),
         allowPopup && allowTextVersion && new SlashCommandEnumValue('popup-text', 'Showing as a popup with the return value - Will only display as text', enumTypes.qr, enumIcons.popup),
         new SlashCommandEnumValue('toast-html', 'Show the return value as a toast notification - Can display HTML', enumTypes.command, 'ℹ️'),
         allowTextVersion && new SlashCommandEnumValue('toast-text', 'Show the return value as a toast notification - Will only display as text', enumTypes.qr, 'ℹ️'),
         new SlashCommandEnumValue('console', 'Log the return value (object, if it can be one) to the console', enumTypes.enum, '>'),
         new SlashCommandEnumValue('none', 'No return value'),
     ].filter(x => !!x),