zidane-ui 9.1.1 → 9.1.4

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

@@ -1,216 +0,0 @@
-/**
- * The composer's TipTap editor: a plain-text StarterKit, the `@` `/` `#` and
- * extension mention popovers, the keys (prompt modes, ghost text, send,
- * history) and paste/drop folding. Built once per `disabled` / extension
- * providers / folder; its callbacks read the Chatbox's live values through
- * `latest` (current as of the last commit) and share its mutable composer
- * state through the refs it passes.
- */
-import { useEditor, type Editor } from '@tiptap/react';
-import { useLayoutEffect, useMemo, useRef, type RefObject } from 'react';
-import {
-  type ChatReferenceScope,
-  type InlineGhost,
-  createChatsCompletionProvider,
-  createFilesCompletionProvider,
-  createSkillsCompletionProvider,
-} from 'zidane/chat/pure';
-
-import { formatPathForCwd } from '../../path';
-import { useComposerHost, useComposerLabels } from '../composer/ComposerHostProvider';
-import type { usePromptHistory } from '../composer/PromptHistoryProvider';
-import type { ComposerMode } from '../headless/composer-modes';
-import type { ComposerCommandArgs, ComposerExtensionProvider } from '../headless/composer/host';
-import { composerExtensions, MAX_RESULTS } from './composer-extensions';
-import { composerEditorProps } from './composer-keys';
-import { debouncedCompleteArgs, type PopoverGate } from './mention-popover';
-import { createSlashSuggestSource } from './slash-completion';
-import type { ComposerSources } from './use-composer-sources';
-import { useEditorHandover } from './use-editor-handover';
-import type { PromptGhost } from './use-prompt-ghost';
-
-/** What {@link useComposerEditor} builds the editor from. */
-export interface ComposerEditorOptions {
-  /** No folder picked: read-only, with its own placeholder. Rebuilds the editor. */
-  disabled: boolean;
-  /** Rebuilds the editor (extension popovers complete against it). */
-  folderPath: string | null;
-  /** Each completion provider is a popover trigger. Rebuilds the editor. */
-  extensionCompletionProviders: readonly ComposerExtensionProvider[];
-  sources: ComposerSources;
-  skillsProvider: ReturnType<typeof createSkillsCompletionProvider>;
-  mentionPopovers: PopoverGate;
-  promptGhost: PromptGhost;
-  /** The live editor (the one this hook returns, once pinned). */
-  editorRef: RefObject<Editor | null>;
-  modeRef: RefObject<ComposerMode>;
-  /** The inline ghost on display. */
-  ghostRef: RefObject<InlineGhost | null>;
-  /** True while a history recall's own transactions run (no ghost for them). */
-  historyRecallRef: RefObject<boolean>;
-  /** Re-evaluate the ghost after a gate input flipped without an edit. */
-  ghostGateChangedRef: RefObject<() => void>;
-  attachmentsEnabled: boolean;
-  history: ReturnType<typeof usePromptHistory>;
-  activeSessionId: string | null;
-  hostId: string | null;
-  send(): void;
-  onSearchNavigate: ((direction: 1 | -1) => void) | undefined;
-  applyMode(next: ComposerMode): void;
-  applyGhost(next: InlineGhost | null): void;
-  addFiles(files: File[]): void;
-  setHistoryStatus(status: { position: number; total: number } | null): void;
-  /** The commands' fixed argument values (what the `/` popover learns, the command badge shows). */
-  commandArgs: ComposerCommandArgs | undefined;
-}
-
-export function useComposerEditor(options: ComposerEditorOptions): Editor | null {
-  const {
-    disabled,
-    folderPath,
-    extensionCompletionProviders,
-    sources,
-    skillsProvider,
-    mentionPopovers,
-    promptGhost,
-    modeRef,
-    ghostGateChangedRef,
-  } = options;
-  const completions = useComposerHost().completions;
-  const labels = useComposerLabels();
-  const latest = useRef(options);
-  useLayoutEffect(() => {
-    latest.current = options;
-  });
-  // Nothing renders it: the `#` popover reads and toggles it in place.
-  const chatScopeRef = useRef<ChatReferenceScope>('project');
-
-  /*
-   * Build the canonical providers once. `getCatalog` reads the sources and
-   * `formatPath` the folder each call, so a folder switch takes effect
-   * immediately without rebuilding either provider. Identity stability
-   * matters: `parseReferences` invokes `formatPath` per catalog entry on
-   * every keystroke. Paths format against `checkoutRoot` (the working tree
-   * the catalog lists); until the location resolves they stay as listed.
-   */
-  const filesProvider = useMemo(
-    () =>
-      // eslint-disable-next-line react-hooks/refs -- read by the callbacks it builds, not during render
-      createFilesCompletionProvider({
-        getCatalog: () => sources.files.peek(),
-        limit: MAX_RESULTS * 4,
-        formatPath: (entry) => {
-          const cwd = latest.current.folderPath;
-          const root = sources.location()?.checkoutRoot;
-
-          if (!cwd || !root) {
-            return entry.path;
-          }
-
-          return formatPathForCwd(entry.path, root, cwd);
-        },
-      }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- stable handles (refs, built-once sources and host); the effect keys on what it re-runs for
-    [],
-  );
-
-  /*
-   * Canonical `/` popover source — commands through the canonical
-   * `createCommandsCompletionProvider` (rank ladder, group match, alias
-   * display, async arg completion) merged with the skills provider via
-   * `mergeSuggestions`, mirroring the TUI. Arg completion routes through
-   * `debouncedCompleteArgs` — the ONE debounce/stale-drop mechanism —
-   * inside the provider's own async path.
-   */
-  const slashSource = useMemo(
-    () =>
-      // eslint-disable-next-line react-hooks/refs -- read by the callbacks it builds, not during render
-      createSlashSuggestSource({
-        getCommandSummaries: () => sources.commands.peek(),
-        skillsProvider,
-        completeArgs: async (name, argsPrefix) => {
-          const cwd = latest.current.folderPath;
-          if (!cwd) return [];
-          const found = await debouncedCompleteArgs(
-            completions?.commandArgs,
-            cwd,
-            name,
-            argsPrefix,
-            latest.current.hostId,
-          );
-          // What the popover learns, the composer's command badge uses (`/fix conflicts`).
-          latest.current.commandArgs?.note(
-            { cwd, hostId: latest.current.hostId },
-            name,
-            found.map((s) => s.value),
-          );
-          return found;
-        },
-        limit: MAX_RESULTS,
-      }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- stable handles (refs, built-once sources and host); the effect keys on what it re-runs for
-    [completions, skillsProvider],
-  );
-
-  const chatsProvider = useMemo(
-    () =>
-      // eslint-disable-next-line react-hooks/refs -- read by the callbacks it builds, not during render
-      createChatsCompletionProvider({
-        getCatalog: () => {
-          const currentId = latest.current.activeSessionId;
-          const root = sources.location()?.projectRoot;
-          return sources.chats.peek().filter((entry) => {
-            if (entry.id === currentId) {
-              return false;
-            }
-
-            if (chatScopeRef.current === 'project') {
-              return root ? entry.projectRoot === root : false;
-            }
-
-            return true;
-          });
-        },
-        getReferenceCatalog: () => {
-          const currentId = latest.current.activeSessionId;
-          const chats = sources.chats.peek();
-          return currentId ? chats.filter((entry) => entry.id !== currentId) : chats;
-        },
-        getScope: () => chatScopeRef.current,
-        limit: MAX_RESULTS * 4,
-      }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- stable handles (refs, built-once sources and host); the effect keys on what it re-runs for
-    [],
-  );
-
-  const editor = useEditor(
-    {
-      // TipTap's own choice, said out loud: render at once in a browser, not while server rendering (no warning per render).
-      immediatelyRender: typeof document !== 'undefined',
-      // eslint-disable-next-line react-hooks/refs -- read by the callbacks it builds, not during render
-      extensions: composerExtensions({
-        disabled,
-        folderPath,
-        extensionCompletionProviders,
-        extensionItems: completions?.extensionItems,
-        sources,
-        filesProvider,
-        slashSource,
-        chatsProvider,
-        chatScopeRef,
-        mentionPopovers,
-        promptGhost,
-        modeRef,
-        ghostGateChangedRef,
-        labels,
-      }),
-      editable: !disabled,
-      // eslint-disable-next-line react-hooks/refs -- read by the callbacks it builds, not during render
-      editorProps: composerEditorProps(latest, labels.composerLabel),
-    },
-    [disabled, extensionCompletionProviders, folderPath],
-  );
-  // A rebuild must not drop the draft or the focus of someone typing.
-  useEditorHandover(editor);
-  return editor;
-}

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

@@ -1,90 +0,0 @@
-/**
- * The composer's completion sources for its folder and server
- * (`composer-sources.ts`, over `ComposerHost.completions`): the lazily read
- * lists, the subscribed skills and extension completion providers, and the
- * folder's roots. One stable handle for the editor's callbacks (built once,
- * read per call); the providers are state, since the editor's extensions are
- * built from them.
- */
-import { useEffect, useState } from 'react';
-
-import { useComposerHost } from '../composer/ComposerHostProvider';
-import { createComposerLists, type ComposerLists } from '../headless/composer/composer-sources';
-import type { ComposerExtensionProvider, ComposerFolderLocation, SkillConfig } from '../headless/composer/host';
-
-/** What the editor reads its completions from. */
-export interface ComposerSources extends Omit<ComposerLists, 'setScope'> {
-  /** The enabled skills (subscribed). */
-  skills(): readonly SkillConfig[];
-  /** The folder's checkout and project roots, once resolved (this computer only). */
-  location(): ComposerFolderLocation | null;
-}
-
-const NOOP = () => undefined;
-
-/**
- * `folderPath`: `''` is a folderless session (catalogs root at HOME, like the
- * TUI launched from `~`); `null` (no folder picked yet) reads nothing.
- * `onCatalog` (stable): the commands or skills changed, so typed `/name`
- * badges are re-read.
- */
-export function useComposerSources(
-  folderPath: string | null,
-  fileRoot: string | null,
-  hostId: string | null,
-  onCatalog: () => void,
-): { sources: ComposerSources; providers: readonly ComposerExtensionProvider[] } {
-  const completions = useComposerHost().completions;
-  const [state] = useState(() => {
-    const lists = createComposerLists(completions, onCatalog);
-    const held = { skills: [] as readonly SkillConfig[], location: null as ComposerFolderLocation | null };
-    const sources: ComposerSources = {
-      files: lists.files,
-      commands: lists.commands,
-      chats: lists.chats,
-      skills: () => held.skills,
-      location: () => held.location,
-    };
-    return { lists, held, sources };
-  });
-  const [providers, setProviders] = useState<readonly ComposerExtensionProvider[]>([]);
-
-  useEffect(() => {
-    const { lists, held } = state;
-    lists.setScope(folderPath === null ? null : { folderPath, fileRoot, hostId });
-    // eslint-disable-next-line react-hooks/immutability -- the built-once holder the callbacks read, written after commit
-    held.skills = [];
-    held.location = null;
-    if (folderPath === null) {
-      // eslint-disable-next-line react-hooks/set-state-in-effect -- resets with the scope it keys on
-      setProviders([]);
-      return undefined;
-    }
-    let cancelled = false;
-    // A worktree's `@` lists the project's files too; a server's folder has no local roots.
-    if (!hostId && completions?.locationOf) {
-      void completions.locationOf(folderPath).then(
-        (location) => {
-          if (!cancelled) held.location = location;
-        },
-        (err: unknown) => console.warn("[composer] couldn't resolve the folder's roots", err),
-      );
-    }
-    const scope = { cwd: folderPath, hostId };
-    const offSkills =
-      completions?.watchSkills?.(scope, (data) => {
-        if (data === held.skills) return;
-        held.skills = data;
-        onCatalog();
-      }) ?? NOOP;
-    const offProviders = completions?.watchExtensionProviders?.(scope, setProviders) ?? NOOP;
-    return () => {
-      cancelled = true;
-      offSkills();
-      offProviders();
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- stable handles (refs, built-once sources and host); the effect keys on what it re-runs for
-  }, [state, completions, folderPath, fileRoot, hostId]);
-
-  return { sources: state.sources, providers };
-}