zidane-ui 9.1.1 → 9.1.4

package/src/chat/rich-composer/mention-popover.ts

@@ -1,336 +0,0 @@
-/**
- * The composer's completion popovers (`@` files, `/` skills and commands,
- * `#` chats, extension triggers): the TipTap suggestion renderer that shows
- * a `MentionList` in a tippy, the gate that says whether one answers keys,
- * and the helpers the suggestion sources share.
- */
-import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
-import { ReactRenderer } from '@tiptap/react';
-import type { SuggestionKeyDownProps, SuggestionProps } from '@tiptap/suggestion';
-import tippy, { type Instance as TippyInstance } from 'tippy.js';
-
-import { readMotionMs } from '../../motion/presence';
-import type { CommandArgSuggestionSummary } from 'zidane/chat';
-
-import type { ComposerCompletions } from '../headless/composer/host';
-import { MentionList, type MentionItem, type MentionKind, type MentionListRef } from './MentionList';
-import { mentionPopoverActive } from '../headless/composer/ghost-autocomplete';
-
-/**
- * Adapter — invoke a canonical `CompletionProvider`'s `suggest()` and
- * project the results into TipTap's `MentionItem` shape so the existing
- * popover renderer (`MentionList`) doesn't need to learn the canonical
- * types. Synchronous because both built-in providers return arrays.
- */
-export function suggestToMentionItems<T>(
-  provider: { suggest: (query: string, ctx: { text: string; cursor: number }, signal: AbortSignal) => unknown },
-  query: string,
-  limit: number,
-  toItem: (data: T) => MentionItem,
-): MentionItem[] {
-  const items = provider.suggest(query, { text: query, cursor: query.length }, new AbortController().signal);
-
-  if (!Array.isArray(items)) {
-    return [];
-  }
-
-  return items.slice(0, limit).map((it: { data: T }) => toItem(it.data));
-}
-
-export function projectName(projectRoot: string): string {
-  return projectRoot.split('/').filter(Boolean).pop() ?? projectRoot;
-}
-
-/**
- * Debounced `completeArgs` IPC forward for the `/` popover's arg mode.
- * A monotonically-increasing token drops stale queries: only the latest
- * keystroke's call survives the 120ms window, everything older resolves
- * to `[]` without ever hitting IPC.
- */
-let argsCompletionToken = 0;
-
-export async function debouncedCompleteArgs(
-  complete: ComposerCompletions['commandArgs'],
-  cwd: string,
-  name: string,
-  argsPrefix: string,
-  hostId: string | null,
-): Promise<CommandArgSuggestionSummary[]> {
-  const token = ++argsCompletionToken;
-  await new Promise((resolve) => setTimeout(resolve, 120));
-
-  if (token !== argsCompletionToken) {
-    return [];
-  }
-
-  if (!complete) return [];
-  return complete({ cwd, hostId }, name, argsPrefix).then(
-    (found) => [...found],
-    () => [],
-  );
-}
-
-/**
- * Whether a completion popover answers keys (Enter/Tab/↑/↓). Several
- * triggers can be live at once (`/review @READ`: the `/` run keeps its
- * arguments open while `@` completes a file), so each popover registers
- * its own live check, and the gate is open while any of them answers.
- * Live, not a stored flag: the composer's Enter handler steps aside
- * exactly when a popover will take the key, never otherwise (a stale flag
- * let Enter fall through to a new line).
- */
-export interface PopoverGate {
-  readonly open: boolean;
-  register(owner: symbol, answers: () => boolean): void;
-  unregister(owner: symbol): void;
-}
-
-export function createPopoverGate(): PopoverGate {
-  const owners = new Map<symbol, () => boolean>();
-  return {
-    get open() {
-      for (const answers of owners.values()) if (answers()) return true;
-      return false;
-    },
-    register: (owner, answers) => void owners.set(owner, answers),
-    unregister: (owner) => void owners.delete(owner),
-  };
-}
-
-export function createMentionRenderer(
-  gate: PopoverGate,
-  kind: MentionKind,
-  options?: {
-    scopeLabel?: () => string;
-    onScopeToggle?: (query: string) => { items: MentionItem[]; scopeLabel: string };
-
-    /**
-     * Hide the popup while the suggestion has zero items — used by the
-     * `/` popover, whose `allowSpaces` matching would otherwise pin an
-     * empty “No matches” box to the caret while the user types prose or
-     * command arguments with no completions.
-     */
-    hideWhenEmpty?: boolean;
-
-    /**
-     * Fired whenever the gate may have flipped — the popover is a
-     * ghost-gate input, and its transitions (items appearing/vanishing,
-     * Esc, exit) happen outside the transaction flow the ghost listener sees.
-     */
-    onActiveChange?: () => void;
-  },
-) {
-  let component: ReactRenderer<MentionListRef> | null = null;
-  let popup: TippyInstance[] | null = null;
-  // Esc dismissed this suggestion run — popup stays hidden and the
-  // key-gate stays released until the suggestion exits for real.
-  let escaped = false;
-  // The document right after a pick: the popover stays closed until the
-  // user types again (a command's `/name ` would otherwise reopen on its
-  // arguments, an argument on itself).
-  let pickedDoc: ProseMirrorNode | null = null;
-  /*
-   * The suggestion's items as last resolved, and its range and query as
-   * of now: TipTap reports a new query (`onBeforeUpdate`) before its items
-   * resolve (`onUpdate`), so a pick in between replaces the current text
-   * with the item still on screen.
-   */
-  let resolved: SuggestionProps<MentionItem> | null = null;
-  let current: SuggestionProps<MentionItem> | null = null;
-  // A `#` scope switch: its items, for the list it was switched from.
-  let scoped: { from: readonly MentionItem[]; items: MentionItem[]; scopeLabel: string } | null = null;
-
-  const closed = (props: SuggestionProps<MentionItem>) => escaped || props.editor.state.doc === pickedDoc;
-  const hasItems = (props: SuggestionProps<MentionItem>): boolean =>
-    mentionPopoverActive((props.items as MentionItem[]).length);
-  /*
-   * Already typed out: the best suggestion is the text itself (`/clear`,
-   * `/fix conflicts`, `@README.md`), so there is nothing to complete and
-   * Enter sends instead of inserting what is already there.
-   */
-  const typedOut = (props: SuggestionProps<MentionItem>) => {
-    const top = (props.items as MentionItem[])[0];
-    return top !== undefined && (top.insertText ?? `${props.text[0]}${top.id}`).trim() === props.text.trim();
-  };
-  const shows = (props: SuggestionProps<MentionItem>) =>
-    !closed(props) && !typedOut(props) && (hasItems(props) || !options?.hideWhenEmpty);
-
-  /** What the popover lists: the resolved items, or a scope switch made from them. */
-  const listed = (): MentionItem[] => {
-    const items = (resolved?.items ?? []) as MentionItem[];
-    return scoped && scoped.from === items ? scoped.items : items;
-  };
-  const scopeLabelNow = () => (scoped && scoped.from === resolved?.items ? scoped.scopeLabel : options?.scopeLabel?.());
-  const visible = () => Boolean(popup?.[0]?.state.isVisible);
-
-  /*
-   * The popover answers keys — and suppresses the inline ghost — only
-   * while it shows items. TUI parity: `popupOpen` is `active &&
-   * items.length > 0` (`PromptBlock`, src/tui/prompt/prompt-block.tsx),
-   * so an active suggestion with zero matches leaves Enter-submit,
-   * history ↑, and ghost queries working.
-   */
-  const owner = Symbol(kind);
-  const answers = () => visible() && listed().length > 0;
-  let wasOpen = false;
-  const changed = () => {
-    if (wasOpen !== answers()) {
-      wasOpen = answers();
-      options?.onActiveChange?.();
-    }
-  };
-
-  const setShown = (show: boolean) => {
-    if (show) popup?.[0]?.show();
-    else popup?.[0]?.hide();
-    changed();
-  };
-
-  const pick = (item: MentionItem) => {
-    const props = current ?? resolved;
-    if (!props) return;
-    props.command(item);
-    pickedDoc = props.editor.state.doc;
-    setShown(false);
-  };
-
-  const render = () =>
-    component?.updateProps({
-      items: listed(),
-      query: resolved?.query ?? '',
-      kind,
-      scopeLabel: scopeLabelNow(),
-      command: pick,
-    });
-
-  return {
-    onBeforeStart(props: SuggestionProps<MentionItem>) {
-      current = props;
-    },
-
-    onBeforeUpdate(props: SuggestionProps<MentionItem>) {
-      current = props;
-    },
-
-    onStart(props: SuggestionProps<MentionItem>) {
-      escaped = false;
-      pickedDoc = null;
-      scoped = null;
-      resolved = props;
-      current = props;
-      gate.register(owner, answers);
-      component = new ReactRenderer(MentionList, {
-        props: {
-          items: listed(),
-          query: props.query,
-          kind,
-          scopeLabel: scopeLabelNow(),
-          command: pick,
-        },
-        editor: props.editor,
-      });
-
-      // Without a place to anchor, nothing shows, so nothing answers keys.
-      if (!props.clientRect) {
-        return;
-      }
-
-      popup = tippy('body', {
-        getReferenceClientRect: () => props.clientRect?.() ?? new DOMRect(),
-        appendTo: () => document.body,
-        content: component.element,
-        showOnCreate: true,
-        interactive: true,
-        trigger: 'manual',
-        placement: 'top-start',
-        offset: [0, 8],
-        // The list sizes itself (MentionList); tippy's default 350px cap would clip it.
-        maxWidth: 'none',
-        theme: 'zg-mention',
-
-        /**
-         * The shared menu motion: a scale-and-slide from the caret in
-         * (`menu`), a fade and slight shrink out (`menu-exit`). The
-         * per-property curves live in `rich-composer.css` under
-         * `.tippy-box[data-animation='zg-mention']`. Tippy only needs the
-         * lengths to know when the hide is done (0 with motion off, where
-         * no transition runs and it unmounts at once). `data-leaving` tells
-         * the hidden state of a close (no slide) from the one before an open.
-         */
-        animation: 'zg-mention',
-        duration: [readMotionMs('menu'), readMotionMs('menu-exit')],
-        onShow: (instance) => {
-          instance.popper.firstElementChild?.removeAttribute('data-leaving');
-        },
-        onHide: (instance) => {
-          instance.popper.firstElementChild?.setAttribute('data-leaving', '');
-        },
-
-        /**
-         * No arrow tail — the popover is anchored visually by its scale
-         * origin (bottom-left, matching `top-start` placement). An arrow
-         * would compete with the typed `@` / `/` glyph below it.
-         */
-        arrow: false,
-
-        /**
-         * Tippy's hover-bridge zone — the invisible padding between
-         * trigger and popover that keeps interactive popovers open when
-         * the cursor crosses the gap. The mention popover is keyboard-
-         * driven and dismissed by the suggestion plugin, so we don't
-         * need the bridge; turning it off removes a stray cursor target.
-         */
-        interactiveBorder: 0,
-      });
-
-      setShown(shows(props));
-    },
-
-    onUpdate(props: SuggestionProps<MentionItem>) {
-      resolved = props;
-      current = props;
-      render();
-      popup?.[0]?.setProps({ getReferenceClientRect: () => props.clientRect?.() ?? new DOMRect() });
-      setShown(shows(props));
-    },
-
-    onKeyDown(props: SuggestionKeyDownProps) {
-      // Only a shown popover answers keys: another trigger's may be the one open.
-      if (!visible()) {
-        return false;
-      }
-
-      if (props.event.key === 'Escape') {
-        escaped = true;
-        setShown(false);
-        return true;
-      }
-
-      if (props.event.key === 'Tab' && options?.onScopeToggle && resolved) {
-        const next = options.onScopeToggle(resolved.query);
-        scoped = { from: resolved.items as MentionItem[], ...next };
-        render();
-        changed();
-        return true;
-      }
-
-      // The same check the gate reads: the list on screen, which takes the key when it has items.
-      if (!answers()) {
-        return false;
-      }
-
-      return component?.ref?.onKeyDown({ event: props.event, items: listed(), pick }) ?? false;
-    },
-
-    onExit() {
-      gate.unregister(owner);
-      resolved = null;
-      current = null;
-      changed();
-      popup?.[0]?.destroy();
-      component?.destroy();
-      popup = null;
-      component = null;
-    },
-  };
-}

