Add slash commands for checkpoints and branch

22d2b7d2a2f0f918d2c9de79739395f3b8335e30

Wolfsblvt <wolfsblvt@gmail.com>

Parents: cb9e73decaa808a85306ca59f26b6211a085a254

public/script.js+2 -0 Viewed

 } from './scripts/nai-settings.js';
 import {
 +    initBookmarks,
     showBookmarksButtons,
     updateBookmarkDisplay,
 } from './scripts/bookmarks.js';

     initDynamicStyles();
     initTags();
     initOpenai();
 +    initBookmarks();
     await getUserAvatars(true, user_avatar);
     await getCharacters();
     await getBackgrounds();

public/scripts/bookmarks.js+277 -24 Viewed

     selected_group,
 } from './group-chats.js';
 import { hideLoader, showLoader } from './loader.js';
 +import { getLastMessageId } from './macros.js';
 import { Popup } from './popup.js';
 +import { SlashCommand } from './slash-commands/SlashCommand.js';
 +import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
 +import { commonEnumProviders } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 +import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { createTagMapFromList } from './tags.js';
 import {

@@ -51,10 +56,10 @@ async function getExistingChatNames() {
51	56	}
52	57	}
53	58
54	59	async function getBookmarkName({ forceName = null } = {}) {
55	60	const chatNames = await getExistingChatNames();
56	61
57	62	let name = forceName \|\| await Popup.show.input('Create Checkpoint', '<span class="margin-right-10px">Enter Checkpoint Name:</span><small>(Leave empty to auto-generate)</small>');
58	63	if (name === null) {
59	64	return null;
60	65	}

     return name;
+}
 -export async function createNewBookmark(mesId) {
 +/**
 + * Creates a new bookmark for a message.
 + *
 + * @param {number} mesId - The ID of the message.
 + * @param {Object} [options={}] - Optional parameters.
 + * @param {string?} [options.forceName=null] - The name to force for the bookmark.
 + * @returns {Promise<string?>} - A promise that resolves to the bookmark name when the bookmark is created.
 + */
 +export async function createNewBookmark(mesId, { forceName = null } = {}) {
     if (this_chid === undefined && !selected_group) {
         toastr.info('No character selected.', 'Checkpoint creationCreate abortedCheckpoint');
         return null;
+    }
+-
     if (!chat.length) {
         toastr.warning('The chat is empty.', 'Checkpoint creationCreate failedCheckpoint');
         return null;
+    }
+-
 +    if (!chat[mesId]) {
 -    if (mesId < 0 || mesId >= chat.length) {
 +        toastr.warning('Invalid message ID.', 'Create Checkpoint');
 -        toastr.warning('Invalid message ID.', 'Checkpoint creation failed');
 +        return null;
 -        return;
+    }
     const lastMes = chat[mesId];

@@ -181,16 +192,16 @@ export async function createNewBookmark(mesId) {
181	192	lastMes.extra = {};
182	193	}
183	194
184	195	if (lastMes.extra.bookmark_link && !forceName) {
185	196	const confirm = await Popup.show.confirm('Replace Checkpoint', 'Checkpoint for the last message already exists.<br />Would you like to replace it?');
186	197	if (!confirm) {
187	198	return null;
188	199	}
189	200	}
190	201
191	202	let name = await getBookmarkName({ forceName: forceName });
192	203	if (!name) {
193	204	return null;
194	205	}
195	206
196	207	const mainChat = selected_group ? groups?.find(x => x.id == selected_group)?.chat_id : characters[this_chid].chat;

     updateBookmarkDisplay(mes, name);
     await saveChatConditional();
     toastr.success('Click the flag icon next to the message to open the checkpoint chat.', 'CheckpointCreate createdCheckpoint', { timeOut: 10000 });
 +    return name;
+}

@@ -233,7 +245,10 @@ async function backToMainChat() {
233	245	} else {
234	246	await openCharacterChat(mainChatName);
235	247	}
	248	+ return mainChatName;
236	249	}
	250	+
	251	+ return null;
237	252	}
238	253
239	254	export async function convertSoloToGroupChat() {

 /**
  * Creates a new branch from the message with the given ID
  * @param {number} mesId Message ID
  * @returns {Promise<string?>} Branch file name
  */
 export async function branchChat(mesId) {
     if (this_chid === undefined && !selected_group) {
         toastr.info('No character selected.', 'Branch creationCreate abortedBranch');
         return null;
+    }
     const fileName = await createBranch(mesId);

     return fileName;
+}
 jQuery(function registerBookmarksSlashCommands() {
 +    /**
 +     * Validates a message ID. (Is a number, exists as a message)
 +     *
 +     * @param {number} mesId - The message ID to validate.
 +     * @param {string} context - The context of the slash command. Will be used as the title of any toasts.
 +     * @returns {boolean} - Returns true if the message ID is valid, otherwise false.
 +     */
 +    function validateMessageId(mesId, context) {
 +        if (isNaN(mesId)) {
 +            toastr.warning('Invalid message ID was provided', context);
 +            return false;
 +        }
 +        if (!chat[mesId]) {
 +            toastr.warning(`Message for id ${mesId} not found`, context);
 +            return false;
 +        }
 +        return true;
 +    }
++
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'branch-create',
 +        returns: 'Name of the new branch',
 +        callback: async (args, text) => {
 +            const mesId = Number(args.mesId ?? text ?? getLastMessageId());
 +            if (!validateMessageId(mesId, 'Create Branch')) return '';
++
 +            const branchName = await branchChat(mesId);
 +            return branchName ?? '';
 +        },
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'mes',
 +                description: 'Message ID',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                enumProvider: commonEnumProviders.messages(),
 +            }),
 +        ],
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'Message ID',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                enumProvider: commonEnumProviders.messages(),
 +            }),
 +        ],
 +        helpString: `
 +        <div>
 +            Create a new branch from the selected message. If no message id is provided, will use the last message.
 +        </div>
 +        <div>
 +            Creating a branch will automatically choose a name for the branch.<br />
 +            After creating the branch, the branch chat will be automatically opened.
 +        </div>
 +        <div>
 +            Use Checkpoints and <code>/checkpoint-create</code> instead if you do not want to jump to the new chat.
 +        </div>`,
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'checkpoint-create',
 +        returns: 'Name of the new checkpoint',
 +        callback: async (args, text) => {
 +            const mesId = Number(args.mesId ?? getLastMessageId());
 +            if (!validateMessageId(mesId, 'Create Checkpoint')) return '';
++
 +            if (!text || typeof text !== 'string') {
 +                toastr.warning('Checkpoint name must be provided', 'Create Checkpoint');
 +                return '';
 +            }
++
 +            const checkPointName = await createNewBookmark(mesId, { forceName: text });
 +            return checkPointName ?? '';
 +        },
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'mes',
 +                description: 'Message ID',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                enumProvider: commonEnumProviders.messages(),
 +            }),
 +        ],
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'Checkpoint name',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: true,
 +            }),
 +        ],
 +        helpString: `
 +        <div>
 +            Create a new checkpoint for the selected message with the provided name. If no message id is provided, will use the last message.
 +        </div>
 +        <div>
 +            A created checkpoint will be permanently linked with the message.<br />
 +            If a checkpoint already exists, the link to it will be overwritten.<br />
 +            After creating the checkpoint, the checkpoint chat can be opened with the checkpoint flag,
 +            using the <code>/go</code> command with the checkpoint name or the <code>/checkpoint-go</code> command on the message.
 +        </div>
 +        <div>
 +            Use Branches and <code>/branch-create</code> instead if you do want to jump to the new chat.
 +        </div>
 +        <div>
 +            <strong>Example:</strong>
 +            <ul>
 +                <li>
 +                    <pre><code>/checkpoint-create mes={{lastCharMessage}} Checkpoint for char reply | /setvar key=rememberCheckpoint {{pipe}}</code></pre>
 +                    Will create a new checkpoint to the latest message of the current character, and save it as a local variable for future use.
 +                </li>
 +            </ul>
 +        </div>`,
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'checkpoint-go',
 +        returns: 'Name of the checkpoint',
 +        callback: async (args, text) => {
 +            const mesId = Number(args.mesId ?? text ?? getLastMessageId());
 +            if (!validateMessageId(mesId, 'Open Checkpoint')) return '';
++
 +            const checkPointName = chat[mesId].extra?.bookmark_link;
 +            if (!checkPointName) {
 +                toastr.warning('No checkpoint is linked to the selected message', 'Open Checkpoint');
 +                return '';
 +            }
++
 +            if (selected_group) {
 +                await openGroupChat(selected_group, checkPointName);
 +            } else {
 +                await openCharacterChat(checkPointName);
 +            }
++
 +            return checkPointName;
 +        },
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'mes',
 +                description: 'Message ID',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                enumProvider: commonEnumProviders.messages(),
 +            }),
 +        ],
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'Message ID',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                enumProvider: commonEnumProviders.messages(),
 +            }),
 +        ],
 +        helpString: `
 +        <div>
 +            Open the checkpoint linked to the selected message. If no message id is provided, will use the last message.
 +        </div>
 +        <div>
 +            Use <code>/checkpoint-get</code> if you want to make sure that the selected message has a checkpoint.
 +        </div>`,
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'checkpoint-exit',
 +        returns: 'The name of the chat exited to. Returns null if not in a checkpoint chat.',
 +        callback: async () => {
 +            const mainChat = await backToMainChat();
 +            return mainChat ?? '';
 +        },
 +        helpString: 'Exit the checkpoint chat.<br />If not in a checkpoint chat, returns null.',
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'checkpoint-parent',
 +        returns: 'Name of the parent chat for this checkpoint',
 +        callback: async () => {
 +            const mainChatName = getMainChatName();
 +            return mainChatName ?? '';
 +        },
 +        helpString: 'Get the name of the parent chat for this checkpoint. If not in a checkpoint chat, returns null.',
 +    }))
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'checkpoint-get',
 +        returns: 'Name of the chat',
 +        callback: async (args, text) => {
 +            const mesId = Number(args.mesId ?? text ?? getLastMessageId());
 +            if (!validateMessageId(mesId, 'Get Checkpoint')) return '';
++
 +            const checkPointName = chat[mesId].extra?.bookmark_link;
 +            return checkPointName ?? '';
 +        },
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'mes',
 +                description: 'Message ID',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                enumProvider: commonEnumProviders.messages(),
 +            }),
 +        ],
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'Message ID',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                enumProvider: commonEnumProviders.messages(),
 +            }),
 +        ],
 +        helpString: `
 +        <div>
 +            Get the name of the checkpoint linked to the selected message. If no message id is provided, will use the last message.<br />
 +            If no checkpoint is linked, the result will be empty.
 +        </div>`,
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'checkpoint-list',
 +        returns: 'JSON array of all existing checkpoints in this chat, as an array',
 +        /** @param {{links?: string}} args @returns {Promise<string>} */
 +        callback: async (args, _) => {
 +            const result = [];
 +            for (const mesId in chat) {
 +                if (chat[mesId].extra?.bookmark_link) {
 +                    result.push(args.links ? chat[mesId].extra.bookmark_link : Number(mesId));
 +                }
 +            }
 +            return JSON.stringify(result);
 +        },
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'links',
 +                description: 'Get a list of all links / chat names of the checkpoints, instead of the message ids',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumList: commonEnumProviders.boolean('trueFalse')(),
 +                defaultValue: 'false',
 +            }),
 +        ],
 +        helpString: `
 +        <div>
 +            List all existing checkpoints in this chat.
 +        </div>
 +        <div>
 +            Returns a list of all message ids that have a checkpoint, or all checkpoint links if <code>links</code> is set to <code>true</code>.<br />
 +            The value will be a JSON array.
 +        </div>`,
 +    }));
 +}
++
 +export function initBookmarks() {
     $('#option_new_bookmark').on('click', saveBookmarkMenu);
     $('#option_back_to_main').on('click', backToMainChat);
     $('#option_convert_to_group').on('click', convertSoloToGroupChat);

         // If shift is held down, we are not following the bookmark, but creating a new one
         if (e.shiftKey) {
             var selectedMesId = $(this).closest('.mes').attr('mesid');
             await createNewBookmark(Number(selectedMesId));
             return;
+        }

     $(document).on('click', '.mes_create_bookmark', async function () {
         var selected_mes_id = $(this).closest('.mes').attr('mesid');
         if (selected_mes_id !== undefined) {
             await createNewBookmark(Number(selected_mes_id));
+        }
     });

             await branchChat(Number(selected_mes_id));
+        }
     });
 -});
++
 +    registerBookmarksSlashCommands();
 +}