@sybilion/uilib 1.3.88 → 1.3.90

package/dist/esm/contexts/chat-context.js

@@ -2,84 +2,42 @@ import { jsx } from 'react/jsx-runtime';
 import { createContext, useState, useCallback, useEffect, useContext, useMemo } from 'react';
 import { MessageRole } from '../components/ui/Chat/Chat.types.js';
 import { normalizeUserTextFileAttachments } from '../components/ui/Chat/buildChatSendMessagePayload.js';
-import { stripJsonDashboardFences } from '../lib/dashboard-spec/stripJsonDashboardFences.js';
-import { LS } from '@homecode/ui';
-import { persistChatsToLS, safeLsSet } from './chatPersistence.js';
+import { normalizeJsonDashboardChatText, stripJsonDashboardFences } from '../lib/dashboard-spec/jsonDashboardFence.js';
+import { isEphemeralChatScope } from './chatPersistence.js';
+import { loadChatsFromSessionStorage, loadScopeIndex, persistScopeIndex, linkSessionToScope, loadSession, persistSession, addScopeIdToRegistry, removeSessionFromScope, countSessionReferences, deleteSessionBlob, renameSessionId } from './chatSessionStorage.js';
 
-const CHATS_PREFIX = 'chats-';
-const CHAT_SCOPE_IDS_REGISTRY_KEY = 'chat-scope-ids';
 const ChatContext = createContext(undefined);
 /** Stable composite key; avoids collisions if `scopeId` contains `:`. */
 function outboundPendingKey(scopeId, chatSessionId) {
     return `${scopeId}\0${chatSessionId}`;
 }