package/src/chat/rich-composer/slash-completion.ts

@@ -1,143 +0,0 @@
-/**
- * Canonical `/` completion for the Chatbox popover — a real mirror of the
- * TUI's merged Commands + Skills popover.
- *
- * Instead of an ad-hoc substring filter over `CommandSummary[]`, this
- * routes every keystroke through the canonical
- * `createCommandsCompletionProvider` (rank ladder: name/alias prefix →
- * name/alias substring + extension-group prefix → description substring →
- * fzf fuzzy → list-all on empty query; alias suffix in the description;
- * async argument completion) and merges with the host's skills provider
- * via the canonical `mergeSuggestions`, which tags each item with its
- * provider `section` ("Commands" / "Skills") in group order — Commands
- * first, matching the TUI's registration order (`useCompletionProviders`,
- * src/tui/prompt/use-completion-providers.ts).
- *
- * Engine parity: `findActiveTriggers` consults ONLY `allowSpacesInQuery`
- * providers once the query contains whitespace, so in argument mode
- * (`/review <prefix>`) the skills provider drops out and — with a single
- * group — `mergeSuggestions` leaves items unsectioned, exactly like the
- * TUI popup (flat list, no headers).
- */
-import {
-  createCommandsCompletionProvider,
-  mergeSuggestions,
-  type Command,
-  type CompletionContext,
-  type CompletionItem,
-  type CompletionProvider,
-} from 'zidane/chat/pure';
-import type { CommandArgSuggestionSummary, CommandSummary } from 'zidane/chat';
-import type { MentionItem } from './MentionList';
-
-/** Renderer-side arg-completion forward (IPC in prod, stub in tests). */
-export type CompleteArgsFn = (name: string, argsPrefix: string) => Promise<CommandArgSuggestionSummary[]>;
-
-export interface SlashSuggestSource {
-  suggest: (query: string, ctx: CompletionContext) => Promise<MentionItem[]>;
-}
-
-/**
- * Project an IPC `CommandSummary` onto the canonical `Command` shape the
- * provider scores against. `run`/`steps` stay absent — the renderer never
- * executes commands (both are optional on the canonical type). The
- * `completeArgs` shim is only attached when the main process reported the
- * command actually completes, so `/name <prefix>` on a completion-less
- * command short-circuits to `[]` inside the provider without IPC.
- */
-export function summaryToCommand(summary: CommandSummary, completeArgs: CompleteArgsFn): Command {
-  return {
-    name: summary.name,
-    description: summary.description,
-    ...(summary.aliases?.length ? { aliases: summary.aliases } : {}),
-    ...(summary.group ? { group: summary.group } : {}),
-    ...(summary.hasArgCompletion
-      ? { completeArgs: (argsPrefix: string) => completeArgs(summary.name, argsPrefix) }
-      : {}),
-  };
-}
-
-export function createSlashSuggestSource(opts: {
-  /** Live catalog — re-read per keystroke so folder switches take effect. */
-  getCommandSummaries: () => readonly CommandSummary[];
-
-  /** The host's canonical skills provider (already built by the Chatbox). */
-  skillsProvider: CompletionProvider<unknown>;
-  completeArgs: CompleteArgsFn;
-
-  /** Per-PROVIDER cap (not global) so both sections stay represented. */
-  limit?: number;
-}): SlashSuggestSource {
-  /*
-   * Identity-memoized shims: the canonical provider caches its fzf
-   * instance in a WeakMap keyed on the catalog ARRAY identity, so the
-   * shim array must stay stable until the summaries array itself swaps
-   * (folder switch / catalog refresh). Rebuilding per keystroke would
-   * rebuild fzf's match structures every character.
-   */
-  let lastSummaries: readonly CommandSummary[] | null = null;
-  let lastShims: Command[] = [];
-
-  const shims = (): readonly Command[] => {
-    const summaries = opts.getCommandSummaries();
-
-    if (summaries !== lastSummaries) {
-      lastSummaries = summaries;
-      lastShims = summaries.map((summary) => summaryToCommand(summary, opts.completeArgs));
-    }
-
-    return lastShims;
-  };
-
-  const commandsProvider = createCommandsCompletionProvider({ getCommands: shims }) as CompletionProvider<unknown>;
-  const limit = opts.limit ?? 8;
-
-  return {
-    async suggest(query, ctx) {
-      const signal = new AbortController().signal;
-      const argMode = /\s/.test(query);
-      // Mirrors `findActiveTriggers`: a spaced query consults only
-      // space-tolerant providers — commands opt in, skills don't.
-      const providers = argMode ? [commandsProvider] : [commandsProvider, opts.skillsProvider];
-
-      /*
-       * allSettled, not all — same rationale as `useCompletion`: one
-       * provider's rejection (a failed arg-completion IPC) must not
-       * blank its sibling's results.
-       */
-      const settled = await Promise.allSettled(
-        providers.map(async (provider) => ({ provider, items: await provider.suggest(query, ctx, signal) })),
-      );
-      const groups = settled.flatMap((result) =>
-        result.status === 'fulfilled'
-          ? [{ provider: result.value.provider, items: result.value.items.slice(0, limit) }]
-          : [],
-      );
-
-      return mergeSuggestions(groups, providers.length).map((item) => toMentionItem(item, argMode));
-    },
-  };
-}
-
-/**
- * Canonical `CompletionItem` → TipTap `MentionItem`. Commands (and their
- * argument suggestions) carry `kind` + `insertText` so the Chatbox's
- * suggestion `command` handler inserts plain text; skills stay kind-less
- * and keep their atomic mention-node insert.
- *
- * In arg mode `mergeSuggestions` ran with a single group, so `providerId`
- * is unstamped — but every arg-mode item IS a command item by construction.
- */
-function toMentionItem(item: CompletionItem<unknown>, argMode: boolean): MentionItem {
-  const isCommand = argMode || item.providerId === 'commands';
-
-  return {
-    id: item.id,
-    label: item.label,
-    ...(item.description !== undefined ? { description: item.description } : {}),
-    ...(item.section !== undefined ? { section: item.section } : {}),
-    ...(isCommand
-      ? { kind: argMode ? ('command-arg' as const) : ('command' as const), insertText: item.insertText }
-      : {}),
-  };
-}

