zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/sidebar/rows.ts

@@ -1,427 +0,0 @@
-/**
- * The sidebar's rows: zidane-ui's session-list model (sort, date / state /
- * project grouping, collapse, "show more") over the app's sessions, plus the
- * app's own layer on top: the Per host view's one section per host, and the
- * sections the list renders (`nestSidebarRows`).
- */
-import { groupRows, type SessionGroupBy as QueryGroupBy, type SessionQueryRow } from 'zidane/chat/pure';
-
-import type { ExtensionItem } from '../../../extensions/headless/wire';
-import type { HostView } from '../hosts';
-import { DEFAULT_CHAT_LABELS } from '../labels';
-import {
-  buildSessionRows,
-  type SessionGroupBy as ListGroupBy,
-  type SessionListOptions,
-  type SessionListRow,
-} from '../session-list';
-import type { SidebarItemEntry } from './query';
-import type { SidebarGroupBy, SidebarListSession, SidebarSortBy } from './types';
-
-/**
- * The project a session is listed under: its repository's root, else its folder (`''`: none).
- *
- * @param session - Its folder and project root.
- */
-export function projectPathOf(session: Pick<SidebarListSession, 'projectRoot' | 'cwd'>): string {
-  return session.projectRoot || session.cwd;
-}
-
-/** One row of the sidebar: a session-list row (a header may name its host) or a host's section header. */
-export type SidebarListRow<S extends SidebarListSession = SidebarListSession> =
-  | Extract<SessionListRow<S>, { kind: 'showMore' }>
-  /** A session; `itemId`: listed under that extension item (one of its child sessions). */
-  | (Extract<SessionListRow<S>, { kind: 'session' }> & { itemId?: string })
-  /**
-   * An extension item listed among the sessions; its child sessions follow it (`itemId`) unless
-   * it is collapsed.
-   */
-  | { kind: 'item'; id: string; entry: ExtensionItem<'sidebar-row'>; collapsed: boolean; childCount: number }
-  /**
-   * A group header; a server's folder names its server (`hostId`), shown as a chip. A project
-   * whose repository also has sessions on other machines names it (`repoKey`): those sessions
-   * are listed under it.
-   */
-  | (Extract<SessionListRow<S>, { kind: 'header' }> & { hostId?: string; repoKey?: string })
-  /**
-   * A host's section in the Per host view (This computer, then each saved
-   * server): its name and connection status. Collapsing it hides every
-   * group under it.
-   */
-  | { kind: 'host'; id: string; host: HostView; collapsed: boolean; count: number };
-
-/**
- * Views whose groups are folders: Per directory, and each host's section in Per host.
- *
- * @param groupBy - The view.
- */
-export function groupsByFolder(groupBy: SidebarGroupBy): boolean {
-  return groupBy === 'project' || groupBy === 'host';
-}
-
-const EMPTY_SET: ReadonlySet<string> = new Set();
-
-/** The directory-less bucket's label ("pure chat" sessions, no project). */
-export const CHATS_BUCKET = 'Chats';
-
-/** The list options {@link buildSidebarRows} passes through. */
-export type BuildSidebarRowsOptions = Pick<
-  SessionListOptions<SidebarListSession>,
-  'collapsedGroups' | 'showMoreExpanded' | 'idPrefix' | 'pinnedProjects' | 'compare'
->;
-
-/**
- * Orchestration on: the main session is pulled out (pinned above the list).
- * Off: the main is not a chat; it is hidden, not regrouped.
- *
- * @param sessions - The listed sessions.
- * @param orchestrationEnabled - Orchestration is on.
- */
-export function partitionMainSession<S extends SidebarListSession>(
-  sessions: readonly S[],
-  orchestrationEnabled: boolean,
-): { main: S | null; rest: S[] } {
-  if (!orchestrationEnabled) return { main: null, rest: sessions.filter((s) => s.isMain !== true) };
-  const main = sessions.find((s) => s.isMain === true) ?? null;
-  return main ? { main, rest: sessions.filter((s) => s.id !== main.id) } : { main: null, rest: sessions.slice() };
-}
-
-/**
- * The sidebar's rows over the kit's session-list model: favorites, git repositories and the project of each session.
- *
- * @param sessions - The sessions to list.
- * @param groupBy - The session-list grouping.
- * @param sortBy - The order inside a group.
- * @param options - Collapsed groups, expanded "show more", id prefix, pinned projects.
- * @param project - The project a session groups under (defaults to {@link projectPathOf}).
- */
-export function buildSidebarRows<S extends SidebarListSession>(
-  sessions: S[],
-  groupBy: ListGroupBy,
-  sortBy: SidebarSortBy,
-  options: BuildSidebarRowsOptions = {},
-  project: (session: S) => string = projectPathOf,
-): SidebarListRow<S>[] {
-  return buildSessionRows(sessions, {
-    ...options,
-    groupBy,
-    sortBy,
-    project,
-    isGitRepo: (s) => s.isGitRepo === true,
-    isFavorite: (s) => s.favorite === true,
-  });
-}
-
-/*
- * Outside Per host every host shares one list, so a server's folder is keyed
- * with its host: the same path on two hosts is two groups. The list model
- * labels a folder by its last segment, so the host goes at the end
- * (`api<SEP>box`): server folders never take a local folder's name, and the
- * suffix is swapped for the server's name once the rows are built.
- */
-const HOST_SEP = '\u0000';
-
-function hostFolderKey(session: SidebarListSession): string {
-  const path = projectPathOf(session);
-  if (!session.hostId || !path) return path;
-  return `${path.replace(/\/+$/, '') || '/'}${HOST_SEP}${session.hostId}`;
-}
-
-/**
- * The group each repository's sessions share across machines, by `repoKey`. A
- * repository with one local folder groups under that folder: its sessions on
- * servers join it. A repository only on servers groups under its first
- * server folder, in key order. A repository with several local folders (two
- * clones) is left out: each folder keeps its own group, and so does each
- * server folder.
- *
- * @param sessions - The listed sessions.
- */
-export function repoGroups(sessions: readonly SidebarListSession[]): Map<string, string> {
-  const local = new Map<string, Set<string>>();
-  const remote = new Map<string, string>();
-  for (const session of sessions) {
-    if (!session.repoKey || !projectPathOf(session)) continue;
-    if (session.hostId) {
-      const key = hostFolderKey(session);
-      const first = remote.get(session.repoKey);
-      if (first === undefined || key < first) remote.set(session.repoKey, key);
-    } else {
-      const folders = local.get(session.repoKey) ?? new Set<string>();
-      folders.add(projectPathOf(session).replace(/\/+$/, '') || '/');
-      local.set(session.repoKey, folders);
-    }
-  }
-  const groups = new Map<string, string>();
-  for (const [repoKey, first] of remote) {
-    const folders = local.get(repoKey);
-    if (!folders) groups.set(repoKey, first);
-    else if (folders.size === 1) groups.set(repoKey, [...folders][0]!);
-  }
-  return groups;
-}
-
-/**
- * Whether `session` is listed under a project header: a local session in its
- * folder, or, for a header that names a `repoKey`, a server session of that
- * repository.
- *
- * @param session - The session.
- * @param project - The header's folder (`path`), its server (`hostId`) and its repository (`repoKey`).
- */
-export function isProjectMember(
-  session: SidebarListSession,
-  project: { path: string; hostId?: string; repoKey?: string },
-): boolean {
-  if (project.repoKey && session.hostId && session.repoKey === project.repoKey) return true;
-  return (session.hostId ?? undefined) === project.hostId && projectPathOf(session) === project.path;
-}
-
-/** A server folder's header: the folder, its server as `hostId` (a chip), without the local folder affordances. */
-function serverFolderHeader<S extends SidebarListSession>(row: SidebarListRow<S>): SidebarListRow<S> {
-  if (row.kind !== 'header' || !row.fullPath?.includes(HOST_SEP)) return row;
-  const { fullPath, isGitRepo: _isGitRepo, ...rest } = row;
-  const hostId = fullPath.slice(fullPath.indexOf(HOST_SEP) + 1);
-  const folder = row.label.replace(`${HOST_SEP}${hostId}`, '') || '/';
-  return { ...rest, label: folder, hostId };
-}
-
-/** A header whose group holds a repository's sessions from several machines names the repository. */
-function withRepoKey<S extends SidebarListSession>(
-  row: SidebarListRow<S>,
-  repoByGroup: ReadonlyMap<string, string>,
-): SidebarListRow<S> {
-  if (row.kind !== 'header' || row.fullPath === undefined) return row;
-  const repoKey = repoByGroup.get(row.fullPath);
-  return repoKey ? { ...row, repoKey } : row;
-}
-
-function withoutLocalPath<S extends SidebarListSession>(row: SidebarListRow<S>): SidebarListRow<S> {
-  if (row.kind !== 'header' || row.fullPath === undefined) {
-    return row;
-  }
-
-  const { fullPath: _fullPath, isGitRepo: _isGitRepo, ...rest } = row;
-  return rest;
-}
-
-/**
- * The sidebar's rows over every host. Per host: This computer's section
- * first, then each saved server's, each host's sessions grouped per folder
- * under its header. Any other view lists every host in one list, a server's
- * folder headers naming the server, and a repository's sessions on every
- * machine under one header ({@link repoGroups}). Sessions of a server no
- * longer saved are not listed.
- *
- * @param sessions - The sessions to list.
- * @param hosts - This machine and each saved server, in order.
- * @param groupBy - The view.
- * @param sortBy - The order inside a group.
- * @param options - Collapsed groups, expanded "show more", pinned projects.
- */
-export function buildHostSidebarRows<S extends SidebarListSession>(
-  sessions: S[],
-  hosts: readonly HostView[],
-  groupBy: Exclude<SidebarGroupBy, 'agent'>,
-  sortBy: SidebarSortBy,
-  options: BuildSidebarRowsOptions = {},
-): SidebarListRow<S>[] {
-  const servers = new Map(hosts.filter((host) => host.kind === 'server').map((host) => [host.id, host.name]));
-
-  if (groupBy !== 'host') {
-    const listed = sessions.filter((s) => !s.hostId || servers.has(s.hostId));
-    const groups = servers.size > 0 ? repoGroups(listed) : new Map<string, string>();
-    const repoByGroup = new Map([...groups].map(([repoKey, group]) => [group, repoKey]));
-    const rows = buildSidebarRows(listed, groupBy, sortBy, options, (s) =>
-      s.repoKey && groups.has(s.repoKey) ? groups.get(s.repoKey)! : hostFolderKey(s),
-    );
-    return servers.size > 0 ? rows.map((row) => serverFolderHeader(withRepoKey(row, repoByGroup))) : rows;
-  }
-
-  const local = sessions.filter((s) => !s.hostId);
-  const collapsedGroups = options.collapsedGroups ?? EMPTY_SET;
-  const out: SidebarListRow<S>[] = [];
-
-  for (const host of hosts) {
-    const own = host.kind === 'local' ? local : sessions.filter((s) => s.hostId === host.id);
-    const id = `host-${host.id}`;
-    const collapsed = collapsedGroups.has(id);
-    out.push({ kind: 'host', id, host, collapsed, count: own.length });
-
-    if (!collapsed) {
-      // Pins are this computer's folders: a server's list ignores them.
-      const { pinnedProjects: _pinnedProjects, ...rest } = options;
-      const rows = buildSidebarRows(own, 'project', sortBy, {
-        ...(host.kind === 'local' ? options : rest),
-        idPrefix: `${host.id}:`,
-      });
-      // A server's folders are not on this machine: no icon keying, no "new session here".
-      out.push(...(host.kind === 'server' ? rows.map(withoutLocalPath) : rows));
-    }
-  }
-
-  return out;
-}
-
-/**
- * An item's row and its child sessions' rows (none while it is collapsed).
- *
- * @param item - The item and its child sessions.
- * @param collapsedGroups - Collapsed row ids (an item collapses under its row id).
- */
-export function itemRows<S extends SidebarListSession>(
-  item: SidebarItemEntry<S>,
-  collapsedGroups: ReadonlySet<string> = EMPTY_SET,
-): SidebarListRow<S>[] {
-  const id = `i-${item.entry.item.id}`;
-  const collapsed = collapsedGroups.has(id);
-  const out: SidebarListRow<S>[] = [
-    { kind: 'item', id, entry: item.entry, collapsed, childCount: item.children.length },
-  ];
-  if (!collapsed) {
-    for (const session of item.children) out.push({ kind: 'session', id: session.id, session, itemId: id });
-  }
-  return out;
-}
-
-/** Options of {@link buildQuerySidebarRows}. */
-export interface BuildQuerySidebarRowsOptions<S extends SidebarListSession> {
-  /** Collapsed header and item ids. */
-  collapsedGroups?: ReadonlySet<string>;
-  /** Labels by group key, under the grouping's own (agent names for the agent grouping). */
-  labels?: Readonly<Record<string, string>>;
-  /** The label of the group of sessions without a value. */
-  missingLabel?: string;
-  /** The favorites section's label. Default: the chat labels'. */
-  favoritesLabel?: string;
-  /** Favorited sessions lead the list under their own header, as in every grouping. */
-  isFavorite?: (session: S) => boolean;
-  /** Extension items, each listed first in the group its `group` names (no `group`: the group without a value). */
-  items?: readonly SidebarItemEntry<S>[];
-}
-
-const MISSING = '\u0000none';
-
-/**
- * The sidebar's rows under a query grouping (a space's, an extension's, the agents'): favorites
- * first, then one group per value in the grouping's order, the items of each group leading it. A
- * session whose value is a list is in each of its groups. The sessions come sorted.
- *
- * @param sessions - The sessions to list, in order.
- * @param groupBy - The grouping.
- * @param options - Collapse, labels, favorites and items.
- */
-export function buildQuerySidebarRows<S extends SidebarListSession>(
-  sessions: readonly S[],
-  groupBy: QueryGroupBy,
-  options: BuildQuerySidebarRowsOptions<S> = {},
-): SidebarListRow<S>[] {
-  const collapsedGroups = options.collapsedGroups ?? EMPTY_SET;
-  const out: SidebarListRow<S>[] = [];
-  const favorites = options.isFavorite ? sessions.filter(options.isFavorite) : [];
-  const rest = favorites.length > 0 ? sessions.filter((s) => !options.isFavorite!(s)) : sessions;
-  if (favorites.length > 0) {
-    const id = 'h-Favorites';
-    const collapsed = collapsedGroups.has(id);
-    out.push({
-      kind: 'header',
-      id,
-      label: options.favoritesLabel ?? DEFAULT_CHAT_LABELS.favorites,
-      collapsed,
-      favorites: true,
-    });
-    if (!collapsed)
-      for (const session of favorites) out.push({ kind: 'session', id: session.id, session, favorites: true });
-  }
-
-  const groups = groupRows(rest as readonly (S & SessionQueryRow)[], groupBy, {
-    ...(options.labels ? { labels: options.labels } : {}),
-    ...(options.missingLabel ? { missingLabel: options.missingLabel } : {}),
-  }).map((g) => ({ key: g.key, label: g.label, rows: g.rows as readonly S[] }));
-  const itemsByKey = new Map<string, SidebarItemEntry<S>[]>();
-  for (const item of options.items ?? []) {
-    const key = item.entry.item.group ?? MISSING;
-    itemsByKey.set(key, [...(itemsByKey.get(key) ?? []), item]);
-  }
-  // An item's group with no session yet still shows, before the group without a value.
-  for (const key of itemsByKey.keys()) {
-    if (groups.some((g) => (g.key ?? MISSING) === key)) continue;
-    const label =
-      key === MISSING ? (options.missingLabel ?? '') : (groupBy.labels?.[key] ?? options.labels?.[key] ?? key);
-    const at = groups.findIndex((g) => g.key === null);
-    const group = { key: key === MISSING ? null : key, label, rows: [] as readonly S[] };
-    if (key === MISSING || at === -1) groups.push(group);
-    else groups.splice(at, 0, group);
-  }
-
-  for (const group of groups) {
-    const key = group.key ?? MISSING;
-    const id = `h-q:${key}`;
-    const collapsed = collapsedGroups.has(id);
-    out.push({ kind: 'header', id, label: group.label, collapsed });
-    if (collapsed) continue;
-    for (const item of itemsByKey.get(key) ?? []) out.push(...itemRows(item, collapsedGroups));
-    for (const session of group.rows) out.push({ kind: 'session', id: session.id, session });
-  }
-  return out;
-}
-
-type SectionHeader<S extends SidebarListSession> = Extract<SidebarListRow<S>, { kind: 'header' } | { kind: 'host' }>;
-
-/**
- * What the sidebar list renders: a session or "show more" row, or a section,
- * a header and the rows under it, drawn as its own `<ul>` so the header
- * sticks while they scroll by and the next section pushes it out.
- */
-export type SidebarNode<S extends SidebarListSession = SidebarListSession> =
-  | Extract<SidebarListRow<S>, { kind: 'session' } | { kind: 'showMore' }>
-  | { kind: 'section'; id: string; header: SectionHeader<S>; children: SidebarNode<S>[] }
-  /** An extension item and its child sessions' rows. */
-  | { kind: 'item'; id: string; row: Extract<SidebarListRow<S>, { kind: 'item' }>; children: SidebarNode<S>[] };
-
-/**
- * The flat rows as nested sections: a host's section holds its groups, a
- * group's holds its rows. Rows before any header (a flat view) stay at the
- * top level, and so do a flat view's rows after its Favorites.
- *
- * @param rows - The flat rows.
- */
-export function nestSidebarRows<S extends SidebarListSession>(rows: readonly SidebarListRow<S>[]): SidebarNode<S>[] {
-  const top: SidebarNode<S>[] = [];
-  let host: Extract<SidebarNode<S>, { kind: 'section' }> | null = null;
-  let group: Extract<SidebarNode<S>, { kind: 'section' }> | null = null;
-  let item: Extract<SidebarNode<S>, { kind: 'item' }> | null = null;
-
-  for (const row of rows) {
-    if (row.kind === 'session' && row.itemId !== undefined && item?.id === row.itemId) {
-      item.children.push(row);
-      continue;
-    }
-    if (row.kind === 'item') {
-      item = { kind: 'item', id: row.id, row, children: [] };
-      const parent = group ?? host;
-      if (parent) parent.children.push(item);
-      else top.push(item);
-      continue;
-    }
-    if (row.kind === 'host') {
-      host = { kind: 'section', id: row.id, header: row, children: [] };
-      group = null;
-      top.push(host);
-      continue;
-    }
-    if (row.kind === 'header') {
-      group = { kind: 'section', id: row.id, header: row, children: [] };
-      (host?.children ?? top).push(group);
-      continue;
-    }
-    if (group?.header.kind === 'header' && group.header.favorites && row.kind === 'session' && !row.favorites) {
-      group = null;
-    }
-    const parent = group ?? host;
-    if (parent) parent.children.push(row);
-    else top.push(row);
-  }
-
-  return top;
-}

