zidane-ui 9.0.4 → 9.1.3

package/src/chat/composer/model-catalog.ts

@@ -1,424 +0,0 @@
-/**
- * The model chain picker's data: a catalog of rows (one per model a
- * provider serves, per account when it has several) and the pure rules the
- * picker lists, searches and edits a chain by. The desktop app's
- * `listModels` rows (`ModelCatalogEntry`) fit `ModelCatalogRow` as they are;
- * a `ChatHost`'s `models` become rows through `catalogFromProviders`.
- */
-import {
-  chainAccountConflict,
-  currentModelKeys,
-  customModelTargets,
-  modelDisplayName,
-  modelPickKey,
-  pickPrimaryKeyed,
-} from 'zidane/chat/pure';
-
-import type { ChatModelProvider } from '../headless/host';
-import type { ModelCatalogRow, ModelPickRef } from '../headless/composer/models';
-
-export type { ModelCatalogRow, ModelPickRef } from '../headless/composer/models';
-
-const lineups = new WeakMap<readonly ModelCatalogRow[], ReadonlySet<string>>();
-
-/**
- * The catalog's current models (core `currentModelKeys`: the newest of each
- * family, by `lineupKeyOf`), worked out once per catalog: hosts keep theirs
- * between openings, and it means parsing every model id. Read-only.
- *
- * @param catalog - The catalog rows. The result is cached per array.
- */
-export function modelLineup(catalog: readonly ModelCatalogRow[]): ReadonlySet<string> {
-  let keys = lineups.get(catalog);
-  if (!keys) lineups.set(catalog, (keys = currentModelKeys(catalog)));
-  return keys;
-}
-
-/**
- * `1M`, `1.5M`, `200k`: the row meta has no room for `1.00M`.
- *
- * @param tokens - A context window size in tokens.
- */
-export function compactWindow(tokens: number): string {
-  if (tokens >= 1_000_000) return `${Number((tokens / 1_000_000).toFixed(1))}M`;
-  if (tokens >= 1_000) return `${Math.round(tokens / 1_000)}k`;
-  return `${tokens}`;
-}
-
-/**
- * Identity of a pick: provider, model and account (core `modelPickKey`, the one key chains compare by).
- *
- * @param entry - The pick.
- */
-export function refKey(entry: ModelPickRef): string {
-  return modelPickKey(entry.providerKey, entry.modelId, entry.account);
-}
-
-/**
- * The pick a catalog row makes: its provider, model and (when the provider has several) account.
- *
- * @param entry - The catalog row.
- */
-export function pickRefOf(entry: ModelCatalogRow): ModelPickRef {
-  return {
-    providerKey: entry.providerKey,
-    modelId: entry.modelId,
-    ...(entry.account ? { account: entry.account.id } : {}),
-  };
-}
-
-/**
- * A catalog row's pick identity.
- *
- * @param entry - The catalog row.
- */
-export function rowKey(entry: ModelCatalogRow): string {
-  return refKey(pickRefOf(entry));
-}
-
-/**
- * A row's lineup identity (`currentModelKeys`: provider + model, whatever the account).
- *
- * @param entry - The catalog row.
- */
-export function lineupKeyOf(entry: ModelCatalogRow): string {
-  return modelPickKey(entry.providerKey, entry.modelId);
-}
-
-/**
- * Section a row lists under: its provider, or its provider's account when there are several.
- *
- * @param entry - A row, or any object with its `providerKey` and `account`.
- */
-export function groupKeyOf(entry: Pick<ModelCatalogRow, 'providerKey' | 'account'>): string {
-  return entry.account ? `${entry.providerKey}@${entry.account.id}` : entry.providerKey;
-}
-
-/**
- * "Anthropic", or "Anthropic (Work)" for one of several accounts. Plain text: it also names
- * the account in tooltips and settings rows.
- *
- * @param entry - A row, or any object with its `providerLabel` and `account`.
- */
-export function providerAccountLabel(entry: Pick<ModelCatalogRow, 'providerLabel' | 'account'>): string {
-  return entry.account ? `${entry.providerLabel} (${entry.account.label})` : entry.providerLabel;
-}
-
-/**
- * A model's natural name (`Opus 4.6`), from the catalog's display name when it lists the model.
- *
- * @param catalog - The catalog rows, or `null` while it loads.
- * @param modelId - The model id to name.
- * @param providerKey - Limits the lookup to one provider. Defaults to `null`, which matches any provider.
- */
-export function modelNameOf(
-  catalog: readonly ModelCatalogRow[] | null,
-  modelId: string,
-  providerKey: string | null = null,
-): string {
-  return modelDisplayName({
-    providerKey,
-    modelId,
-    modelName: catalog?.find((e) => e.modelId === modelId && (!providerKey || e.providerKey === providerKey))
-      ?.modelName,
-  }).name;
-}
-
-/**
- * The chain after making `pick` the primary: one account per provider, so
- * entries naming another account of its provider drop (core
- * `filterChainFallbacks` would drop them anyway, silently).
- *
- * @param chain - The current chain: the primary, then its fallbacks.
- * @param pick - The model to make the primary.
- */
-export function withPrimary(chain: readonly ModelPickRef[], pick: ModelPickRef): ModelPickRef[] {
-  return pickPrimaryKeyed(
-    chain.filter((e) => e.providerKey !== pick.providerKey || e.account === pick.account),
-    pick,
-    refKey,
-  );
-}
-
-/**
- * Whether `pick` can join `chain` as a fallback: no other account of its provider is in it.
- *
- * @param chain - The current chain.
- * @param pick - The model to add as a fallback.
- */
-export function canJoinChain(chain: readonly ModelPickRef[], pick: ModelPickRef): boolean {
-  const asEntry = (e: ModelPickRef) => ({
-    provider: e.providerKey,
-    model: e.modelId,
-    ...(e.account ? { account: e.account } : {}),
-  });
-  return !chainAccountConflict(chain.map(asEntry), asEntry(pick));
-}
-
-/**
- * A pick as the catalog lists it. A pick naming no account runs on its
- * provider's active account: where the catalog lists that provider per
- * account, the pick is that account's row (the one marked active, else the
- * first account that has the model). Any other pick comes back as it is.
- *
- * @param pick - A pick of the chain.
- * @param catalog - The catalog rows.
- */
-export function resolvePick(pick: ModelPickRef, catalog: readonly ModelCatalogRow[]): ModelPickRef {
-  if (pick.account) return pick;
-  let first: string | undefined;
-  for (const entry of catalog) {
-    if (entry.providerKey !== pick.providerKey || entry.modelId !== pick.modelId || !entry.account) continue;
-    if (entry.account.active) return { ...pick, account: entry.account.id };
-    first ??= entry.account.id;
-  }
-  return first ? { ...pick, account: first } : pick;
-}
-
-/**
- * A chain as the catalog lists it, {@link resolvePick} on each entry: what the
- * picker shows (In use, places, checks) and edits. The chain itself when no
- * entry changes.
- *
- * @param chain - The chain: the primary, then its fallbacks.
- * @param catalog - The catalog rows.
- */
-export function resolveChain(
-  chain: readonly ModelPickRef[],
-  catalog: readonly ModelCatalogRow[],
-): readonly ModelPickRef[] {
-  let changed = false;
-  const shown = chain.map((pick) => {
-    const resolved = resolvePick(pick, catalog);
-    if (resolved !== pick) changed = true;
-    return resolved;
-  });
-  return changed ? shown : chain;
-}
-
-/**
- * An edit made on a resolved chain ({@link resolveChain}), back on the chain
- * it was resolved from: an entry that was there keeps its own form (a pick
- * naming no account still names none, so it still follows the active
- * account), a new one stays as it was picked.
- *
- * @param next - The edited resolved chain.
- * @param chain - The chain before the edit.
- * @param shown - `chain` resolved, as the edit saw it.
- */
-export function unresolveChain(
-  next: readonly ModelPickRef[],
-  chain: readonly ModelPickRef[],
-  shown: readonly ModelPickRef[],
-): ModelPickRef[] {
-  const was = new Map(shown.map((pick, i) => [refKey(pick), chain[i]!]));
-  return next.map((pick) => was.get(refKey(pick)) ?? pick);
-}
-
-function uniqueProviders(catalog: readonly ModelCatalogRow[]): { key: string; label: string }[] {
-  const seen = new Map<string, string>();
-  for (const entry of catalog) {
-    if (!seen.has(entry.providerKey)) seen.set(entry.providerKey, entry.providerLabel);
-  }
-  return [...seen].map(([key, label]) => ({ key, label }));
-}
-
-/**
- * "Use this id via …" rows for a typed model id, one per provider in the
- * catalog (the provider the query names first, then the current one, then
- * the rest), minus routes the catalog already lists. Empty unless the query
- * names an id worth offering: when the catalog matched something, only an
- * id-shaped query (a digit, `-`, `.`, `/` or `:`, 3+ characters) gets typed
- * routes, so a plain word like "claude" stays a search.
- *
- * @param catalog - The catalog rows.
- * @param query - What the user typed in the search field.
- * @param currentProviderKey - Key of the provider in use, listed after the one the query names. `null` for none.
- * @param catalogMatched - Whether the catalog already matched the query. If so, only an id-shaped query gets typed routes.
- */
-export function offCatalogRows(
-  catalog: readonly ModelCatalogRow[],
-  query: string,
-  currentProviderKey: string | null,
-  catalogMatched: boolean,
-): ModelCatalogRow[] {
-  const targets = customModelTargets(query, uniqueProviders(catalog), currentProviderKey);
-  const id = targets[0]?.modelId;
-  if (!id) return [];
-  if (catalogMatched && (id.length < 3 || !/[\d\-./:]/.test(id))) return [];
-  const listed = new Set(catalog.map(rowKey));
-  return targets
-    .filter((t) => !listed.has(refKey(t)))
-    .map((t) => ({
-      providerKey: t.providerKey,
-      providerLabel: t.providerLabel,
-      modelId: t.modelId,
-      modelName: t.modelId,
-      contextWindow: null,
-      supportsReasoning: false,
-      searchCorpus: '',
-      offCatalog: true,
-    }));
-}
-
-function corpusOf(entry: ModelCatalogRow): string {
-  return (
-    entry.searchCorpus ??
-    [
-      entry.providerKey,
-      entry.providerLabel,
-      entry.account?.label ?? '',
-      entry.modelId,
-      entry.modelName,
-      entry.modelProvider ?? '',
-    ]
-      .join(' ')
-      .toLowerCase()
-  );
-}
-
-/**
- * Search rank of one entry against the query terms, or `null` when a term is
- * missing. Lower is better: a term at the start of the model id beats one at
- * a word start inside it, which beats a substring of the id, which beats a
- * hit only in the name / provider corpus.
- *
- * @param entry - The catalog row.
- * @param terms - The lower-cased search terms. Every term must match.
- */
-export function modelSearchScore(entry: ModelCatalogRow, terms: readonly string[]): number | null {
-  const id = entry.modelId.toLowerCase();
-  const name = entry.modelName.toLowerCase();
-  const corpus = corpusOf(entry);
-  let score = 0;
-  for (const term of terms) {
-    if (!corpus.includes(term) && !id.includes(term) && !name.includes(term)) return null;
-    const at = id.indexOf(term);
-    if (at === 0 || id.lastIndexOf('/', at) === at - 1) score += 0;
-    else if (at > 0 && /[-_.\s/:]/.test(id[at - 1]!)) score += 1;
-    else if (at > 0) score += 2;
-    else score += name.includes(term) ? 3 : 4;
-  }
-  return score;
-}
-
-/** One section of the model picker list. */
-export interface PickerGroup<E extends ModelCatalogRow = ModelCatalogRow> {
-  /** Provider key (`provider@account` for one of several accounts), `in-use` for the pinned chain, `typed` for a typed id's routes. */
-  key: string;
-  /** Heading of the section. */
-  label: string;
-  /** Provider key for coloring; `null` for the in-use and typed groups. */
-  providerKey: string | null;
-  /** The models listed in the section. */
-  rows: E[];
-  /** Models of this provider in the catalog, before the lineup filter. */
-  total: number;
-  /** Shown after the label as typed (not uppercased): the typed id of the routes group. */
-  detail?: string;
-}
-
-/**
- * The picker's list as groups. Empty query: the chain first ("In use"), then
- * each provider in catalog order with its current models (or all of them
- * with `showLegacy`), chain members not repeated. With a query: every model
- * of every provider that matches, grouped by provider, groups ordered by
- * their best match, rows by score then catalog order.
- *
- * @param catalog - The catalog rows.
- * @param query - What the user typed in the search field. Blank lists by provider.
- * @param chain - The chain in force. Its models lead the list as "In use".
- * @param showLegacy - Lists every model instead of only the current ones.
- * @param current - The lineup keys of the current models, from {@link modelLineup}.
- */
-export function pickerGroups<E extends ModelCatalogRow>(
-  catalog: readonly E[],
-  query: string,
-  chain: readonly ModelPickRef[],
-  showLegacy: boolean,
-  current: ReadonlySet<string>,
-): PickerGroup<E>[] {
-  const totals = new Map<string, number>();
-  for (const entry of catalog) totals.set(groupKeyOf(entry), (totals.get(groupKeyOf(entry)) ?? 0) + 1);
-  const terms = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
-
-  const groups = new Map<string, PickerGroup<E> & { best: number; scored: { entry: E; score: number; i: number }[] }>();
-  const groupFor = (entry: E) => {
-    const key = groupKeyOf(entry);
-    let group = groups.get(key);
-    if (!group) {
-      group = {
-        key,
-        label: providerAccountLabel(entry),
-        providerKey: entry.providerKey,
-        rows: [],
-        total: totals.get(key) ?? 0,
-        best: Number.POSITIVE_INFINITY,
-        scored: [],
-      };
-      groups.set(key, group);
-    }
-    return group;
-  };
-
-  if (terms.length > 0) {
-    catalog.forEach((entry, i) => {
-      const score = modelSearchScore(entry, terms);
-      if (score === null) return;
-      const group = groupFor(entry);
-      group.scored.push({ entry, score, i });
-      group.best = Math.min(group.best, score);
-    });
-    return [...groups.values()]
-      .sort((a, b) => a.best - b.best)
-      .map(({ best: _best, scored, ...group }) => ({
-        ...group,
-        rows: scored.sort((a, b) => a.score - b.score || a.i - b.i).map((s) => s.entry),
-      }));
-  }
-
-  const byKey = new Map(catalog.map((entry) => [rowKey(entry), entry]));
-  const inUse: E[] = [];
-  const pinned = new Set<string>();
-  for (const pick of chain) {
-    const entry = byKey.get(refKey(pick));
-    if (entry && !pinned.has(rowKey(entry))) {
-      inUse.push(entry);
-      pinned.add(rowKey(entry));
-    }
-  }
-  for (const entry of catalog) {
-    if (pinned.has(rowKey(entry))) continue;
-    if (!showLegacy && !current.has(lineupKeyOf(entry))) {
-      groupFor(entry);
-      continue;
-    }
-    groupFor(entry).rows.push(entry);
-  }
-  const out: PickerGroup<E>[] = [];
-  if (inUse.length > 0)
-    out.push({ key: 'in-use', label: 'In use', providerKey: null, rows: inUse, total: inUse.length });
-  for (const { best: _best, scored: _scored, ...group } of groups.values()) {
-    if (group.rows.length > 0) out.push(group);
-  }
-  return out;
-}
-
-/**
- * A `ChatHost`'s models as catalog rows, in the host's order.
- *
- * @param providers - The providers a host offers, usually `host.models`.
- */
-export function catalogFromProviders(providers: readonly ChatModelProvider[]): ModelCatalogRow[] {
-  return providers.flatMap((provider) =>
-    provider.models.map((model) => ({
-      providerKey: provider.key,
-      providerLabel: provider.label,
-      modelId: model.id,
-      modelName: model.label ?? model.id,
-      contextWindow: model.contextWindow ?? null,
-      supportsReasoning: model.thinking === true,
-      ...(model.details?.length ? { details: model.details } : {}),
-    })),
-  );
-}

