zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/session-list.ts

@@ -1,400 +0,0 @@
-/**
- * The session list model: sort, group (by date, state or project), collapse
- * and "show more" caps, as a flat list of rows a renderer walks. Pure: the
- * same input gives the same rows, so a list can be rebuilt on every change
- * and tested without rendering.
- *
- * Generic over the session shape: anything with an id, a title, a status and
- * two timestamps. Project grouping reads the folder through `project`.
- * Favorites (`isFavorite`) lead the list in a section of their own, in every
- * grouping, and are not repeated in their group.
- */
-import { ageStep } from 'zidane/chat/pure';
-
-import { DEFAULT_CHAT_LABELS, type ChatLabels } from './labels';
-
-/** The minimal session shape the list model needs. {@link ChatSession} satisfies it. */
-export interface ListableSession {
-  /** Stable session id. Used as the row id. */
-  id: string;
-  /** Session title. Used for alphabetical sorting and the title search. */
-  title?: string;
-  /** Run state (`running`, `completed`, `error`, `idle`). Used for state grouping; missing counts as `idle`. */
-  status?: string;
-  /** Epoch milliseconds of creation. Used by the `createdTime` sort. */
-  createdAt: number;
-  /** Epoch milliseconds of the last activity. Used by the `recency` sort and date grouping. */
-  updatedAt?: number;
-}
-
-/** How the list groups sessions: `none` (flat), `date`, `state`, or `project`. */
-export type SessionGroupBy = 'none' | 'date' | 'state' | 'project';
-/** How sessions are ordered inside a group: `recency` (last activity, newest first), `createdTime` (newest first), or `alphabetical` by title. */
-export type SessionSortBy = 'recency' | 'createdTime' | 'alphabetical';
-
-/** One row of the flat list {@link buildSessionRows} returns: a group `header`, a `session`, or a `showMore` row that ends a capped group. */
-export type SessionListRow<S> =
-  | {
-      kind: 'header';
-      id: string;
-      label: string;
-      collapsed: boolean;
-      /** Project groups: the folder the group stands for (its full path). */
-      fullPath?: string;
-      /** Project groups: the folder is a git repository. */
-      isGitRepo?: boolean;
-      /** The directory-less bucket of a project grouping. */
-      chats?: boolean;
-      /** The favorites section, above every group. */
-      favorites?: boolean;
-      /** Project groups: pinned, so listed first in the order they were pinned. */
-      pinned?: boolean;
-    }
-  | {
-      kind: 'session';
-      id: string;
-      session: S;
-      /** Listed in the favorites section (its own group is not on show there). */
-      favorites?: boolean;
-    }
-  | { kind: 'showMore'; id: string; groupId: string; hiddenCount: number };
-
-/** Options for {@link buildSessionRows}. */
-export interface SessionListOptions<S> {
-  /**
-   * How to group sessions.
-   * @default 'none'
-   */
-  groupBy?: SessionGroupBy;
-  /**
-   * How to order sessions inside a group.
-   * @default 'recency'
-   */
-  sortBy?: SessionSortBy;
-  /** Orders sessions in place of `sortBy` (a query sort an extension or a space defines). */
-  compare?: (a: S, b: S) => number;
-  /** Header ids whose sessions are hidden. */
-  collapsedGroups?: ReadonlySet<string>;
-  /** Header ids whose capped group shows every session. */
-  showMoreExpanded?: ReadonlySet<string>;
-  /** Prefix for row ids, when several lists share one id space (one per host). */
-  idPrefix?: string;
-  /** Sessions shown per project group before "show more" (default 5). */
-  projectCap?: number;
-  /** A session's folder for project grouping; none puts it in the "Chats" bucket. */
-  project?: (session: S) => string | null | undefined;
-  /** The session's folder is a git repository. */
-  isGitRepo?: (session: S) => boolean;
-  /** Favorited sessions: shown first, under their own header. */
-  isFavorite?: (session: S) => boolean;
-  /**
-   * Project grouping: folders whose groups lead the list (under Favorites,
-   * above Chats) in this order, whatever their activity.
-   */
-  pinnedProjects?: readonly string[];
-  /** Strings for group headings and date buckets. Missing keys fall back to the default chat labels. */
-  labels?: Pick<
-    ChatLabels,
-    | 'today'
-    | 'yesterday'
-    | 'months'
-    | 'chats'
-    | 'favorites'
-    | 'stateRunning'
-    | 'stateCompleted'
-    | 'stateError'
-    | 'stateIdle'
-  >;
-  /** Clock, for date buckets (tests pin it). */
-  now?: number;
-  /** Pin the zone and locale of date buckets (pages rendered on a server and in browsers). */
-  calendar?: CalendarOptions;
-}
-
-/**
- * Default number of sessions a project group shows before its "show more" row.
- * @default 5
- */
-export const PROJECT_GROUP_CAP = 5;
-
-const EMPTY: ReadonlySet<string> = new Set();
-const DAY = 24 * 60 * 60 * 1000;
-
-/**
- * Which calendar day labels are read in. Default: the runtime's zone and
- * locale. Pin both when the same list renders on a server and in browsers
- * (a prerendered page), or the two disagree about "Yesterday" and hydration
- * fails.
- */
-export interface CalendarOptions {
-  /** IANA time zone the days are read in, for example `Europe/Paris`. Default: the runtime's zone. */
-  timeZone?: string;
-  /** Locale of the weekday names (the other date words come from the labels). */
-  locale?: string;
-}
-
-interface Day {
-  year: number;
-  month: number;
-  date: number;
-  /** Days since the epoch, in the calendar's zone: differences count whole days. */
-  index: number;
-}
-
-const zoned = new Map<string, Intl.DateTimeFormat>();
-function dayOf(at: number, calendar: CalendarOptions | undefined): Day {
-  if (!calendar?.timeZone) {
-    const d = new Date(at);
-    return {
-      year: d.getFullYear(),
-      month: d.getMonth(),
-      date: d.getDate(),
-      index: Math.floor(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()) / DAY),
-    };
-  }
-  let fmt = zoned.get(calendar.timeZone);
-  if (!fmt) {
-    fmt = new Intl.DateTimeFormat('en-US', {
-      timeZone: calendar.timeZone,
-      year: 'numeric',
-      month: 'numeric',
-      day: 'numeric',
-    });
-    zoned.set(calendar.timeZone, fmt);
-  }
-  const part = (type: string) => Number(fmt.formatToParts(at).find((p) => p.type === type)?.value);
-  const year = part('year');
-  const month = part('month') - 1;
-  const date = part('day');
-  return { year, month, date, index: Math.floor(Date.UTC(year, month, date) / DAY) };
-}
-
-const weekdays = new Map<string, Intl.DateTimeFormat>();
-/** Locale weekday name, capitalised (fr, es, it spell them lowercase). */
-function weekdayLabel(at: number, calendar: CalendarOptions | undefined): string {
-  const key = `${calendar?.locale ?? ''}|${calendar?.timeZone ?? ''}`;
-  let fmt = weekdays.get(key);
-  if (!fmt) {
-    fmt = new Intl.DateTimeFormat(calendar?.locale, { weekday: 'long', timeZone: calendar?.timeZone });
-    weekdays.set(key, fmt);
-  }
-  const raw = fmt.format(at);
-  return raw.charAt(0).toLocaleUpperCase() + raw.slice(1);
-}
-
-/**
- * Today, Yesterday, a weekday within the week, `Mon D` this year, `Mon YYYY` before.
- *
- * @param at - Epoch milliseconds of the session's activity.
- * @param now - Epoch milliseconds of the current time.
- * @param labels - Strings for `today`, `yesterday`, and the month names. Defaults to the default chat labels.
- * @param calendar - Pins the zone and locale the days are read in.
- */
-export function dateBucket(at: number, now: number, labels = DEFAULT_CHAT_LABELS, calendar?: CalendarOptions): string {
-  const d = dayOf(at, calendar);
-  const today = dayOf(now, calendar);
-  const ago = today.index - d.index;
-  if (ago <= 0) return labels.today;
-  if (ago === 1) return labels.yesterday;
-  if (ago <= 7 && d.year === today.year) return weekdayLabel(at, calendar);
-  if (d.year === today.year) return `${labels.months[d.month]} ${d.date}`;
-  return `${labels.months[d.month]} ${d.year}`;
-}
-
-/** From this many days {@link relativeTime} shows a date (`Mar 4`), not a duration: pass it to core `ageStep` to know whether the label takes "ago". */
-export const RELATIVE_TIME_DATE_AFTER_DAYS = 7;
-
-/**
- * How long ago, as short as it can say it: `now`, `5m`, `3h`, `2d`, `Mar 4`, `Mar 2024`.
- * Only a duration reads with "ago" in a sentence (core `ageStep` says which).
- *
- * @param at - Epoch milliseconds of the event.
- * @param now - Epoch milliseconds of the current time.
- * @param labels - Strings for `justNow` and the month names. Defaults to the default chat labels.
- * @param calendar - Pins the zone and locale the dates are read in.
- */
-export function relativeTime(
-  at: number,
-  now: number,
-  labels: Pick<ChatLabels, 'justNow' | 'months'> = DEFAULT_CHAT_LABELS,
-  calendar?: CalendarOptions,
-): string {
-  const step = ageStep(at, now, RELATIVE_TIME_DATE_AFTER_DAYS);
-  if (step.kind === 'now') return labels.justNow;
-  if (step.kind === 'duration') return `${step.value}${step.unit}`;
-  const d = dayOf(at, calendar);
-  if (d.year === dayOf(now, calendar).year) return `${labels.months[d.month]} ${d.date}`;
-  return `${labels.months[d.month]} ${d.year}`;
-}
-
-/**
- * A running session's elapsed time: `42s`, `12m`, `1h 5m`.
- *
- * @param sec - Elapsed whole seconds.
- */
-export function formatElapsedShort(sec: number): string {
-  if (sec < 60) return `${sec}s`;
-  if (sec < 3600) return `${Math.floor(sec / 60)}m`;
-  const m = Math.floor((sec % 3600) / 60);
-  return `${Math.floor(sec / 3600)}h${m ? ` ${m}m` : ''}`;
-}
-
-/**
- * The order a sort puts two sessions in (negative: `a` first), as {@link buildSessionRows} sorts them.
- *
- * @param a - One session.
- * @param b - The other.
- * @param sort - The sort.
- */
-export function compareSessions(a: ListableSession, b: ListableSession, sort: SessionSortBy): number {
-  switch (sort) {
-    case 'alphabetical':
-      return (a.title || '').localeCompare(b.title || '');
-    case 'createdTime':
-      return b.createdAt - a.createdAt;
-    default:
-      return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
-  }
-}
-
-const segments = (path: string) => path.split('/').filter(Boolean);
-
-/** Basename per project folder; `parent/name` when two basenames collide. */
-function projectLabels(paths: readonly string[]): Map<string, string> {
-  const byBase = new Map<string, string[]>();
-  for (const p of paths) {
-    const base = segments(p).pop() ?? p;
-    byBase.set(base, [...(byBase.get(base) ?? []), p]);
-  }
-  const out = new Map<string, string>();
-  for (const [base, list] of byBase) {
-    for (const p of list) {
-      const segs = segments(p);
-      const parent = list.length > 1 && segs.length >= 2 ? segs[segs.length - 2] : '';
-      out.set(p, parent ? `${parent}/${base}` : base);
-    }
-  }
-  return out;
-}
-
-const CHATS = '\u0000chats';
-
-/**
- * Builds the flat row list for a session list: favorites first, then groups with headers, collapse state, and "show more" caps for project groups. Pure: the same input gives the same rows.
- *
- * @param sessions - The sessions to list.
- * @param options - Grouping, sorting, collapse state, and labels.
- */
-export function buildSessionRows<S extends ListableSession>(
-  sessions: readonly S[],
-  options: SessionListOptions<S> = {},
-): SessionListRow<S>[] {
-  const groupBy = options.groupBy ?? 'none';
-  const collapsedGroups = options.collapsedGroups ?? EMPTY;
-  const showMoreExpanded = options.showMoreExpanded ?? EMPTY;
-  const prefix = options.idPrefix ?? '';
-  const cap = options.projectCap ?? PROJECT_GROUP_CAP;
-  const labels = { ...DEFAULT_CHAT_LABELS, ...options.labels };
-  const compare = options.compare ?? ((a: S, b: S) => compareSessions(a, b, options.sortBy ?? 'recency'));
-  const all = sessions.slice().sort(compare);
-  const favorites = options.isFavorite ? all.filter(options.isFavorite) : [];
-  const sorted = favorites.length > 0 ? all.filter((s) => !options.isFavorite!(s)) : all;
-
-  // Favorites first, under a header of their own (collapsible like any group).
-  const out: SessionListRow<S>[] = [];
-  if (favorites.length > 0) {
-    const id = `h-${prefix}Favorites`;
-    const collapsed = collapsedGroups.has(id);
-    out.push({ kind: 'header', id, label: labels.favorites, collapsed, favorites: true });
-    if (!collapsed) {
-      for (const session of favorites) out.push({ kind: 'session', id: session.id, session, favorites: true });
-    }
-  }
-
-  if (groupBy === 'none') {
-    for (const session of sorted) out.push({ kind: 'session', id: session.id, session });
-    return out;
-  }
-
-  const now = options.now ?? Date.now();
-  const state: Record<string, string> = {
-    running: labels.stateRunning,
-    completed: labels.stateCompleted,
-    error: labels.stateError,
-    idle: labels.stateIdle,
-  };
-  const groups = new Map<string, S[]>();
-  const gitRepos = new Set<string>();
-  const order: string[] = [];
-
-  for (const session of sorted) {
-    let bucket: string;
-    if (groupBy === 'date') bucket = dateBucket(session.updatedAt ?? now, now, labels, options.calendar);
-    else if (groupBy === 'state') bucket = state[session.status ?? 'idle'] ?? labels.stateIdle;
-    else {
-      const folder = options.project?.(session);
-      bucket = folder ? folder.replace(/\/+$/, '') || '/' : CHATS;
-    }
-    if (!groups.has(bucket)) {
-      groups.set(bucket, []);
-      order.push(bucket);
-    }
-    if (groupBy === 'project' && bucket !== CHATS && options.isGitRepo?.(session)) gitRepos.add(bucket);
-    groups.get(bucket)!.push(session);
-  }
-
-  // Directory-less chats lead a project grouping, after the pinned projects in pin order.
-  const pinned = new Set<string>();
-  if (groupBy === 'project') {
-    if (order.indexOf(CHATS) > 0) {
-      order.splice(order.indexOf(CHATS), 1);
-      order.unshift(CHATS);
-    }
-    for (const path of options.pinnedProjects ?? []) {
-      const bucket = path.replace(/\/+$/, '') || '/';
-      if (groups.has(bucket) && bucket !== CHATS) pinned.add(bucket);
-    }
-    if (pinned.size > 0) order.splice(0, order.length, ...pinned, ...order.filter((b) => !pinned.has(b)));
-  }
-
-  const names = groupBy === 'project' ? projectLabels(order.filter((b) => b !== CHATS)) : null;
-  for (const bucket of order) {
-    const chats = bucket === CHATS;
-    const label = chats ? labels.chats : (names?.get(bucket) ?? bucket);
-    // Stable ids, whatever the labels say: apps persist collapse state under them.
-    const key = chats ? 'Chats' : bucket;
-    const id = `h-${prefix}${key}`;
-    const collapsed = collapsedGroups.has(id);
-    const project = groupBy === 'project' && !chats;
-    out.push({
-      kind: 'header',
-      id,
-      label,
-      collapsed,
-      ...(project ? { fullPath: bucket, isGitRepo: gitRepos.has(bucket) } : {}),
-      ...(pinned.has(bucket) ? { pinned: true } : {}),
-      ...(chats ? { chats: true } : {}),
-    });
-    if (collapsed) continue;
-    const group = groups.get(bucket)!;
-    const capped = groupBy === 'project' && group.length > cap && !showMoreExpanded.has(id);
-    for (const session of capped ? group.slice(0, cap) : group) out.push({ kind: 'session', id: session.id, session });
-    if (capped) out.push({ kind: 'showMore', id: `m-${prefix}${key}`, groupId: id, hiddenCount: group.length - cap });
-  }
-  return out;
-}
-
-/**
- * Sessions whose title contains every word of `query` (case-insensitive).
- *
- * @param sessions - The sessions to filter.
- * @param query - Space-separated words. A blank query returns a copy of every session.
- */
-export function filterSessions<S extends ListableSession>(sessions: readonly S[], query: string): S[] {
-  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
-  if (!words.length) return sessions.slice();
-  return sessions.filter((s) => {
-    const title = (s.title ?? '').toLowerCase();
-    return words.every((w) => title.includes(w));
-  });
-}

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