package/src/chat/headless/sidebar/types.ts

@@ -1,96 +0,0 @@
-/**
- * The session sidebar's shared vocabulary: the row a session list shows, the
- * five filter axes and the per-space view. React-free.
- */
-import type { ChatSessionStatus } from '../host';
-
-/**
- * One session as the sidebar lists it: the chat session plus where it runs
- * (folder, host, space). An app's own row type extends it.
- */
-export interface SidebarListSession {
-  /** The session's key. */
-  id: string;
-  /** What the row shows. */
-  title: string;
-  /** Whether a run is going, and how the last one ended. */
-  status: ChatSessionStatus;
-  /** Epoch ms. */
-  createdAt: number;
-  /** Epoch ms of the last activity. */
-  updatedAt: number;
-  /** The folder its tools run in. */
-  cwd: string;
-  /** The repository or project folder it belongs to, when known. */
-  projectRoot?: string;
-  /** The remote host it lives on; undefined on this machine. */
-  hostId?: string;
-  /** The space it belongs to; undefined in the default space. */
-  spaceId?: string;
-  /** The orchestration main session. */
-  isMain?: boolean;
-  /** Its folder is a git repository. */
-  isGitRepo?: boolean;
-  /**
-   * The repository its folder is a checkout of (`github.com/owner/repo`). Sessions of one
-   * repository on several machines are listed under one project.
-   */
-  repoKey?: string;
-  /** Starred: listed under Favorites. */
-  favorite?: boolean;
-  /** Archived: listed only under the archived filter. */
-  archived?: boolean;
-  /** The agent profile it runs (`AgentProfile.id`): the agent grouping and filter read it. */
-  agentId?: string;
-  /**
-   * What extensions computed for it, keyed `<extensionId>.<key>` (a query reads one as
-   * `facet.<extensionId>.<key>`). Absent: none, or a host that sends none.
-   */
-  facets?: Readonly<Record<string, unknown>>;
-}
-
-/** Which sessions the list reads: the archive axis is the one the host filters. */
-export type SessionArchiveFilter = 'active' | 'archived' | 'all';
-/** Only sessions touched within the last day, 3, 7 or 30 days. */
-export type SessionActivityFilter = 'all' | '1d' | '3d' | '7d' | '30d';
-/** How the sidebar groups its rows: the session list's groupings, one section per host, or one group per agent. */
-export type SidebarGroupBy = 'none' | 'date' | 'state' | 'project' | 'host' | 'agent';
-
-/**
- * In {@link SidebarExtensionView}: the view's own axis (`groupBy`, `sortBy`) in a space that has a
- * grouping or sort of its own (an extension space, a saved view), where that one applies by default.
- */
-export const VIEW_CHOICE = '@view';
-
-/**
- * The user's layer over what extensions contribute to the filter menu, kept per space with the rest
- * of the view. Ids are the published ones (`<extension>/<id>`); an id no extension offers now is ignored.
- */
-export interface SidebarExtensionView {
-  /** Each contributed filter's value: `true` for an active toggle, an option id (select), option ids (multi). */
-  filters: Readonly<Record<string, boolean | string | readonly string[]>>;
-  /** A contributed sort, or {@link VIEW_CHOICE}. Absent: the space's sort when it has one, else `sortBy`. */
-  sort?: string;
-  /** A contributed grouping, or {@link VIEW_CHOICE}. Absent: the space's grouping when it has one, else `groupBy`. */
-  group?: string;
-}
-/** How the sidebar orders sessions inside a group. */
-export type SidebarSortBy = 'recency' | 'createdTime' | 'alphabetical';
-
-/** The filter axes, kept per space. */
-export interface SidebarView {
-  /** Active, archived or every session. */
-  archive: SessionArchiveFilter;
-  /** A project's folder name, or null for every project. */
-  project: string | null;
-  /** Only sessions touched recently. */
-  activity: SessionActivityFilter;
-  /** How the rows group. */
-  groupBy: SidebarGroupBy;
-  /** How the rows sort inside a group. */
-  sortBy: SidebarSortBy;
-  /** Only this agent's sessions (`AgentProfile.id`), or null for every agent. */
-  agent?: string | null;
-  /** What the user picked of the extensions' filters, sorts and groupings. Absent: nothing. */
-  extension?: SidebarExtensionView;
-}