@adecore/agents-react 0.31.12 → 0.33.0

package/dist/chat/ui/composer/key-handler.js

@@ -5,146 +5,199 @@ import { STASH_SHORTCUT } from '../../stash.js';
 import { pageTimeline } from '../../timeline-scroll.js';
 import { enterAction, inCode, inFenceBody, inOpenFence, listItemAt, recallDirection, tabSpaces } from './keys.js';
 const SEND_HOW = {
-    send: 'default',
-    'send-alternate': 'alternate',
-    'send-and-new': 'and-new'
+  send: 'default',
+  'send-alternate': 'alternate',
+  'send-and-new': 'and-new'
 };
 /* In a fence Tab indents like a code editor; anywhere else it keeps moving the focus. */
 function indentInFence(e, view) {
-    const { state } = view;
-    const { from, to, head } = state.selection.main;
-    const tree = ensureSyntaxTree(state, state.doc.length, 50) ?? syntaxTree(state);
-    if (!inFenceBody(tree, state.doc.toString(), head)) {
-        return false;
+  const {
+    state
+  } = view;
+  const {
+    from,
+    to,
+    head
+  } = state.selection.main;
+  const tree = ensureSyntaxTree(state, state.doc.length, 50) ?? syntaxTree(state);
+  if (!inFenceBody(tree, state.doc.toString(), head)) {
+    return false;
+  }
+  // Handled even when there is nothing to outdent, so Shift+Tab never throws the focus out of a block.
+  if (e.shiftKey) {
+    indentLess(view);
+  } else if (from !== to) {
+    indentMore(view);
+  } else {
+    view.dispatch(state.replaceSelection(tabSpaces(head - state.doc.lineAt(head).from)), {
+      scrollIntoView: true,
+      userEvent: 'input'
+    });
+  }
+  return true;
+}
+/* The keys an open picker takes: the arrows walk it, and Tab (or Enter, outside the commands) picks. */
+function pickInMenu(e, {
+  menus,
+  setText
+}) {
+  const {
+    activeIndex
+  } = menus;
+  if (menus.commandMenuOpen) {
+    if (menus.moveInMenu(e.key, menus.commands.length)) {
+      return true;
     }
-    // Handled even when there is nothing to outdent, so Shift+Tab never throws the focus out of a block.
-    if (e.shiftKey) {
-        indentLess(view);
+    if (e.key === 'Tab') {
+      const chosen = menus.commands[activeIndex];
+      if (chosen.skill) {
+        menus.chooseSkill(chosen.name);
+      } else {
+        setText(`/${chosen.name} `);
+      }
+      return true;
     }
-    else if (from !== to) {
-        indentMore(view);
+  }
+  if (menus.skillMenuOpen) {
+    if (menus.moveInMenu(e.key, menus.skillMatches.length)) {
+      return true;
     }
-    else {
-        view.dispatch(state.replaceSelection(tabSpaces(head - state.doc.lineAt(head).from)), { scrollIntoView: true, userEvent: 'input' });
+    if (e.key === 'Tab' || e.key === 'Enter') {
+      menus.chooseSkill((menus.skillMatches[activeIndex] ?? menus.skillMatches[0]).name);
+      return true;
     }
-    return true;
-}
-/* The keys an open picker takes: the arrows walk it, and Tab (or Enter, outside the commands) picks. */
-function pickInMenu(e, { menus, setText }) {
-    const { activeIndex } = menus;
-    if (menus.commandMenuOpen) {
-        if (menus.moveInMenu(e.key, menus.commands.length)) {
-            return true;
-        }
-        if (e.key === 'Tab') {
-            const chosen = menus.commands[activeIndex];
-            if (chosen.skill) {
-                menus.chooseSkill(chosen.name);
-            }
-            else {
-                setText(`/${chosen.name} `);
-            }
-            return true;
-        }
-    }
-    if (menus.skillMenuOpen) {
-        if (menus.moveInMenu(e.key, menus.skillMatches.length)) {
-            return true;
-        }
-        if (e.key === 'Tab' || e.key === 'Enter') {
-            menus.chooseSkill((menus.skillMatches[activeIndex] ?? menus.skillMatches[0]).name);
-            return true;
-        }
+  }
+  if (menus.mentionMenuOpen && menus.mentionCount > 0) {
+    if (menus.moveInMenu(e.key, menus.mentionCount)) {
+      return true;
     }
-    if (menus.mentionMenuOpen && menus.mentionCount > 0) {
-        if (menus.moveInMenu(e.key, menus.mentionCount)) {
-            return true;
-        }
-        if (e.key === 'Tab' || e.key === 'Enter') {
-            menus.chooseMentionAt(activeIndex);
-            return true;
-        }
+    if (e.key === 'Tab' || e.key === 'Enter') {
+      menus.chooseMentionAt(activeIndex);
+      return true;
     }
-    return false;
+  }
+  return false;
 }
 /* Enter sends, adds a line, or carries a list on, by the send key and where the caret is. */
-function enter(e, view, { host, sendKey, submit }) {
-    const { state } = view;
-    const { from, to, head } = state.selection.main;
-    // Parsed to the end, since the fence that closes the block can sit after the caret.
-    const tree = ensureSyntaxTree(state, state.doc.length, 50) ?? syntaxTree(state);
-    const line = state.doc.lineAt(head);
-    const list = from === to && !inCode(tree, state.doc.toString(), head) ? listItemAt(line.text) : null;
-    const action = enterAction({ shift: e.shiftKey, mod: isModHeld(e, host.isApplePlatform()), alt: e.altKey }, {
-        inOpenFence: inOpenFence(tree, head),
-        list,
-        column: head - line.from,
-        sendKey,
-        multiline: state.doc.lines > 1,
-        startsNewChat: host.openNewChat !== null
-    });
-    if (action === 'newline') {
-        return insertNewline(view);
-    }
-    if (action === 'continue-list') {
-        if (list) {
-            view.dispatch({
-                changes: { from: head, insert: `\n${list.next}` },
-                selection: { anchor: head + 1 + list.next.length },
-                scrollIntoView: true,
-                userEvent: 'input'
-            });
-        }
-        return true;
-    }
-    if (action === 'leave-list') {
-        view.dispatch({ changes: { from: line.from, to: line.to }, selection: { anchor: line.from }, userEvent: 'delete' });
-        return true;
+function enter(e, view, {
+  host,
+  sendKey,
+  submit
+}) {
+  const {
+    state
+  } = view;
+  const {
+    from,
+    to,
+    head
+  } = state.selection.main;
+  // Parsed to the end, since the fence that closes the block can sit after the caret.
+  const tree = ensureSyntaxTree(state, state.doc.length, 50) ?? syntaxTree(state);
+  const line = state.doc.lineAt(head);
+  const list = from === to && !inCode(tree, state.doc.toString(), head) ? listItemAt(line.text) : null;
+  const action = enterAction({
+    shift: e.shiftKey,
+    mod: isModHeld(e, host.isApplePlatform()),
+    alt: e.altKey
+  }, {
+    inOpenFence: inOpenFence(tree, head),
+    list,
+    column: head - line.from,
+    sendKey,
+    multiline: state.doc.lines > 1,
+    startsNewChat: host.openNewChat !== null
+  });
+  if (action === 'newline') {
+    return insertNewline(view);
+  }
+  if (action === 'continue-list') {
+    if (list) {
+      view.dispatch({
+        changes: {
+          from: head,
+          insert: `\n${list.next}`
+        },
+        selection: {
+          anchor: head + 1 + list.next.length
+        },
+        scrollIntoView: true,
+        userEvent: 'input'
+      });
     }
-    submit(SEND_HOW[action]);
     return true;
+  }
+  if (action === 'leave-list') {
+    view.dispatch({
+      changes: {
+        from: line.from,
+        to: line.to
+      },
+      selection: {
+        anchor: line.from
+      },
+      userEvent: 'delete'
+    });
+    return true;
+  }
+  submit(SEND_HOW[action]);
+  return true;
 }
 /* Runs before the editor's own keymap; true means the key is handled and its default prevented. */
 export function composerKeyHandler(input) {
-    const { chatId, host, text, history } = input;
-    return (e, view) => {
-        input.noteKey(e);
-        // Escape leaves the node, unless it first has a recalled prompt to put back.
-        if (e.key === 'Escape' && !e.isComposing) {
-            if (!history.leave()) {
-                return false;
-            }
-            e.stopPropagation();
-            return true;
-        }
-        // The app's own shortcuts stay the app's while you type: Mod+Shift+Enter would otherwise send as well.
-        if (host.isAppShortcut(e)) {
-            return false;
-        }
-        e.stopPropagation();
-        // A key inside an IME composition belongs to the composition, Enter and the arrows included.
-        if (e.isComposing) {
-            return false;
-        }
-        // Reading back through a long answer should not mean leaving the box you are typing in.
-        if (e.key === 'PageUp' || e.key === 'PageDown') {
-            return pageTimeline(chatId, e.key === 'PageUp' ? -1 : 1);
-        }
-        if (matchesShortcut(STASH_SHORTCUT, e, host.isApplePlatform())) {
-            input.toggleStash();
-            return true;
-        }
-        if (pickInMenu(e, input)) {
-            return true;
-        }
-        if (e.key === 'Tab' && !e.altKey && !e.metaKey && !e.ctrlKey && indentInFence(e, view)) {
-            return true;
-        }
-        if (e.key === 'Enter') {
-            return enter(e, view, input);
-        }
-        const { from, to } = view.state.selection.main;
-        const direction = recallDirection({ key: e.key, text, from, to, recalled: history.recalled(text) });
-        return direction !== null && history.recall(direction);
-    };
-}
+  const {
+    chatId,
+    host,
+    text,
+    history
+  } = input;
+  return (e, view) => {
+    input.noteKey(e);
+    // Escape leaves the node, unless it first has a recalled prompt to put back.
+    if (e.key === 'Escape' && !e.isComposing) {
+      if (!history.leave()) {
+        return false;
+      }
+      e.stopPropagation();
+      return true;
+    }
+    // The app's own shortcuts stay the app's while you type: Mod+Shift+Enter would otherwise send as well.
+    if (host.isAppShortcut(e)) {
+      return false;
+    }
+    e.stopPropagation();
+    // A key inside an IME composition belongs to the composition, Enter and the arrows included.
+    if (e.isComposing) {
+      return false;
+    }
+    // Reading back through a long answer should not mean leaving the box you are typing in.
+    if (e.key === 'PageUp' || e.key === 'PageDown') {
+      return pageTimeline(chatId, e.key === 'PageUp' ? -1 : 1);
+    }
+    if (matchesShortcut(STASH_SHORTCUT, e, host.isApplePlatform())) {
+      input.toggleStash();
+      return true;
+    }
+    if (pickInMenu(e, input)) {
+      return true;
+    }
+    if (e.key === 'Tab' && !e.altKey && !e.metaKey && !e.ctrlKey && indentInFence(e, view)) {
+      return true;
+    }
+    if (e.key === 'Enter') {
+      return enter(e, view, input);
+    }
+    const {
+      from,
+      to
+    } = view.state.selection.main;
+    const direction = recallDirection({
+      key: e.key,
+      text,
+      from,
+      to,
+      recalled: history.recalled(text)
+    });
+    return direction !== null && history.recall(direction);
+  };
+}

package/dist/chat/ui/composer/keys.js

@@ -2,13 +2,17 @@ import { modSends } from '../../send-key.js';
 const LIST_ITEM = /^([ \t]*)(?:([-*+])|(\d{1,9})([.)]))([ \t]+)(\[[ xX]\](?:[ \t]+|$))?/;
 /* The list item a line starts, if it starts one. */
 export function listItemAt(line) {
-    const match = LIST_ITEM.exec(line);
-    if (match === null) {
-        return null;
-    }
-    const [prefix, indent, bullet, number, delimiter, space, task] = match;
-    const marker = bullet ?? `${Number(number) + 1}${delimiter}`;
-    return { prefix, next: `${indent}${marker}${space}${task ? '[ ] ' : ''}`, empty: line.slice(prefix.length).trim() === '' };
+  const match = LIST_ITEM.exec(line);
+  if (match === null) {
+    return null;
+  }
+  const [prefix, indent, bullet, number, delimiter, space, task] = match;
+  const marker = bullet ?? `${Number(number) + 1}${delimiter}`;
+  return {
+    prefix,
+    next: `${indent}${marker}${space}${task ? '[ ] ' : ''}`,
+    empty: line.slice(prefix.length).trim() === ''
+  };
 }
 /*
  * Enter sends, except where whoever types is still writing: inside a fence nobody has closed yet
@@ -17,59 +21,66 @@ export function listItemAt(line) {
  * is Mod+Enter, Enter adds a line instead of sending. Alt sends the other way (queue or steer), and so
  * does Mod+Shift+Enter where Mod+Enter is the send key; Mod+Alt+Enter is the send that opens a new chat.
  */
-export function enterAction(keys, { inOpenFence, list, column, sendKey = 'enter', multiline = false, startsNewChat = false }) {
-    const modOnly = modSends(sendKey, multiline);
-    if (keys.mod) {
-        if (keys.alt && startsNewChat) {
-            return 'send-and-new';
-        }
-        return keys.alt || (modOnly && keys.shift) ? 'send-alternate' : 'send';
-    }
-    if (keys.shift || inOpenFence) {
-        return 'newline';
-    }
-    if (list !== null) {
-        // A caret in front of the marker moves the item down rather than splitting its marker.
-        if (column < list.prefix.length) {
-            return 'newline';
-        }
-        return list.empty ? 'leave-list' : 'continue-list';
+export function enterAction(keys, {
+  inOpenFence,
+  list,
+  column,
+  sendKey = 'enter',
+  multiline = false,
+  startsNewChat = false
+}) {
+  const modOnly = modSends(sendKey, multiline);
+  if (keys.mod) {
+    if (keys.alt && startsNewChat) {
+      return 'send-and-new';
     }
-    if (keys.alt) {
-        return 'send-alternate';
+    return keys.alt || modOnly && keys.shift ? 'send-alternate' : 'send';
+  }
+  if (keys.shift || inOpenFence) {
+    return 'newline';
+  }
+  if (list !== null) {
+    // A caret in front of the marker moves the item down rather than splitting its marker.
+    if (column < list.prefix.length) {
+      return 'newline';
     }
-    return modOnly ? 'newline' : 'send';
+    return list.empty ? 'leave-list' : 'continue-list';
+  }
+  if (keys.alt) {
+    return 'send-alternate';
+  }
+  return modOnly ? 'newline' : 'send';
 }
 /* The innermost fenced code block around `pos`, if any. */
 function enclosingFence(tree, pos) {
-    for (let node = tree.resolveInner(pos, -1); node !== null; node = node.parent) {
-        if (node.name === 'FencedCode') {
-            return node;
-        }
+  for (let node = tree.resolveInner(pos, -1); node !== null; node = node.parent) {
+    if (node.name === 'FencedCode') {
+      return node;
     }
-    return null;
+  }
+  return null;
 }
 /* A fence nobody has closed yet has its opening mark only. */
 function isOpenFence(fence) {
-    return fence.getChildren('CodeMark').length < 2;
+  return fence.getChildren('CodeMark').length < 2;
 }
 /* Whether `pos` sits inside a fenced code block that has an opening fence and no closing one yet. */
 export function inOpenFence(tree, pos) {
-    const fence = enclosingFence(tree, pos);
-    return fence !== null && pos > fence.from && isOpenFence(fence);
+  const fence = enclosingFence(tree, pos);
+  return fence !== null && pos > fence.from && isOpenFence(fence);
 }
 /* Whether `pos` sits in the body of a fenced code block, open or closed: below its opening line and before its end. */
 export function inFenceBody(tree, text, pos) {
-    const fence = enclosingFence(tree, pos);
-    if (fence === null) {
-        return false;
-    }
-    const openingEnd = text.indexOf('\n', fence.from);
-    return openingEnd !== -1 && pos > openingEnd && (pos < fence.to || isOpenFence(fence));
+  const fence = enclosingFence(tree, pos);
+  if (fence === null) {
+    return false;
+  }
+  const openingEnd = text.indexOf('\n', fence.from);
+  return openingEnd !== -1 && pos > openingEnd && (pos < fence.to || isOpenFence(fence));
 }
 /* The spaces Tab inserts at `column`, up to the next stop of four, the way a code editor lines up. */
 export function tabSpaces(column) {
-    return ' '.repeat(4 - (column % 4));
+  return ' '.repeat(4 - column % 4);
 }
 const INLINE_BLOCK = /^(Paragraph|ATXHeading\d|SetextHeading\d)$/;
 /*
@@ -78,41 +89,47 @@ const INLINE_BLOCK = /^(Paragraph|ATXHeading\d|SetextHeading\d)$/;
  * counts as well: whoever types after it is writing code.
  */
 export function inCode(tree, text, pos) {
-    let blockFrom = null;
-    for (let node = tree.resolveInner(pos, -1); node !== null; node = node.parent) {
-        if (node.name === 'FencedCode') {
-            return pos > node.from && (pos < node.to || isOpenFence(node));
-        }
-        if (node.name === 'InlineCode' && pos > node.from && pos < node.to) {
-            return true;
-        }
-        if (blockFrom === null && INLINE_BLOCK.test(node.name)) {
-            blockFrom = node.from;
-        }
+  let blockFrom = null;
+  for (let node = tree.resolveInner(pos, -1); node !== null; node = node.parent) {
+    if (node.name === 'FencedCode') {
+      return pos > node.from && (pos < node.to || isOpenFence(node));
+    }
+    if (node.name === 'InlineCode' && pos > node.from && pos < node.to) {
+      return true;
     }
-    let from = blockFrom ?? text.lastIndexOf('\n', pos - 1) + 1;
-    tree.iterate({
-        from,
-        to: pos,
-        enter: (node) => {
-            if (node.name === 'InlineCode' && node.to <= pos) {
-                from = Math.max(from, node.to);
-            }
-        }
-    });
-    return /(^|[^\\])`/.test(text.slice(from, pos));
+    if (blockFrom === null && INLINE_BLOCK.test(node.name)) {
+      blockFrom = node.from;
+    }
+  }
+  let from = blockFrom ?? text.lastIndexOf('\n', pos - 1) + 1;
+  tree.iterate({
+    from,
+    to: pos,
+    enter: node => {
+      if (node.name === 'InlineCode' && node.to <= pos) {
+        from = Math.max(from, node.to);
+      }
+    }
+  });
+  return /(^|[^\\])`/.test(text.slice(from, pos));
 }
 /*
  * Which way the arrow walks through earlier prompts, or null when the arrow just moves the caret.
  * Only an empty box or an unedited recall walks, so an arrow in a prompt being written never
  * throws it away.
  */
-export function recallDirection({ key, text, from, to, recalled }) {
-    if (key === 'ArrowUp' && (text === '' || (recalled && from === 0))) {
-        return -1;
-    }
-    if (key === 'ArrowDown' && recalled && to === text.length) {
-        return 1;
-    }
-    return null;
-}
+export function recallDirection({
+  key,
+  text,
+  from,
+  to,
+  recalled
+}) {
+  if (key === 'ArrowUp' && (text === '' || recalled && from === 0)) {
+    return -1;
+  }
+  if (key === 'ArrowDown' && recalled && to === text.length) {
+    return 1;
+  }
+  return null;
+}

package/dist/chat/ui/composer/menu-aria.js

@@ -1,18 +1,27 @@
 /* The index that still points at an option once the list has shrunk under a stale one. */
 export function clampMenuIndex(index, count) {
-    return Math.min(index, Math.max(count - 1, 0));
+  return Math.min(index, Math.max(count - 1, 0));
 }
 export function optionIdOf(listId, index) {
-    return `${listId}-${index}`;
+  return `${listId}-${index}`;
 }
 /*
  * The attributes the editor's content element takes while a suggestion menu stands beside it. The
  * element keeps its `textbox` role; ARIA 1.2 lets it name the option the arrow keys are on.
  */
-export function composerMenuAria({ label, listId, open, activeIndex, count }) {
-    return {
-        'aria-label': label,
-        'aria-autocomplete': 'list',
-        ...(open && count > 0 ? { 'aria-controls': listId, 'aria-activedescendant': optionIdOf(listId, activeIndex) } : {})
-    };
-}
+export function composerMenuAria({
+  label,
+  listId,
+  open,
+  activeIndex,
+  count
+}) {
+  return {
+    'aria-label': label,
+    'aria-autocomplete': 'list',
+    ...(open && count > 0 ? {
+      'aria-controls': listId,
+      'aria-activedescendant': optionIdOf(listId, activeIndex)
+    } : {})
+  };
+}