zidane-ui 9.1.1 → 9.1.3

package/src/chat/rich-composer/composer-keys.ts

@@ -1,416 +0,0 @@
-/**
- * The rich composer's editor props: the input's attributes, pasted-HTML
- * cleanup, the keymap (send, prompt modes, ghost text, ↑/↓ history, popover
- * keys) and paste / drop into attachments. Built from the composer's live
- * options (`latest`), read per event.
- */
-import type { EditorOptions } from '@tiptap/core';
-import { Selection } from '@tiptap/pm/state';
-
-import { isCaretAtEnd, isCaretAtStart, plainTextToDocJson } from '../composer/prompt-history-nav';
-import { pastedTextFilename, shouldFoldPasteToAttachment } from '../composer/attachment-ingest';
-import {
-  caretEffectivelyAtStart,
-  decodeHistoryEntry,
-  encodeHistoryDraft,
-  exitsModeOnKey,
-  modeForTypedChar,
-} from '../headless/composer-modes';
-import { draftWireText } from '../headless/composer/draft-sync';
-import type { JsonNode } from '../headless/composer/editor-markdown';
-import { ghostKeyAction } from '../headless/composer/ghost-autocomplete';
-import { plainTextWithCursor } from './ghost-plugin';
-import type { ComposerEditorOptions } from './use-composer-editor';
-
-/**
- * The editor's props over the composer's live options.
- *
- * @param latest - The composer's options as of the last commit.
- * @param name - The textbox's accessible name.
- */
-export function composerEditorProps(
-  latest: { readonly current: ComposerEditorOptions },
-  name: string,
-): EditorOptions['editorProps'] {
-  // Stable for the composer's lifetime (refs and handles built once).
-  const { editorRef, modeRef, ghostRef, historyRecallRef, ghostGateChangedRef, mentionPopovers, promptGhost } =
-    latest.current;
-  const liveEditor = () => {
-    const ed = editorRef.current;
-    return ed && !ed.isDestroyed ? ed : null;
-  };
-  return {
-    attributes: {
-      /*
-       * `overflow-clip`, not `hidden`: a hidden box still scrolls from
-       * code, and with the line trim (rich-composer.css `.ProseMirror p`) a
-       * caret before a leading badge measures the full untrimmed line,
-       * so revealing it scrolled the text 4px. Long prompts scroll in
-       * the outer `.zg-editor-scroll`.
-       */
-      class: 'block w-full bg-transparent text-[var(--zg-text)] text-sm focus:outline-none leading-6 overflow-clip',
-      'aria-label': name,
-    },
-    /*
-     * Strip every formatting tag the browser might emit on paste —
-     * `<b>`, `<strong>`, `<i>`, `<em>`, `<s>`, `<strike>`, `<del>`,
-     * `<u>`, `<code>` — so rich-text sources (Google Docs, web
-     * pages) land as flat text even if a future StarterKit option
-     * change accidentally re-enables a mark. Cheap regex pass; the
-     * input is already a small fragment by the time ProseMirror
-     * calls us. We also unwrap inline `style` attributes that
-     * would otherwise be parsed for `font-weight: bold` / `font-
-     * style: italic` by ProseMirror's DOM parser.
-     */
-    transformPastedHTML(html) {
-      return html
-        .replace(/<\/?(b|strong|i|em|s|strike|del|u|code|mark)\b[^>]*>/gi, '')
-        .replace(/\sstyle="[^"]*"/gi, '');
-    },
-    handleKeyDown(view, event) {
-      /*
-       * ---- Composer prompt modes (TUI parity) --------------------
-       * Sentinel ENTRY: `!` / `?` typed as the first character of an
-       * empty composer flips the mode and CONSUMES the character
-       * (preventDefault — it never lands in the doc), mirroring the
-       * TUI's `syncBuffer` sentinel checks (`useSyncBuffer`,
-       * src/tui/prompt/use-sync-buffer.ts).
-       * Keydown-level detection is what makes this typed-only:
-       * pasted or recalled `!cmd` text never passes through here.
-       * Shift is allowed — both sentinels are shifted keys on most
-       * layouts.
-       */
-      if (!event.metaKey && !event.ctrlKey && !event.altKey) {
-        const bufferEmpty = view.state.doc.textContent.length === 0 && view.state.doc.content.size <= 2;
-        const entered = modeForTypedChar(event.key, modeRef.current, bufferEmpty);
-
-        if (entered) {
-          event.preventDefault();
-          latest.current.applyMode(entered);
-
-          return true;
-        }
-      }
-
-      /*
-       * Mode EXIT: shell leaves on Backspace with the caret at the
-       * very start (`handleShellExitKey`, buffer text kept); search
-       * leaves on Esc or Backspace/Delete-at-start
-       * (`isTranscriptSearchExitKey`; both in
-       * src/tui/prompt/prompt-key-handlers.ts) and
-       * discards the query — the TUI restores the pre-search draft,
-       * which is always empty here since `?` only fires on an empty
-       * composer.
-       */
-      if (modeRef.current !== 'normal' && !event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey) {
-        const caretAtStart = caretEffectivelyAtStart(
-          view.state.selection,
-          Selection.atStart(view.state.doc).from,
-          view.state.doc.textContent.length === 0,
-        );
-
-        if (exitsModeOnKey(modeRef.current, event.key, caretAtStart)) {
-          event.preventDefault();
-
-          if (event.key === 'Escape') {
-            // Esc must not ALSO reach window-level consumers (⌘F
-            // overlay close, future global Esc handlers).
-            event.stopPropagation();
-          }
-
-          if (modeRef.current === 'search') {
-            queueMicrotask(() => liveEditor()?.commands.clearContent(true));
-          }
-
-          latest.current.applyMode('normal');
-
-          return true;
-        }
-      }
-
-      /*
-       * Search-mode match navigation: Enter / ↓ hop forward,
-       * Shift+Enter / ↑ hop back. (The TUI's Enter opens the
-       * selected turn's details modal — the GUI transcript has no
-       * turn-details surface, so Enter maps to next-match, matching
-       * the ⌘F overlay's grammar.) Everything below — send, history
-       * cycling — is unreachable while searching, mirroring the
-       * TUI's early return (`handleSearchModeKey`,
-       * src/tui/prompt/prompt-key-handlers.ts).
-       */
-      if (modeRef.current === 'search') {
-        if (event.key === 'Enter' && !event.metaKey && !event.ctrlKey && !event.altKey) {
-          event.preventDefault();
-          latest.current.onSearchNavigate?.(event.shiftKey ? -1 : 1);
-
-          return true;
-        }
-
-        if (
-          (event.key === 'ArrowUp' || event.key === 'ArrowDown') &&
-          !event.metaKey &&
-          !event.ctrlKey &&
-          !event.altKey &&
-          !event.shiftKey
-        ) {
-          event.preventDefault();
-          latest.current.onSearchNavigate?.(event.key === 'ArrowUp' ? -1 : 1);
-
-          return true;
-        }
-
-        return false;
-      }
-
-      /*
-       * ---- Inline ghost accept/rotate/dismiss (TUI parity) -------
-       * Mirrors `handleInlineGhostKey`
-       * (src/tui/prompt/prompt-key-handlers.ts), and runs BEFORE the Enter and
-       * history branches so ↑/↓ rotation on a multi-candidate ghost
-       * wins over history cycling (TUI consumes rotation first). The
-       * ghost is null whenever the mention/slash popover is open or a
-       * prompt mode is active (query gate), so this branch never
-       * steals their keys. Tab-accept re-checks the buffer snapshot
-       * inside `ghostKeyAction` — a stale ghost can never insert.
-       */
-      if (ghostRef.current && !event.isComposing) {
-        const action = ghostKeyAction(ghostRef.current, event, plainTextWithCursor(view.state), {
-          prompt: promptGhost.painted() !== null,
-        });
-
-        if (action.type === 'accept') {
-          event.preventDefault();
-          view.dispatch(view.state.tr.insertText(action.insert));
-          latest.current.applyGhost(null);
-
-          return true;
-        }
-
-        if (action.type === 'rotate') {
-          event.preventDefault();
-          latest.current.applyGhost({ ...ghostRef.current, index: action.index });
-
-          return true;
-        }
-
-        if (action.type === 'dismiss') {
-          if (action.forSuggestion) {
-            promptGhost.dismissPainted();
-          }
-
-          // Dismiss WITHOUT consuming — Esc keeps its other meanings
-          // and movement keys still move the caret (TUI `handleInlineGhostKey`).
-          latest.current.applyGhost(null);
-
-          if (action.consume) {
-            event.preventDefault();
-
-            return true;
-          }
-        }
-      }
-
-      if (event.key === 'Enter' && !mentionPopovers.open) {
-        event.preventDefault();
-        if (event.shiftKey) {
-          // Shift+Enter = new line: a new paragraph (one `\n` on the wire).
-          editorRef.current?.chain().focus().splitBlock().run();
-        } else {
-          // Enter = send.
-          latest.current.send();
-        }
-
-        return true;
-      }
-
-      /*
-       * History cycling: ↑ recalls only with the caret on the very first
-       * position of the buffer, ↓ advances only from the very last one
-       * (`prompt-history-nav.ts`). Anywhere else the arrows move the
-       * caret as usual, so a multi-line draft still navigates naturally. The
-       * provider stashes the in-progress draft on the first ↑ and
-       * restores it when ↓ steps past the newest entry. No-op while
-       * the mention popover owns the arrow keys.
-       */
-      if (
-        (event.key === 'ArrowUp' || event.key === 'ArrowDown') &&
-        !event.shiftKey &&
-        !event.metaKey &&
-        !event.ctrlKey &&
-        !event.altKey &&
-        !mentionPopovers.open
-      ) {
-        const sessionId = latest.current.activeSessionId;
-
-        if (!sessionId) {
-          return false;
-        }
-
-        const direction = event.key === 'ArrowUp' ? 'up' : 'down';
-        const atEdge = direction === 'up' ? isCaretAtStart(view.state) : isCaretAtEnd(view.state);
-
-        if (!atEdge) {
-          return false;
-        }
-
-        /*
-         * The draft is stashed through the same markdown serializer
-         * as submit, so mentions and code fences survive the
-         * stash-restore round trip as text (a plain `textBetween`
-         * would silently drop mention nodes).
-         */
-        /*
-         * A shell-mode draft round-trips through the same `!`-prefix
-         * encoding as persisted history entries (TUI `usePromptHistory`,
-         * src/tui/prompt/use-prompt-history.ts), and recalled `!cmd`
-         * entries re-enter shell mode with the bang stripped
-         * (`applyRecalledPrompt`, same file).
-         */
-        // The wire form: one `\n` per line, without the serializer's trailing gap (it restored as an extra empty line).
-        const serialized = editorRef.current ? draftWireText(editorRef.current.getJSON() as JsonNode) : '';
-        const current = encodeHistoryDraft(modeRef.current, serialized);
-        const next = latest.current.history.cycle(sessionId, direction, current);
-
-        if (next !== null) {
-          event.preventDefault();
-
-          /*
-           * Swap the document via TipTap's `setContent` command rather
-           * than a raw `tr.delete(...)` — the raw transaction can leave
-           * the doc empty, violating the `block+` schema and either
-           * silently dropping the change or throwing on `dispatch`.
-           * The recalled text goes through `plainTextToDocJson` so
-           * multi-line entries keep their line structure instead of
-           * being fed to TipTap's HTML parser. We schedule it on a
-           * microtask so it runs after ProseMirror finishes processing
-           * this keydown (otherwise we'd dispatch inside the active
-           * transaction and risk reentrancy).
-           */
-          const recalled = decodeHistoryEntry(next);
-          latest.current.applyMode(recalled.mode);
-
-          const editor = editorRef.current;
-
-          if (editor) {
-            queueMicrotask(() => {
-              /*
-               * Ghost suppression while the recall's own transactions
-               * run — browsing history must not pop ghost suggestions
-               * for text the user didn't type. Editing the recalled
-               * draft afterwards re-queries normally.
-               */
-              historyRecallRef.current = true;
-
-              try {
-                editor.commands.setContent(plainTextToDocJson(recalled.text), { emitUpdate: true });
-
-                /*
-                 * Direction-aware caret parking (mirrors the TUI's
-                 * `applyRecalledPrompt`): browsing back lands the caret
-                 * at the START so the next ↑ keeps cycling; browsing
-                 * forward lands it at the END so the next ↓ does.
-                 */
-                editor.commands.focus(direction === 'up' ? 'start' : 'end');
-              } finally {
-                historyRecallRef.current = false;
-              }
-
-              /*
-               * The recall flag is a gate input that just reopened
-               * without a further edit — re-evaluate so the recalled
-               * draft ghosts exactly where the TUI does: ↓-recall
-               * parks the caret at the END (word boundary → query),
-               * ↑-recall at the START (mid-word → no ghost).
-               */
-              ghostGateChangedRef.current();
-            });
-          }
-
-          latest.current.setHistoryStatus(latest.current.history.status(sessionId));
-
-          return true;
-        }
-      }
-
-      return false;
-    },
-    handlePaste(_view, event) {
-      // Pasted rich text (a web page, a doc) lands as its plain text: a
-      // pasted list keeps its "- " characters instead of turning into
-      // structure the composer no longer has.
-      const insertPlain = (): boolean => {
-        const plain = event.clipboardData?.getData('text/plain') ?? '';
-        const ed = editorRef.current;
-        if (!plain || !ed) return false;
-        event.preventDefault();
-        const lines = plain.replace(/\r\n?/g, '\n').split('\n');
-        ed.chain()
-          .focus()
-          .insertContent(
-            lines.length === 1
-              ? plain
-              : lines.map((line) => ({
-                  type: 'paragraph',
-                  ...(line ? { content: [{ type: 'text', text: line }] } : {}),
-                })),
-          )
-          .run();
-        return true;
-      };
-
-      if (!latest.current.attachmentsEnabled) {
-        return insertPlain();
-      }
-
-      const items = Array.from(event.clipboardData?.items ?? []);
-
-      // A screenshot, or files copied in Finder: attachments, whatever their type (`readAttachment` decides).
-      const pastedFiles = items
-        .filter((item) => item.kind === 'file')
-        .map((item) => item.getAsFile())
-        .filter((file): file is File => file !== null);
-
-      if (pastedFiles.length > 0) {
-        event.preventDefault();
-        latest.current.addFiles(pastedFiles);
-
-        return true;
-      }
-
-      /*
-       * Long plain-text paste → file attachment. The model receives
-       * the blob as a discrete document part instead of an inline
-       * wall of text, and the editor stays scannable. Threshold is
-       * TUI parity — >10 lines folds (`planTextPaste`, src/tui/prompt/paste.ts)
-       * — plus a GUI-only char ceiling for giant one-liners; see
-       * `shouldFoldPasteToAttachment`. Shorter pastes inline as plain text.
-       */
-      const text = event.clipboardData?.getData('text/plain') ?? '';
-
-      if (text.length > 0 && shouldFoldPasteToAttachment(text)) {
-        event.preventDefault();
-
-        const file = new File([text], pastedTextFilename(), { type: 'text/plain' });
-        latest.current.addFiles([file]);
-
-        return true;
-      }
-
-      return insertPlain();
-    },
-    handleDrop(_view, event) {
-      if (!latest.current.attachmentsEnabled) {
-        return false;
-      }
-
-      // Files land as attachments through the card's drop handler (the event bubbles there), never as editor content.
-      if (!(event as DragEvent).dataTransfer?.files.length) {
-        return false;
-      }
-
-      event.preventDefault();
-
-      return true;
-    },
-  };
-}