package/src/chat/composer/model-list-layout.ts

@@ -1,118 +0,0 @@
-/**
- * The model chain picker's list geometry. Section headers and rows have
- * fixed heights, so where everything sits is arithmetic: the list mounts
- * only the rows in view (plus overscan), and finds a row for the keyboard or
- * a section for a pill and the scroll spy without reading the DOM back.
- * The list sets these heights on its headers and rows: a restyle that needs
- * more room changes them here, or its content clips.
- */
-import type { PickerGroup } from './model-catalog';
-
-/** A section's header: the provider, sticky while its rows scroll under it. */
-export const MODEL_HEADER_H = 29;
-/** A row: one line in the popover (`dense`), two in the modal. */
-const MODEL_ROW_H = { dense: 30, full: 48 } as const;
-/** Between two rows of a section. */
-const MODEL_ROW_GAP = 1;
-/** The list's bottom padding, part of its scroll height. */
-export const MODEL_LIST_PAD_BOTTOM = 6;
-
-export interface PlacedGroup<G extends PickerGroup = PickerGroup> {
-  group: G;
-  /** Flat index of the group's first row: the cursor indexes rows across groups. */
-  first: number;
-  /** Offset of the group (its header) in the scrolled content. */
-  top: number;
-  height: number;
-}
-
-export interface ModelListLayout<G extends PickerGroup = PickerGroup> {
-  groups: PlacedGroup<G>[];
-  /** The groups' height, without the list's padding. */
-  height: number;
-  rowH: number;
-}
-
-export function layoutModelList<G extends PickerGroup>(groups: readonly G[], dense: boolean): ModelListLayout<G> {
-  const rowH = dense ? MODEL_ROW_H.dense : MODEL_ROW_H.full;
-  const placed: PlacedGroup<G>[] = [];
-  let top = 0;
-  let first = 0;
-  for (const group of groups) {
-    const n = group.rows.length;
-    const height = MODEL_HEADER_H + n * rowH + Math.max(0, n - 1) * MODEL_ROW_GAP;
-    placed.push({ group, first, top, height });
-    top += height;
-    first += n;
-  }
-  return { groups: placed, height: top, rowH };
-}
-
-/** Offset of a group's row `k` below the group's header. */
-export function rowTop(layout: ModelListLayout, k: number): number {
-  return k * (layout.rowH + MODEL_ROW_GAP);
-}
-
-/** Where the flat row `index` sits in the scrolled content. */
-export function placeOfRow(layout: ModelListLayout, index: number): number | null {
-  for (const placed of layout.groups) {
-    const k = index - placed.first;
-    if (k >= 0 && k < placed.group.rows.length) return placed.top + MODEL_HEADER_H + rowTop(layout, k);
-  }
-  return null;
-}
-
-/** The rows of `placed` that reach into `[from, to]` (content offsets), first and last; `null`: none. */
-export function rowsBetween(
-  layout: ModelListLayout,
-  placed: PlacedGroup,
-  from: number,
-  to: number,
-): [number, number] | null {
-  const n = placed.group.rows.length;
-  if (n === 0) return null;
-  const pitch = layout.rowH + MODEL_ROW_GAP;
-  const rowsTop = placed.top + MODEL_HEADER_H;
-  const lo = Math.max(0, Math.floor((from - rowsTop) / pitch));
-  const hi = Math.min(n - 1, Math.floor((to - rowsTop) / pitch));
-  return lo <= hi ? [lo, hi] : null;
-}
-
-/** How far the list scrolls: its content (groups and bottom padding) past its view. */
-export function maxScroll(layout: ModelListLayout, viewHeight: number): number {
-  return Math.max(0, layout.height + MODEL_LIST_PAD_BOTTOM - viewHeight);
-}
-
-/**
- * The section under the list's top edge: the last one whose header reached
- * it. Scrolled to the very bottom, the last section, even when a short one
- * never brings its header up there.
- */
-export function groupAt(layout: ModelListLayout, scrollTop: number, viewHeight: number): string | null {
-  const { groups } = layout;
-  if (groups.length === 0) return null;
-  const end = maxScroll(layout, viewHeight);
-  if (end > 1 && scrollTop > 0 && scrollTop >= end - 2) return groups.at(-1)!.group.key;
-  let key = groups[0]!.group.key;
-  for (const placed of groups) {
-    if (placed.top > scrollTop + 1) break;
-    key = placed.group.key;
-  }
-  return key;
-}
-
-/**
- * Where to scroll so the row at `top` shows, `null` when it already does.
- * The header sticky at the top of the list covers a row passing under it.
- */
-export function scrollToShow(
-  layout: ModelListLayout,
-  top: number,
-  scrollTop: number,
-  viewHeight: number,
-): number | null {
-  const bottom = top + layout.rowH;
-  if (top - MODEL_HEADER_H < scrollTop) return Math.max(0, top - MODEL_HEADER_H);
-  if (bottom > scrollTop + viewHeight) return Math.min(maxScroll(layout, viewHeight), bottom - viewHeight);
-  return null;
-}

