Files
llama.cpp/tools/ui/tests/client/groups-db.svelte.test.ts
T
Aleksander GrygierandPascal 281e7dad7c ui: gather chats into named groups in the sidebar (#32012)
* ui: let a menu action open a submenu

Group and project pickers open as flyouts from a chat's menus. Master's menu
list has no submenus, so bring them back next to its tooltips, with a close
callback for picks made inside them.

Assisted-by: Claude (Opus 5.5 Medium)

* ui : store groups and let conversations join them

Groups live in their own IndexedDB table (schema version 2) with a name.
groupsStore creates, renames and deletes them; deleting a group keeps its
chats, out of any group. A conversation records the group it is sorted
into, and a group picked before the first message is kept pending and
applied when the conversation is created.

Assisted-by: Claude (Opus 5.5 Medium)

* ui : show each group as a sidebar section

Every group is a sidebar section next to Pinned and Recent, folding,
showing its first six chats and dragged into place like them. A chat
dropped on a group joins it and leaves Pinned; dropped on Recent, it
leaves its group. Recent is called Ungrouped once a group exists, and its
menus create a group in a small naming dialog; so does a right-click
anywhere in the list that no row or heading takes, down to the empty space
under the last section. A group's heading starts a new chat in it, and its
menus rename or delete it; deleting keeps its chats, back in Ungrouped.

Assisted-by: Claude (Opus 5.5 Medium)

* ui : move chats into groups from their menus

A chat's menus, in the sidebar and on right-click, move it into a group
or take it out of its group. Desktop menus show a searchable group flyout
whose New group entry names a group in the group dialog and moves the chat
into it; a phone gets a picker dialog instead, which creates a group from
what is typed.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: open the group picker from a phone's hold menu

The hold menu is anchored to the row, so it showed the desktop flyout,
which ran off the left edge of the screen and whose New group closed
without naming one. On a phone, Move to group now opens the picker
dialog, as intended.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: open a new chat in a tab of its own

With conversation tabs on, New chat from the sidebar, a group's heading
or the shortcut replaced the open chat's tab. It now adds a tab, as the
tab bar's "+" does, and the open chat keeps its own.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: list a phone's groups under the picker's search

On a phone the picker fills the screen, and its grid spread the rows
over the height, so the list sat in the middle. It is now a column: the
list starts under the search and scrolls in the rest of the screen.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: fix gaps in chat groups found in review

- A phone shows a group heading's New chat and menu, and the Ungrouped
  heading's menu, which were reachable only by hover or right-click.
- A pinned chat moved into a group from its menu leaves Pinned, as a
  drag onto the group already did, so the move shows.
- Only the sidebar's New chat, a group's New chat and the new-chat
  shortcut open a new tab; stepping past the last chat, search and the
  models drawer show the new-chat screen in the current tab again.
- An export carries each chat's group, and an import sorts the chat
  into the group of that id or name, or creates it; a group the file
  does not carry is dropped.
- The group picked with a group's New chat survives leaving the
  new-chat tab and coming back.
- A phone's menus skip any submenu in the shared menu list, not only
  the group one.
- Deleting a group forgets its section's place and fold.
- Groups load newest first by creation, so a rename no longer moves one
  after a reload.
- groupsStore looks groups up in a map and answers which live group a
  chat is in, for the three places that checked it by hand.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: keep a forked chat in its source chat's group

A fork copied the working directory but not the group, so it landed in
Ungrouped.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: move a chat with its whole fork family between groups

Moving a chat into a group, or out of one, takes its parents and its
children along, so a fork tree never splits across sidebar sections. A
pinned member that joins a group leaves Pinned with the rest. Group
sections render the tree with its depth, as Ungrouped does.

* ui: show the group name prompt as a small centered card on phones

The new and rename group prompt opened full screen on a phone, like a
large dialog. It is now built on the alert dialog, as the chat rename
prompt is, so a phone shows it as a card in the middle of the screen.
Its Cancel is a plain button, so Enter in the name field saves.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: space a phone's group sections like Ungrouped

On a phone a group or Pinned section put its first chat right under the
heading, where Ungrouped leaves a row gap. They now leave the same gap,
and the sections sit a little further apart than the rows inside them.

Assisted-by: Claude (Opus 5.5 Medium)

---------

Co-authored-by: Pascal <admin@serveurperso.com>
2026-11-10 15:44:46 +01:00

99 lines
3.7 KiB
TypeScript

import { DatabaseService } from '$lib/services/database.service';
import type { Group } from '$lib/types';
import { afterEach, describe, expect, it } from 'vitest';
function makeGroup(id: string): Group {
return { createdAt: 0, id, name: `Group ${id}`, updatedAt: 0 };
}
afterEach(async () => {
const groups = await DatabaseService.getAllGroups();
await Promise.all(groups.map((group) => DatabaseService.deleteGroup(group.id)));
const conversations = await DatabaseService.getAllConversations();
await Promise.all(
conversations.map((conversation) => DatabaseService.deleteConversation(conversation.id))
);
});
/**
* Groups live in their own table; deleting one must leave its chats in place,
* out of any group.
*/
describe('DatabaseService groups', () => {
it('round-trips a group', async () => {
await DatabaseService.createGroup(makeGroup('a'));
expect(await DatabaseService.getAllGroups()).toEqual([makeGroup('a')]);
});
it('applies partial updates without dropping other fields', async () => {
await DatabaseService.createGroup(makeGroup('a'));
await DatabaseService.updateGroup('a', { name: 'Renamed', updatedAt: 5 });
expect(await DatabaseService.getAllGroups()).toEqual([
{ ...makeGroup('a'), name: 'Renamed', updatedAt: 5 }
]);
});
it('returns groups newest first by creation, whatever their updates', async () => {
await DatabaseService.createGroup({ ...makeGroup('a'), createdAt: 1, updatedAt: 9 });
await DatabaseService.createGroup({ ...makeGroup('b'), createdAt: 2, updatedAt: 3 });
expect((await DatabaseService.getAllGroups()).map((group) => group.id)).toEqual(['b', 'a']);
});
it('takes the chats out of a deleted group and keeps them', async () => {
await DatabaseService.createGroup(makeGroup('a'));
const inGroup = await DatabaseService.createConversation('in', { groupId: 'a' });
const elsewhere = await DatabaseService.createConversation('out', { groupId: 'b' });
await DatabaseService.deleteGroup('a');
expect(await DatabaseService.getAllGroups()).toEqual([]);
expect((await DatabaseService.getConversation(inGroup.id))?.groupId).toBeUndefined();
expect((await DatabaseService.getConversation(elsewhere.id))?.groupId).toBe('b');
});
it("sorts imported chats into the file's group, by id, then by name, else a new one", async () => {
await DatabaseService.createGroup(makeGroup('a'));
await DatabaseService.createGroup({ ...makeGroup('b'), name: 'Research' });
const chat = (id: string, groupId?: string) => ({
conv: { currNode: '', groupId, id, lastModified: 0, name: id },
messages: []
});
await DatabaseService.importConversations([
{ ...chat('same-id', 'a'), group: { id: 'a', name: 'Other name' } },
{ ...chat('same-name', 'x'), group: { id: 'x', name: 'Research' } },
{ ...chat('new-group', 'y'), group: { id: 'y', name: 'Travel' } },
chat('dangling', 'gone')
]);
const groupOf = async (id: string) => (await DatabaseService.getConversation(id))?.groupId;
expect(await groupOf('same-id')).toBe('a');
expect(await groupOf('same-name')).toBe('b');
expect(await groupOf('new-group')).toBe('y');
expect(await groupOf('dangling')).toBeUndefined();
expect((await DatabaseService.getAllGroups()).map((group) => group.name)).toContain('Travel');
});
it('keeps a forked chat in the group of the chat it was forked from', async () => {
await DatabaseService.createGroup(makeGroup('a'));
const source = await DatabaseService.createConversation('source', { groupId: 'a' });
const rootId = await DatabaseService.createRootMessage(source.id);
const fork = await DatabaseService.forkConversation(source.id, rootId, {
includeAttachments: false,
name: 'fork'
});
expect(fork.groupId).toBe('a');
expect((await DatabaseService.getConversation(fork.id))?.groupId).toBe('a');
});
});