optimize chat manager logic

30e9e90b3850ee8eaeeab11ba04e84414c0b46f9

p3il4 <42489293+P3il4@users.noreply.github.com>

Parents: b6c4b3cdd2765f070a169a299d3ac982af107fe7

public/script.js+48 -85 Viewed

     $('#select_chat_div').empty();
     $('#select_chat_search').val('').off('input');
-    const data = await (selected_group ? getGroupPastChats(selected_group) : getPastCharacterChats());
-    if (!data) {
-        toastr.error(t`Could not load chat data. Try reloading the page.`);
-        return;
-    }
     const chatDetails = getCurrentChatDetails();
-    const group = chatDetails.group;
     const currentChat = chatDetails.sessionName;
     const displayName = chatDetails.characterName;
     const avatarImg = chatDetails.avatarImgURL;
-    const rawChats = await getChatsFromFiles(data, selected_group);
+    await displayChats('', currentChat, displayName, avatarImg, selected_group);
-    // Sort by last message date descending
-    data.sort((a, b) => sortMoments(timestampToMoment(a.last_mes), timestampToMoment(b.last_mes)));
-    console.log(data);
-    $('#load_select_chat_div').css('display', 'none');
-    $('#ChatHistoryCharName').text(`${displayName}'s `);
-    const displayChats = (searchQuery) => {
+    const debouncedDisplay = debounce((searchQuery) => {
-        $('#select_chat_div').empty();  // Clear the current chats before appending filtered chats
+        displayChats(searchQuery, currentChat, displayName, avatarImg, selected_group);
+    });
-        const filteredData = data.filter(chat => {
+    // Define the search input listener
-            const fileName = chat['file_name'];
+    $('#select_chat_search').on('input', function () {
-            const chatContent = rawChats[fileName];
+        const searchQuery = $(this).val();
+        debouncedDisplay(searchQuery);
+    });
-            // Make sure empty chats are displayed when there is no search query
+    // UX convenience: Focus the search field when the Manage Chat Files view opens.
-            if (Array.isArray(chatContent) && !chatContent.length && !searchQuery) {
+    setTimeout(function () {
-                return true;
+        const textSearchElement = $('#select_chat_search');
+        textSearchElement.click();
+        textSearchElement.focus();
+        textSearchElement.select();  // select content (if any) for easy erasing
+    }, 200);
+}
-            // // Uncomment this to return to old behavior (classical full-substring search).
+async function displayChats(searchQuery, currentChat, displayName, avatarImg, selected_group) {
-            // return chatContent && Object.values(chatContent).some(message => message?.mes?.toLowerCase()?.includes(searchQuery.toLowerCase()));
+    try {
+        const response = await fetch('/api/chats/search', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify({
+                query: searchQuery,
+                avatar_url: selected_group ? null : characters[this_chid].avatar,
+                group_id: selected_group || null
+            }),
+        });
-            // Fragment search a.k.a. swoop (as in `helm-swoop` in the Helm package of Emacs).
+        if (!response.ok) {
-            // Split a `query` {string} into its fragments {string[]}.
+            throw new Error('Search failed');
-            function makeQueryFragments(query) {
-                let fragments = query.trim().split(/\s+/).map(str => str.trim().toLowerCase()).filter(onlyUnique);
-                // fragments = fragments.filter( function(str) { return str.length >= 3; } );  // Helm does this, but perhaps better if we don't.
-                return fragments;
-            }
-            // Check whether `text` {string} includes all of the `fragments` {string[]}.
-            function matchFragments(fragments, text) {
-                if (!text || !text.toLowerCase) return false;
-                return fragments.every(item => text.toLowerCase().includes(item));
+        }
-            const fragments = makeQueryFragments(searchQuery);
-            // At least one chat message must match *all* the fragments.
-            // Currently, this doesn't match if the fragment matches are distributed across several chat messages.
-            return chatContent && Object.values(chatContent).some(message => matchFragments(fragments, message?.mes));
-        });
-        console.debug(filteredData);
+        const filteredData = await response.json();
-        for (const value of filteredData.values()) {
+        $('#select_chat_div').empty();
-            let strlen = 300;
-            let mes = value['mes'];
-            if (mes !== undefined) {
+        for (const chat of filteredData) {
-                if (mes.length > strlen) {
-                    mes = '...' + mes.substring(mes.length - strlen);
-                }
-                const fileSize = value['file_size'];
-                const fileName = value['file_name'];
-                const chatItems = rawChats[fileName].length;
-                const timestamp = timestampToMoment(value['last_mes']).format('lll');
             const template = $('#past_chat_template .select_chat_block_wrapper').clone();
-                template.find('.select_chat_block').attr('file_name', fileName);
+            template.find('.select_chat_block').attr('file_name', chat.file_name);
             template.find('.avatar img').attr('src', avatarImg);
-                template.find('.select_chat_block_filename').text(fileName);
+            template.find('.select_chat_block_filename').text(chat.file_name);
-                template.find('.chat_file_size').text(`(${fileSize},`);
+            template.find('.chat_file_size').text(`(${chat.file_size},`);
-                template.find('.chat_messages_num').text(`${chatItems}💬)`);
+            template.find('.chat_messages_num').text(`${chat.message_count}💬)`);
-                template.find('.select_chat_block_mes').text(mes);
+            template.find('.select_chat_block_mes').text(chat.preview_message);
-                template.find('.PastChat_cross').attr('file_name', fileName);
+            template.find('.PastChat_cross').attr('file_name', chat.file_name);
-                template.find('.chat_messages_date').text(timestamp);
+            template.find('.chat_messages_date').text(timestampToMoment(chat.last_mes).format('lll'));
-                if (selected_group) {
-                    template.find('.avatar img').replaceWith(getGroupAvatar(group));
-                }
             $('#select_chat_div').append(template);
-                if (currentChat === fileName.toString().replace('.jsonl', '')) {
+            if (currentChat === chat.file_name) {
                 $('#select_chat_div').find('.select_chat_block:last').attr('highlight', String(true));
+            }
+        }
+    } catch (error) {
+        console.error('Error loading chats:', error);
+        toastr.error('Could not load chat data. Try reloading the page.');
+    }
-    };
-    displayChats('');  // Display all by default
-    const debouncedDisplay = debounce((searchQuery) => {
-        displayChats(searchQuery);
-    });
-    // Define the search input listener
-    $('#select_chat_search').on('input', function () {
-        const searchQuery = $(this).val();
-        debouncedDisplay(searchQuery);
-    });
-    // UX convenience: Focus the search field when the Manage Chat Files view opens.
-    setTimeout(function () {
-        const textSearchElement = $('#select_chat_search');
-        textSearchElement.click();
-        textSearchElement.focus();
-        textSearchElement.select();  // select content (if any) for easy erasing
-    }, 200);
+}
 export function selectRightMenuWithAnimation(selectedMenuId) {

         $('#load_select_chat_div').css('display', 'block');
     });
+    // not sure what that hourglass was for
+    $('#option_select_chat').click(function () {
+        $('#load_select_chat_div').css('display', 'none');
+    });
     if (navigator.clipboard === undefined) {
         // No clipboard support
         $('.mes_copy').remove();

src/endpoints/chats.js+147 -0 Viewed

     return backupFunctions.get(handle);
+}
+/**
+ * Formats a byte size into a human-readable string with units
+ * @param {number} bytes - The size in bytes to format
+ * @returns {string} The formatted string (e.g., "1.5 MB")
+ */
+function formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+/**
+ * Gets a preview message from an array of chat messages
+ * @param {Array<Object>} messages - Array of chat messages, each with a 'mes' property
+ * @returns {string} A truncated preview of the last message or empty string if no messages
+ */
+function getPreviewMessage(messages) {
+    const strlen = 300;
+    const lastMessage = messages[messages.length - 1]?.mes;
+    if (!lastMessage) {
+        return '';
+    }
+    return lastMessage.length > strlen
+        ? '...' + lastMessage.substring(lastMessage.length - strlen)
+        : lastMessage;
+}
 process.on('exit', () => {
     for (const func of backupFunctions.values()) {
         func.flush();

     getBackupFunction(request.user.profile.handle)(request.user.directories.backups, String(id), jsonlData);
     return response.send({ ok: true });
 });
+router.post('/search', jsonParser, function (request, response) {
+    try {
+        const { query, avatar_url, group_id } = request.body;
+        let chatFiles = [];
+        if (group_id) {
+            // Find group's chat IDs first
+            const groupDir = path.join(request.user.directories.groups);
+            const groupFiles = fs.readdirSync(groupDir)
+                .filter(file => file.endsWith('.json'));
+            let targetGroup;
+            for (const groupFile of groupFiles) {
+                const groupData = JSON.parse(fs.readFileSync(path.join(groupDir, groupFile), 'utf8'));
+                if (groupData.id === group_id) {
+                    targetGroup = groupData;
+                    break;
+                }
+            }
+            if (!targetGroup?.chats) {
+                return response.send([]);
+            }
+            // Find group chat files for given group ID
+            const groupChatsDir = path.join(request.user.directories.groupChats);
+            chatFiles = targetGroup.chats
+                .map(chatId => {
+                    const filePath = path.join(groupChatsDir, `${chatId}.jsonl`);
+                    if (!fs.existsSync(filePath)) return null;
+                    const stats = fs.statSync(filePath);
+                    return {
+                        file_name: chatId,
+                        file_size: formatBytes(stats.size),
+                        path: filePath,
+                    };
+                })
+                .filter(x => x);
+        } else {
+            // Regular character chat directory
+            const character_name = avatar_url.replace('.png', '');
+            const directoryPath = path.join(request.user.directories.chats, character_name);
+            if (!fs.existsSync(directoryPath)) {
+                return response.send([]);
+            }
+            chatFiles = fs.readdirSync(directoryPath)
+                .filter(file => file.endsWith('.jsonl'))
+                .map(fileName => {
+                    const filePath = path.join(directoryPath, fileName);
+                    const stats = fs.statSync(filePath);
+                    return {
+                        file_name: fileName,
+                        file_size: formatBytes(stats.size),
+                        path: filePath,
+                    };
+                });
+        }
+        const results = [];
+        // Search logic
+        for (const chatFile of chatFiles) {
+            const data = fs.readFileSync(chatFile.path, 'utf8');
+            const messages = data.split('\n')
+                .map(line => { try { return JSON.parse(line); } catch (_) { return null; } })
+                .filter(x => x);
+            if (messages.length === 0) {
+                continue;
+            }
+            const lastMessage = messages[messages.length - 1];
+            const lastMesDate = lastMessage?.send_date || new Date().toISOString();
+            // If no search query, just return metadata
+            if (!query) {
+                results.push({
+                    file_name: chatFile.file_name,
+                    file_size: chatFile.file_size,
+                    message_count: messages.length,
+                    last_mes: lastMesDate,
+                    preview_message: getPreviewMessage(messages),
+                });
+                continue;
+            }
+            // Search through messages
+            const fragments = query.trim().toLowerCase().split(/\s+/).filter(x => x);
+            const hasMatch = messages.some(message => {
+                const text = message?.mes?.toLowerCase();
+                return text && fragments.every(fragment => text.includes(fragment));
+            });
+            if (hasMatch) {
+                results.push({
+                    file_name: chatFile.file_name,
+                    file_size: chatFile.file_size,
+                    message_count: messages.length,
+                    last_mes: lastMesDate,
+                    preview_message: getPreviewMessage(messages),
+                });
+            }
+        }
+        // Sort by last message date descending
+        results.sort((a, b) => new Date(b.last_mes) - new Date(a.last_mes));
+        return response.send(results);
+    } catch (error) {
+        console.error('Chat search error:', error);
+        return response.status(500).json({ error: 'Search failed' });
+    }
+});
 \ No newline at end of file