package/src/chat/composer/prompt-history-nav.ts

@@ -1,60 +0,0 @@
-/**
- * Pure helpers for prompt-history navigation, shared by the kit's
- * `Composer` and the desktop app's Chatbox.
- *
- * ↑ recalls history only with the caret on the very first position of the
- * buffer, ↓ advances only from the very last one; anywhere else the editor
- * owns the keypress and moves the caret. A recall parks the caret at that
- * same edge, so repeated presses keep cycling. Positions, not text: a
- * Shift+Enter line break is a node, not a "\n" in the document's text, so
- * a text-based "first line" test took the second line for the first.
- * `plainTextToDocJson` rebuilds a TipTap doc from recalled plain text
- * without routing it through TipTap's HTML parser (which would collapse
- * newlines and interpret `<` as markup).
- */
-import { Selection, type EditorState } from '@tiptap/pm/state';
-
-/**
- * Whether the caret is collapsed on the very first position of the document.
- *
- * @param state - The editor state.
- */
-export function isCaretAtStart(state: Pick<EditorState, 'doc' | 'selection'>): boolean {
-  return state.selection.empty && state.selection.from === Selection.atStart(state.doc).from;
-}
-
-/**
- * Whether the caret is collapsed on the very last position of the document.
- *
- * @param state - The editor state.
- */
-export function isCaretAtEnd(state: Pick<EditorState, 'doc' | 'selection'>): boolean {
-  return state.selection.empty && state.selection.to === Selection.atEnd(state.doc).to;
-}
-
-interface DocJson {
-  type: 'doc';
-  content: Array<{ type: 'paragraph'; content?: Array<{ type: 'text'; text: string }> }>;
-}
-
-/**
- * Plain text → TipTap doc JSON, one paragraph per line. `setContent`
- * with a string parses it as HTML — multi-line history entries would
- * collapse to a single run and angle brackets would be swallowed as
- * tags. Building the JSON directly keeps recalled prompts (and restored
- * drafts) byte-faithful. Empty text yields a single empty paragraph,
- * the minimal valid `block+` doc.
- *
- * @param text - The plain text. Each line becomes a paragraph.
- */
-export function plainTextToDocJson(text: string): DocJson {
-  const lines = text.split('\n');
-
-  return {
-    type: 'doc',
-    content: lines.map((line) => ({
-      type: 'paragraph' as const,
-      ...(line.length > 0 ? { content: [{ type: 'text' as const, text: line }] } : {}),
-    })),
-  };
-}

package/src/chat/composer/scope-side.ts

@@ -1,7 +0,0 @@
-/** The look of one side of a draft's scope toggle (`ScopeToggle`, `ServerScopeToggle`, `ProjectMenu`). */
-export const SCOPE_SIDE =
-  'zg-segment-item zg-press-subtle inline-flex items-center gap-1 h-6 px-2 rounded-full text-xs border-0 bg-transparent cursor-pointer whitespace-nowrap';
-
-/** The text tone of a side: the picked one reads as text, the other muted. */
-export const scopeTone = (active: boolean) =>
-  active ? 'text-[var(--zg-text)] font-medium' : 'text-[var(--zg-text-muted)]';