@@ -1,179 +0,0 @@
-/**
- * What each session's run is doing right now, for the sidebar: thinking,
- * writing, a tool call (in the transcript's own words), compacting or
- * retrying. Kept per session outside React from the stream signals the app
- * receives for every session ({@link createSessionActivity}). Listeners fire
- * only when what a row shows changes, never per streamed token.
- *
- * Subagent events are left out: the parent's own call that spawned them
- * (still running) is what the row says.
- */
-import { displayNameFor, toolOverview } from 'zidane/chat/pure';
-import type { StreamEvent } from 'zidane/chat';
-
-import { DEFAULT_SIDEBAR_LABELS, type SidebarLabels } from './labels';
-
-/** The stream signals the activity follows; any other kind is ignored. */
-export type SessionActivitySignal =
-  | { kind: 'run:start'; sessionId: string; runId?: string; startedAt?: number }
-  | { kind: 'run:end'; sessionId: string; runId?: string; ok?: boolean }
-  | { kind: 'compacting:start'; sessionId: string }
-  | { kind: 'compacting:end'; sessionId: string; ok?: boolean }
-  | { kind: 'stream:retry'; sessionId: string; source: string; attempt?: number; max?: number }
-  | { kind: 'stream:retry:cleared'; sessionId: string; source: string }
-  | {
-      kind: 'event';
-      sessionId: string;
-      event: Pick<StreamEvent, 'kind' | 'childId' | 'streaming' | 'tool' | 'callId' | 'input'>;
-    };
-
-/** What a session's run is doing, as its row says it. */
-export interface SessionActivity {
-  /** Tool calls still running, oldest first: the row names the newest. */
-  tools: readonly { callId: string; label: string; title?: string }[];
-  /** What the model does when no tool runs. */
-  phase: 'thinking' | 'writing' | 'compacting' | 'retrying';
-  /** Inside a run (a compaction can also happen on its own, `/compact`). */
-  run: boolean;
-}
-
-/**
- * The row's words for an activity: the newest running tool, else the phase.
- *
- * @param activity - What the run is doing.
- * @param labels - The phase words.
- */
-export function activityLabel(
-  activity: SessionActivity,
-  labels: Pick<
-    SidebarLabels,
-    'activityCompacting' | 'activityRetrying' | 'activityWriting' | 'activityThinking'
-  > = DEFAULT_SIDEBAR_LABELS,
-): { text: string; title?: string } {
-  if (activity.phase === 'compacting') return { text: labels.activityCompacting };
-  if (activity.phase === 'retrying') return { text: labels.activityRetrying };
-  const tool = activity.tools.at(-1);
-  if (tool) return { text: tool.label, ...(tool.title ? { title: tool.title } : {}) };
-  return { text: activity.phase === 'writing' ? labels.activityWriting : labels.activityThinking };
-}
-
-const THINKING: SessionActivity = { tools: [], phase: 'thinking', run: true };
-
-/**
- * The next activity after `signal`; the same object when nothing a row shows changed, `null` once the run ended.
- *
- * @param prev - The activity so far, `null` for none.
- * @param signal - The stream signal that arrived.
- */
-export function reduceActivity(prev: SessionActivity | null, signal: SessionActivitySignal): SessionActivity | null {
-  switch (signal.kind) {
-    case 'run:start':
-      return THINKING;
-    case 'run:end':
-      return null;
-    case 'compacting:start':
-      return { tools: prev?.tools ?? [], phase: 'compacting', run: prev?.run ?? false };
-    case 'compacting:end':
-      // A compaction outside a run (`/compact`) leaves nothing running.
-      if (prev?.phase !== 'compacting') return prev;
-      return prev.run ? { ...prev, phase: 'thinking' } : null;
-    case 'stream:retry':
-      return signal.source === 'parent' ? { tools: prev?.tools ?? [], phase: 'retrying', run: true } : prev;
-    case 'stream:retry:cleared':
-      return signal.source === 'parent' && prev?.phase === 'retrying' ? { ...prev, phase: 'thinking' } : prev;
-    case 'event': {
-      const event = signal.event;
-      if (event.childId) return prev;
-      switch (event.kind) {
-        // The model streams only once every tool result is in: a call whose
-        // result this window missed stops being named here.
-        case 'thinking':
-          return prev?.phase === 'thinking' && prev.tools.length === 0 ? prev : THINKING;
-        case 'markdown':
-          if (!event.streaming) return prev;
-          return prev?.phase === 'writing' && prev.tools.length === 0
-            ? prev
-            : { tools: [], phase: 'writing', run: true };
-        case 'tool': {
-          if (!event.tool || !event.callId) return prev;
-          const input = (event.input ?? undefined) as Record<string, unknown> | undefined;
-          const overview = toolOverview({
-            name: event.tool,
-            displayName: displayNameFor(event.tool, input ?? {}),
-            ...(input ? { input } : {}),
-            ok: null,
-          });
-          const tools = [...(prev?.tools ?? []).filter((t) => t.callId !== event.callId)];
-          tools.push({
-            callId: event.callId,
-            label: overview.label,
-            ...(overview.title ? { title: overview.title } : {}),
-          });
-          return { tools, phase: 'thinking', run: true };
-        }
-        case 'tool-result': {
-          if (!prev || !event.callId || !prev.tools.some((t) => t.callId === event.callId)) return prev;
-          return { ...prev, tools: prev.tools.filter((t) => t.callId !== event.callId) };
-        }
-        default:
-          return prev;
-      }
-    }
-    default:
-      return prev;
-  }
-}
-
-/** Every session's activity, outside React. */
-export interface SessionActivityStore {
-  /** Follow the signals; returns the stop. Call once at boot. */
-  start(): () => void;
-  /** The session's activity, `null` when nothing of a run was seen (or it ended). */
-  get(sessionId: string): SessionActivity | null;
-  /** Fires only when what the session's row shows changes. */
-  subscribe(sessionId: string, listener: () => void): () => void;
-}
-
-/**
- * The activity store over `subscribe`, the app's feed of every session's
- * stream signals (an Electron bus, a server connection's `ipc.signal`).
- *
- * @param options - The signal feed.
- */
-export function createSessionActivity(options: {
-  subscribe: (listener: (signal: { kind: string }) => void) => () => void;
-}): SessionActivityStore {
-  const activities = new Map<string, SessionActivity>();
-  const listeners = new Map<string, Set<() => void>>();
-
-  const apply = (sessionId: string, signal: SessionActivitySignal): void => {
-    const prev = activities.get(sessionId) ?? null;
-    const next = reduceActivity(prev, signal);
-    if (next === prev) return;
-    if (next) activities.set(sessionId, next);
-    else activities.delete(sessionId);
-    for (const listener of listeners.get(sessionId) ?? []) listener();
-  };
-
-  return {
-    start: () =>
-      options.subscribe((signal) => {
-        if ('sessionId' in signal && typeof signal.sessionId === 'string') {
-          apply(signal.sessionId, signal as SessionActivitySignal);
-        }
-      }),
-    get: (sessionId) => activities.get(sessionId) ?? null,
-    subscribe(sessionId, listener) {
-      let set = listeners.get(sessionId);
-      if (!set) {
-        set = new Set();
-        listeners.set(sessionId, set);
-      }
-      set.add(listener);
-      return () => {
-        set.delete(listener);
-        if (set.size === 0 && listeners.get(sessionId) === set) listeners.delete(sessionId);
-      };
-    },
-  };
-}