-function getCurrentChatIdKey(scopeId) {
-    return `chat-current-id-${scopeId}`;
-}
-function getChatsKey(scopeId) {
-    return `${CHATS_PREFIX}${scopeId}`;
-}
-function scopeIdsForUser(userId, all) {
-    const prefix = `${userId}-`;
-    const out = new Set();
-    for (const id of all) {
-        if (id.startsWith(prefix))
-            out.add(id);
-    }
-    return out;
-}
-function discoverScopeIdsFromLS() {
-    const scopeIds = new Set();
-    const registryRaw = LS.get(CHAT_SCOPE_IDS_REGISTRY_KEY);
-    const registry = Array.isArray(registryRaw) ? registryRaw : [];
-    registry.forEach((id) => {
-        if (typeof id === 'string' && id)
-            scopeIds.add(id);
-    });
-    try {
-        for (let i = 0; i < window.localStorage.length; i++) {
-            const key = window.localStorage.key(i);
-            if (key?.startsWith(CHATS_PREFIX)) {
-                const scopeId = key.slice(CHATS_PREFIX.length);
-                if (scopeId)
-                    scopeIds.add(scopeId);
-            }
+function applySessionUpdate(prev, sessionId, updater) {
+    let updatedChat = null;
+    const next = {};
+    for (const [scopeId, scopeChats] of Object.entries(prev)) {
+        const idx = scopeChats.findIndex(chat => chat.session_id === sessionId);
+        if (idx === -1) {
+            next[scopeId] = scopeChats;
+            continue;
         }
+        const chat = updater(scopeChats[idx]);
+        updatedChat = chat;
+        const scopeNext = [...scopeChats];
+        scopeNext[idx] = chat;
+        next[scopeId] = scopeNext;
     }
-    catch {
-        // ignore
-    }
-    return scopeIds;
-}
-function loadChatsFromLS(userId) {
-    if (typeof window === 'undefined' || userId === null) {
-        return { chats: {}, currentChatId: {} };
-    }
-    const chats = {};
-    const currentChatId = {};
-    const scopeIds = scopeIdsForUser(userId, discoverScopeIdsFromLS());
-    for (const scopeId of scopeIds) {
-        const chatsKey = getChatsKey(scopeId);
-        const storedRaw = LS.get(chatsKey);
-        const stored = Array.isArray(storedRaw) ? storedRaw : undefined;
-        if (stored?.length) {
-            chats[scopeId] = stored;
-            const ck = getCurrentChatIdKey(scopeId);
-            const savedCurrentIdRaw = LS.get(ck);
-            const savedCurrentId = typeof savedCurrentIdRaw === 'string' && savedCurrentIdRaw !== ''
-                ? savedCurrentIdRaw
-                : undefined;
-            currentChatId[scopeId] = savedCurrentId ?? stored[0]?.session_id ?? null;
-        }
-    }
-    return { chats, currentChatId };
+    if (updatedChat)
+        persistSession(updatedChat);
+    return next;
 }
-function addScopeIdToRegistry(scopeId) {
-    const raw = LS.get(CHAT_SCOPE_IDS_REGISTRY_KEY);
-    const registry = Array.isArray(raw) ? [...raw] : [];
-    if (!registry.includes(scopeId)) {
-        safeLsSet(CHAT_SCOPE_IDS_REGISTRY_KEY, [...registry, scopeId]);
+function remapSessionIdInMemory(prev, oldSessionId, newSessionId) {
+    const next = {};
+    for (const [scopeId, scopeChats] of Object.entries(prev)) {
+        next[scopeId] = scopeChats.map(chat => chat.session_id === oldSessionId
+            ? { ...chat, session_id: newSessionId }
+            : chat);
     }
+    return next;
 }
 /** Shallow-clone messages for seeding another session; drops in-progress rows. */
 function cloneMessagesForNewSession(messages) {
@@ -87,6 +45,7 @@ function cloneMessagesForNewSession(messages) {
         .filter(message => !message.inProgress)
         .map(message => ({
         ...message,
+        text: stripJsonDashboardFences(message.text),
         ...(message.meta ? { meta: { ...message.meta } } : {}),
         ...(message.userTextFileAttachments
             ? {
@@ -97,14 +56,14 @@ function cloneMessagesForNewSession(messages) {
 }
 function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessageFn, }) {
     const [chats, setChats] = useState(() => {
-        if (userSwitchKey === null)
+        if (userSwitchKey === null || typeof window === 'undefined')
             return {};
-        return loadChatsFromLS(userSwitchKey).chats;
+        return loadChatsFromSessionStorage(userSwitchKey).chats;
     });
     const [currentChatId, setCurrentChatIdState] = useState(() => {
-        if (userSwitchKey === null)
+        if (userSwitchKey === null || typeof window === 'undefined')
             return {};
-        return loadChatsFromLS(userSwitchKey).currentChatId;
+        return loadChatsFromSessionStorage(userSwitchKey).currentChatId;
     });
     const [outboundPendingByKey, setOutboundPendingByKey] = useState({});
     const [panelBusyCount, setPanelBusyCount] = useState(0);
@@ -140,6 +99,54 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
             return null;
         return v;
     }, [currentChatId]);
+    const setCurrentChatId = useCallback((currScopeId, sessionId) => {
+        if (!sessionId)
+            return;
+        setCurrentChatIdState(prev => ({ ...prev, [currScopeId]: sessionId }));
+        const index = loadScopeIndex(currScopeId);
+        if (index) {
+            persistScopeIndex(currScopeId, {
+                ...index,
+                currentSessionId: sessionId,
+            });
+        }
+    }, []);
+    const linkSessionToScope$1 = useCallback((scopeId, sessionId, options) => {
+        if (userSwitchKey === null)
+            return;
+        linkSessionToScope(scopeId, sessionId, options);
+        setChats(prev => {
+            const sessionFromLs = loadSession(sessionId);
+            let sessionFromMemory = null;
+            for (const scopeChats of Object.values(prev)) {
+                const found = scopeChats.find(chat => chat.session_id === sessionId);
+                if (found &&
+                    (!sessionFromMemory ||
+                        found.messages.length > sessionFromMemory.messages.length)) {
+                    sessionFromMemory = found;
+                }
+            }
+            const session = sessionFromMemory &&
+                (!sessionFromLs ||
+                    sessionFromMemory.messages.length >= sessionFromLs.messages.length)
+                ? sessionFromMemory
+                : sessionFromLs;
+            if (!session)
+                return prev;
+            if (session === sessionFromMemory) {
+                persistSession(sessionFromMemory);
+            }
+            const scopeChats = prev[scopeId] ?? [];
+            const exists = scopeChats.some(chat => chat.session_id === sessionId);
+            const updatedChats = exists
+                ? scopeChats.map(chat => chat.session_id === sessionId ? session : chat)
+                : [session, ...scopeChats];
+            return { ...prev, [scopeId]: updatedChats };
+        });
+        if (options?.makeCurrent !== false) {
+            setCurrentChatIdState(prev => ({ ...prev, [scopeId]: sessionId }));
+        }
+    }, [userSwitchKey]);
     const newChat = useCallback((scopeId, options) => {
         if (userSwitchKey === null)
             return undefined;
@@ -148,63 +155,65 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
         const seededMessages = options?.seedMessages && options.seedMessages.length > 0
             ? cloneMessagesForNewSession(options.seedMessages)
             : [];
-        const newChat = {
+        const created = {
             session_id: sessionId,
             name: '',
             messages: seededMessages,
         };
+        persistSession(created);
+        linkSessionToScope(scopeId, sessionId, { makeCurrent: true });
         setChats(prev => {
-            const currentChats = prev[scopeId] ?? [];
-            const updatedChats = [newChat, ...currentChats];
-            persistChatsToLS(scopeId, updatedChats);
-            return {
-                ...prev,
-                [scopeId]: updatedChats,
-            };
+            const scopeChats = prev[scopeId] ?? [];
+            const isEphemeral = isEphemeralChatScope(scopeId);
+            if (isEphemeral) {
+                for (const old of scopeChats) {
+                    if (old.session_id !== sessionId) {
+                        removeSessionFromScope(scopeId, old.session_id);
+                        if (countSessionReferences(userSwitchKey, old.session_id) === 0) {
+                            deleteSessionBlob(old.session_id);
+                        }
+                    }
+                }
+            }
+            const updatedChats = isEphemeral ? [created] : [created, ...scopeChats];
+            return { ...prev, [scopeId]: updatedChats };
         });
         setCurrentChatIdState(prev => ({ ...prev, [scopeId]: sessionId }));
-        safeLsSet(getCurrentChatIdKey(scopeId), sessionId);
         return sessionId;
     }, [userSwitchKey]);
-    const setCurrentChatId = useCallback((currScopeId, sessionId) => {
-        if (!sessionId)
-            return;
-        setCurrentChatIdState(prev => ({ ...prev, [currScopeId]: sessionId }));
-        safeLsSet(getCurrentChatIdKey(currScopeId), sessionId);
-    }, []);
     const deleteChat = useCallback((scopeId, sessionId) => {
-        const currentKey = getCurrentChatIdKey(scopeId);
+        const scopeChats = chats[scopeId] ?? [];
+        const deletedIndex = scopeChats.findIndex(chat => chat.session_id === sessionId);
+        if (deletedIndex === -1)
+            return;
+        removeSessionFromScope(scopeId, sessionId);
+        if (userSwitchKey != null &&
+            countSessionReferences(userSwitchKey, sessionId) === 0) {
+            deleteSessionBlob(sessionId);
+        }
         setChats(prev => {
-            const scopeChats = prev[scopeId] ?? [];
-            const deletedIndex = scopeChats.findIndex(c => c.session_id === sessionId);
-            if (deletedIndex === -1) {
-                return prev;
-            }
-            const updatedChats = scopeChats.filter(c => c.session_id !== sessionId);
-            persistChatsToLS(scopeId, updatedChats);
-            setCurrentChatIdState(prevCurr => {
-                if (prevCurr[scopeId] !== sessionId) {
-                    return prevCurr;
-                }
-                const nextId = deletedIndex > 0
-                    ? scopeChats[deletedIndex - 1].session_id
-                    : (updatedChats[0]?.session_id ?? null);
-                if (nextId) {
-                    safeLsSet(currentKey, nextId);
-                }
-                else {
-                    LS.remove(currentKey);
-                }
-                return { ...prevCurr, [scopeId]: nextId };
-            });
-            return { ...prev, [scopeId]: updatedChats };
+            const currentScopeChats = prev[scopeId] ?? [];
+            return {
+                ...prev,
+                [scopeId]: currentScopeChats.filter(chat => chat.session_id !== sessionId),
+            };
         });
-    }, []);
+        setCurrentChatIdState(prevCurr => {
+            if (prevCurr[scopeId] !== sessionId)
+                return prevCurr;
+            const index = loadScopeIndex(scopeId);
+            const nextId = index?.currentSessionId ??
+                (deletedIndex > 0 ? scopeChats[deletedIndex - 1].session_id : null);
+            return { ...prevCurr, [scopeId]: nextId };
+        });
+    }, [chats, userSwitchKey]);
     const addMessage = useCallback((scopeId, chatId, role, text, options) => {
         if (userSwitchKey === null)
             return undefined;
         addScopeIdToRegistry(scopeId);
-        const storedText = stripJsonDashboardFences(text);
+        const storedText = role === MessageRole.ASSISTANT
+            ? normalizeJsonDashboardChatText(text)
+            : stripJsonDashboardFences(text);
         const attachments = role === MessageRole.USER
             ? options?.userTextFileAttachments
             : undefined;
@@ -219,73 +228,52 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
             ...(options?.inProgress ? { inProgress: true } : {}),
             ...(options?.meta ? { meta: { ...options.meta } } : {}),
         };
-        setChats(prev => {
-            const scopeChats = prev[scopeId] ?? [];
-            const updatedChats = scopeChats.map(chat => {
-                if (chat.session_id === chatId) {
-                    return { ...chat, messages: [...chat.messages, newMessage] };
-                }
-                return chat;
-            });
-            persistChatsToLS(scopeId, updatedChats);
-            return { ...prev, [scopeId]: updatedChats };
-        });
+        setChats(prev => applySessionUpdate(prev, chatId, chat => ({
+            ...chat,
+            messages: [...chat.messages, newMessage],
+        })));
         return newMessage.id;
     }, [userSwitchKey]);
     const removeMessageById = useCallback((scopeId, chatId, messageId) => {
         if (userSwitchKey === null)
             return;
-        setChats(prev => {
-            const scopeChats = prev[scopeId] ?? [];
-            const updatedChats = scopeChats.map(chat => {
-                if (chat.session_id !== chatId)
-                    return chat;
-                return {
-                    ...chat,
-                    messages: chat.messages.filter(m => m.id !== messageId),
-                };
-            });
-            persistChatsToLS(scopeId, updatedChats);
-            return { ...prev, [scopeId]: updatedChats };
-        });
+        setChats(prev => applySessionUpdate(prev, chatId, chat => ({
+            ...chat,
+            messages: chat.messages.filter(message => message.id !== messageId),
+        })));
     }, [userSwitchKey]);
     const updateMessageById = useCallback((scopeId, chatId, messageId, patch) => {
         if (userSwitchKey === null)
             return;
-        setChats(prev => {
-            const scopeChats = prev[scopeId] ?? [];
-            const updatedChats = scopeChats.map(chat => {
-                if (chat.session_id !== chatId)
-                    return chat;
-                return {
-                    ...chat,
-                    messages: chat.messages.map(message => {
-                        if (message.id !== messageId)
-                            return message;
-                        const next = { ...message };
-                        if (patch.role != null) {
-                            next.role = patch.role;
-                        }
-                        if (patch.text != null) {
-                            next.text = stripJsonDashboardFences(patch.text);
-                        }
-                        if (patch.inProgress === true) {
-                            next.inProgress = true;
-                        }
-                        else if (patch.inProgress === false ||
-                            (patch.role != null && patch.role !== MessageRole.SYSTEM)) {
-                            delete next.inProgress;
-                        }
-                        if (patch.meta != null) {
-                            next.meta = { ...next.meta, ...patch.meta };
-                        }
-                        return next;
-                    }),
-                };
-            });
-            persistChatsToLS(scopeId, updatedChats);
-            return { ...prev, [scopeId]: updatedChats };
-        });
+        setChats(prev => applySessionUpdate(prev, chatId, chat => ({
+            ...chat,
+            messages: chat.messages.map(message => {
+                if (message.id !== messageId)
+                    return message;
+                const next = { ...message };
+                if (patch.role != null) {
+                    next.role = patch.role;
+                }
+                if (patch.text != null) {
+                    const targetRole = patch.role ?? message.role;
+                    next.text =
+                        targetRole === MessageRole.ASSISTANT
+                            ? normalizeJsonDashboardChatText(patch.text)
+                            : stripJsonDashboardFences(patch.text);
+                }
+                if (patch.inProgress === true) {
+                    next.inProgress = true;
+                }
+                else if (patch.inProgress === false ||
+                    (patch.role != null && patch.role !== MessageRole.SYSTEM)) {
+                    delete next.inProgress;
+                }
+                if (patch.meta != null) {
+                    next.meta = { ...next.meta, ...patch.meta };
+                }
+                return next;
+            }),
+        })));
     }, [userSwitchKey]);
     const setChatMessages = useCallback((scopeId, chatId, messages) => {
         if (userSwitchKey === null)
@@ -293,35 +281,23 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
         addScopeIdToRegistry(scopeId);
         const cloned = messages.map(message => ({
             ...message,
+            text: message.role === MessageRole.ASSISTANT
+                ? message.text
+                : stripJsonDashboardFences(message.text),
             ...(message.meta ? { meta: { ...message.meta } } : {}),
         }));
-        setChats(prev => {
-            const scopeChats = prev[scopeId] ?? [];
-            const updatedChats = scopeChats.map(chat => {
-                if (chat.session_id !== chatId)
-                    return chat;
-                return { ...chat, messages: cloned };
-            });
-            persistChatsToLS(scopeId, updatedChats);
-            return { ...prev, [scopeId]: updatedChats };
-        });
+        setChats(prev => applySessionUpdate(prev, chatId, chat => ({
+            ...chat,
+            messages: cloned,
+        })));
     }, [userSwitchKey]);
     const updateChatMeta = useCallback((scopeId, chatId, patch) => {
         if (userSwitchKey === null)
             return;
-        setChats(prev => {
-            const scopeChats = prev[scopeId] ?? [];
-            const updatedChats = scopeChats.map(chat => {
-                if (chat.session_id !== chatId)
-                    return chat;
-                return {
-                    ...chat,
-                    meta: { ...chat.meta, ...patch },
-                };
-            });
-            persistChatsToLS(scopeId, updatedChats);
-            return { ...prev, [scopeId]: updatedChats };
-        });
+        setChats(prev => applySessionUpdate(prev, chatId, chat => ({
+            ...chat,
+            meta: { ...chat.meta, ...patch },
+        })));
     }, [userSwitchKey]);
     const sendMessage = useCallback(async (scopeId, message, chatId) => {
         const targetChatId = chatId ?? getCurrentChatId(scopeId);
@@ -350,15 +326,11 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
                 data.session_id && data.session_id !== pendingChatSessionId
                     ? data.session_id
                     : pendingChatSessionId;
-            if (data.session_id && data.session_id !== pendingChatSessionId) {
-                setChats(prev => {
-                    const scopeChats = prev[scopeId] ?? [];
-                    const updatedChats = scopeChats.map(chat => chat.session_id === pendingChatSessionId
-                        ? { ...chat, session_id: data.session_id }
-                        : chat);
-                    persistChatsToLS(scopeId, updatedChats);
-                    return { ...prev, [scopeId]: updatedChats };
-                });
+            if (data.session_id &&
+                data.session_id !== pendingChatSessionId &&
+                userSwitchKey != null) {
+                renameSessionId(userSwitchKey, pendingChatSessionId, data.session_id);
+                setChats(prev => remapSessionIdInMemory(prev, pendingChatSessionId, data.session_id));
                 setCurrentChatId(scopeId, data.session_id);
             }
             if (progressMessageId) {
@@ -389,6 +361,7 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
         getCurrentChatId,
         sendChatMessageFn,
         setCurrentChatId,
+        userSwitchKey,
     ]);
     useEffect(() => {
         if (userSwitchKey === null) {
@@ -398,7 +371,7 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
             setPanelBusyCount(0);
             return;
         }
-        const loaded = loadChatsFromLS(userSwitchKey);
+        const loaded = loadChatsFromSessionStorage(userSwitchKey);
         const updatedCurrentChatId = { ...loaded.currentChatId };
         for (const [scopeId, scopeChats] of Object.entries(loaded.chats)) {
             if (scopeChats.length > 0 &&
@@ -412,6 +385,7 @@ function ChatProvider({ children, userSwitchKey, sendChatMessage: sendChatMessag
     }, [userSwitchKey]);
     return (jsx(ChatContext.Provider, { value: {
             newChat,
+            linkSessionToScope: linkSessionToScope$1,
             setCurrentChatId,
             addMessage,
             removeMessageById,
@@ -478,7 +452,7 @@ function useSyncChatPanelBusy(isLoading) {
     }, [isLoading, acquirePanelBusy, releasePanelBusy]);
 }
 function useChatsForScopeId(scopeId) {
-    const { getChatsForScopeId, getCurrentChatId, setCurrentChatId, newChat, addMessage, removeMessageById, updateMessageById, updateChatMeta, setChatMessages, sendMessage, deleteChat, } = useChats();
+    const { getChatsForScopeId, getCurrentChatId, setCurrentChatId, newChat, linkSessionToScope, addMessage, removeMessageById, updateMessageById, updateChatMeta, setChatMessages, sendMessage, deleteChat, } = useChats();
     const chats = getChatsForScopeId(scopeId);
     const currentChatId = getCurrentChatId(scopeId);
     const currentChat = useChat(scopeId, currentChatId ?? undefined);
@@ -489,6 +463,7 @@ function useChatsForScopeId(scopeId) {
         currentChatId,
         isOutboundPending,
         setCurrentChatId: (targetId) => setCurrentChatId(scopeId, targetId),
+        linkSessionToScope: (sessionId, options) => linkSessionToScope(scopeId, sessionId, options),
         newChat: (options) => newChat(scopeId, options),
         addMessage: (chatId, role, text, options) => addMessage(scopeId, chatId, role, text, options),
         removeMessageById: (chatId, messageId) => removeMessageById(scopeId, chatId, messageId),

package/dist/esm/contexts/chatPersistence.js

@@ -1,4 +1,5 @@
-import { stripJsonDashboardFences } from '../lib/dashboard-spec/stripJsonDashboardFences.js';
+import { MessageRole } from '../components/ui/Chat/Chat.types.js';
+import { stripJsonDashboardFences } from '../lib/dashboard-spec/jsonDashboardFence.js';
 import { LS } from '@homecode/ui';
 
 /** Ephemeral scopes (e.g. /reports/new draft) — keep only the latest session in LS. */
@@ -21,7 +22,9 @@ function stripAttachmentForPersistence(attachment) {
     };
 }
 function stripMessageForPersistence(message) {
-    const text = stripJsonDashboardFences(message.text);
+    const text = message.role === MessageRole.ASSISTANT
+        ? message.text
+        : stripJsonDashboardFences(message.text);
     const next = { ...message, text };
     if (message.inProgress) {
         delete next.inProgress;
@@ -39,21 +42,6 @@ function stripChatsForPersistence(chats) {
             .map(stripMessageForPersistence),
     }));
 }
-function chatsForScopePersistence(scopeId, chats) {
-    const scopeChats = isEphemeralChatScope(scopeId) ? chats.slice(0, 1) : chats;
-    return stripChatsForPersistence(scopeChats);
-}
-function persistChatsToLS(scopeId, chats) {
-    const chatsKey = `chats-${scopeId}`;
-    const payload = chatsForScopePersistence(scopeId, chats);
-    try {
-        LS.set(chatsKey, payload);
-    }
-    catch (error) {
-        if (!isQuotaExceededError(error))
-            throw error;
-    }
-}
 function safeLsSet(key, value) {
     try {
         LS.set(key, value);
@@ -64,4 +52,4 @@ function safeLsSet(key, value) {
     }
 }
 
-export { persistChatsToLS, safeLsSet, stripChatsForPersistence, stripMessageForPersistence };
+export { isEphemeralChatScope, safeLsSet, stripChatsForPersistence, stripMessageForPersistence };