package/src/chat/rich-composer/ghost-plugin.ts

@@ -1,89 +0,0 @@
-/**
- * The ghost text's ProseMirror side: the decoration plugin that paints the
- * suggestion after the caret, and the editor's plain text + caret mapping the
- * provider reads. The state machine is `zidane-ui/chat/headless`
- * (`ghost-autocomplete.ts`).
- */
-import type { EditorState } from '@tiptap/pm/state';
-import { Plugin, PluginKey } from '@tiptap/pm/state';
-import { Decoration, DecorationSet } from '@tiptap/pm/view';
-
-/**
- * Plain-text buffer + caret offset for the provider context. Both fields
- * come from the SAME `textBetween` mapping (`\n` block separator, leaf
- * nodes — mentions — contribute nothing), so the offsets always align
- * even when the doc holds mention chips. This deliberately differs from
- * `getText()` (which serializes mentions via their `renderText`): the
- * ghost completes the whitespace-delimited token ENDING at the caret, so
- * a consistent text/cursor pair matters more than mention fidelity.
- */
-export function plainTextWithCursor(state: EditorState): { text: string; cursor: number } {
-  const doc = state.doc;
-
-  return {
-    text: doc.textBetween(0, doc.content.size, '\n'),
-    cursor: doc.textBetween(0, state.selection.from, '\n').length,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// ProseMirror decoration plugin
-// ---------------------------------------------------------------------------
-
-/**
- * Plugin state is just the display string (or null). The host pushes it
- * via `setMeta` after reconciling its `InlineGhost` snapshot; any doc
- * change WITHOUT an accompanying meta clears the decoration — the host's
- * transaction listener re-derives and re-pushes within the same JS turn
- * (before paint), so per-keystroke reconciliation stays blink-free.
- */
-export const ghostTextPluginKey = new PluginKey<string | null>('zg-ghost-text');
-
-export function createGhostTextPlugin(): Plugin<string | null> {
-  return new Plugin<string | null>({
-    key: ghostTextPluginKey,
-    state: {
-      init: () => null,
-      apply(tr, prev) {
-        const meta = tr.getMeta(ghostTextPluginKey) as string | null | undefined;
-
-        if (meta !== undefined) {
-          return meta;
-        }
-
-        return tr.docChanged ? null : prev;
-      },
-    },
-    props: {
-      decorations(state) {
-        const text = ghostTextPluginKey.getState(state);
-
-        if (!text || !state.selection.empty) {
-          return null;
-        }
-
-        /*
-         * Widget AFTER the caret position (`side: 1`): the caret renders
-         * before the ghost, and typed text inserts before the widget —
-         * the TUI's "suffix painted right after the caret, tail pushed
-         * right" (`renderGhostOverlay`, src/tui/prompt/composer-parts.tsx)
-         * falls out of normal inline flow.
-         */
-        const widget = Decoration.widget(
-          state.selection.head,
-          () => {
-            const span = document.createElement('span');
-            span.className = 'zg-ghost-suffix';
-            span.setAttribute('aria-hidden', 'true');
-            span.textContent = text;
-
-            return span;
-          },
-          { side: 1, key: `zg-ghost:${text}` },
-        );
-
-        return DecorationSet.create(state.doc, [widget]);
-      },
-    },
-  });
-}

package/src/chat/rich-composer/index.ts

@@ -1,3 +0,0 @@
-/** `zidane-ui/chat/rich-composer`: the desktop app's Tiptap composer (mentions, commands, ghost text, shared drafts, prompt history). Its own entry, so an app that does not render it never loads it. */
-export { RichComposer, type RichComposerProps } from './RichComposer';
-export { PlusButton, SendStopButton, type PlusButtonProps, type SendStopButtonProps } from './composer-controls';