package/src/chat/rich-composer/use-composer-bus.ts

@@ -1,57 +0,0 @@
-/**
- * The window's composer on the composer bus (`composer-bus.ts`): it receives
- * its conversation's scope (producers for that scope are enabled while it is
- * mounted), takes the pushes aimed at that scope, and the ones aimed at no
- * composer in particular.
- */
-import { useEffect, useLayoutEffect, useRef } from 'react';
-
-import type { ComposerAttachment as ChatAttachment } from '../headless/composer/host';
-import {
-  claimComposerFocus,
-  onComposerAttachment,
-  onComposerDraft,
-  onComposerFocus,
-  onComposerInsert,
-  onComposerMention,
-  onComposerPrompt,
-  registerComposerScope,
-  type ComposerDraft,
-} from '../composer/composer-bus';
-
-export interface ComposerBusHandlers {
-  attachment(attachment: ChatAttachment): void;
-  /** An `@<path>` mention at the caret. */
-  mention(path: string): void;
-  /** Plain text at the end of the draft. */
-  insert(text: string): void;
-  focus(): void;
-  /** Sent as is, beside the draft. */
-  prompt(text: string): void;
-  /** The draft replaced. */
-  draft(draft: ComposerDraft): void;
-}
-
-export function useComposerBus(key: string | null, handlers: ComposerBusHandlers): void {
-  const latest = useRef(handlers);
-  useLayoutEffect(() => {
-    latest.current = handlers;
-  });
-
-  useEffect(() => registerComposerScope(key), [key]);
-  // At commit, before a push queued with a conversation switch dispatches.
-  useLayoutEffect(() => claimComposerFocus(key), [key]);
-  useEffect(() => {
-    const offs = [
-      onComposerAttachment(key, (attachment) => latest.current.attachment(attachment)),
-      onComposerMention(key, (path) => latest.current.mention(path)),
-      onComposerInsert(key, (text) => latest.current.insert(text)),
-      onComposerFocus(key, () => latest.current.focus()),
-      onComposerPrompt(key, (text) => latest.current.prompt(text)),
-      onComposerDraft(key, (draft) => latest.current.draft(draft)),
-    ];
-    return () => {
-      for (const off of offs) off();
-    };
-  }, [key]);
-}