@adecore/agents-react 0.38.0 → 0.40.0

package/src/chat/ui/composer/key-handler.ts

@@ -26,7 +26,6 @@ interface KeyHandlerInput {
     history: PromptHistory;
     noteKey(e: KeyboardEvent): void;
     toggleStash(): void;
-    setText(next: string): void;
     submit(how: ComposerSend): void;
 }
 
@@ -35,9 +34,11 @@ function indentInFence(e: KeyboardEvent, view: EditorView): boolean {
     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);
@@ -46,53 +47,62 @@ function indentInFence(e: KeyboardEvent, view: EditorView): boolean {
     } 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: KeyboardEvent, { menus, setText }: KeyHandlerInput): boolean {
+export function pickInMenu(e: KeyboardEvent, menus: ComposerMenus): boolean {
     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} `);
-            }
+            menus.completeCommand(menus.commands[activeIndex]!);
+
             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 (e.key === 'Tab' || e.key === 'Enter') {
             menus.chooseMentionAt(activeIndex);
+
             return true;
         }
     }
+
     if (menus.referenceMenuOpen && menus.referenceMatches.length > 0) {
         if (menus.moveInMenu(e.key, menus.referenceMatches.length)) {
             return true;
         }
+
         if (e.key === 'Tab' || e.key === 'Enter') {
             menus.chooseReferenceAt(activeIndex);
+
             return true;
         }
     }
+
     return false;
 }
 
@@ -104,6 +114,7 @@ function enter(e: KeyboardEvent, view: EditorView, { host, sendKey, submit }: Ke
     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 },
         {
@@ -115,9 +126,11 @@ function enter(e: KeyboardEvent, view: EditorView, { host, sendKey, submit }: Ke
             startsNewChat: host.openNewChat !== null
         }
     );
+
     if (action === 'newline') {
         return insertNewline(view);
     }
+
     if (action === 'continue-list') {
         if (list) {
             view.dispatch({
@@ -127,57 +140,77 @@ function enter(e: KeyboardEvent, view: EditorView, { host, sendKey, submit }: Ke
                 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;
     }
+
     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: KeyHandlerInput): (e: KeyboardEvent, view: EditorView) => boolean {
     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)) {
+
+        if (pickInMenu(e, input.menus)) {
             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/src/chat/ui/composer/keys.ts

@@ -40,11 +40,14 @@ const LIST_ITEM = /^([ \t]*)(?:([-*+])|(\d{1,9})([.)]))([ \t]+)(\[[ xX]\](?:[ \t
 /* The list item a line starts, if it starts one. */
 export function listItemAt(line: string): ListItem | null {
     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() === '' };
 }
 
@@ -60,25 +63,32 @@ export function enterAction(
     { inOpenFence, list, column, sendKey = 'enter', multiline = false, startsNewChat = false }: EnterContext
 ): EnterAction {
     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';
     }
+
     if (keys.alt) {
         return 'send-alternate';
     }
+
     return modOnly ? 'newline' : 'send';
 }
 
@@ -89,6 +99,7 @@ function enclosingFence(tree: Tree, pos: number): SyntaxNode | null {
             return node;
         }
     }
+
     return null;
 }
 
@@ -100,16 +111,20 @@ function isOpenFence(fence: SyntaxNode): boolean {
 /* Whether `pos` sits inside a fenced code block that has an opening fence and no closing one yet. */
 export function inOpenFence(tree: Tree, pos: number): boolean {
     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: Tree, text: string, pos: number): boolean {
     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));
 }
 
@@ -127,18 +142,23 @@ const INLINE_BLOCK = /^(Paragraph|ATXHeading\d|SetextHeading\d)$/;
  */
 export function inCode(tree: Tree, text: string, pos: number): boolean {
     let blockFrom: number | null = null;
+
     for (let node: SyntaxNode | null = 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 from = blockFrom ?? text.lastIndexOf('\n', pos - 1) + 1;
+
     tree.iterate({
         from,
         to: pos,
@@ -148,6 +168,7 @@ export function inCode(tree: Tree, text: string, pos: number): boolean {
             }
         }
     });
+
     return /(^|[^\\])`/.test(text.slice(from, pos));
 }
 
@@ -169,8 +190,10 @@ export function recallDirection({ key, text, from, to, recalled }: RecallContext
     if (key === 'ArrowUp' && (text === '' || (recalled && from === 0))) {
         return -1;
     }
+
     if (key === 'ArrowDown' && recalled && to === text.length) {
         return 1;
     }
+
     return null;
 }

package/src/chat/ui/composer/placeholder.ts

@@ -10,12 +10,15 @@ function hintedPlaceholder(lead: string, joiner: string, hints: ReadonlyArray<{
     const extra = document.createElement('span');
     extra.className = 'composer-hints-extra';
     extra.append(joiner);
+
     for (const hint of hints) {
         const cap = document.createElement('kbd');
         cap.textContent = hint.key;
         extra.append(cap, hint.label);
     }
+
     root.append(lead, extra);
+
     return root;
 }
 
@@ -32,13 +35,16 @@ export function useHintedPlaceholder({ chatId, disabled, readOnly, mentionable,
     const { t } = useTranslation('agent-chat');
     const scope = useChatScope();
     const lead = useHostComposerPlaceholder(scope.id, chatId);
+
     return useMemo(() => {
         if (disabled) {
             return t('composer.placeholder.disconnected');
         }
+
         if (readOnly) {
             return t('composer.placeholder.readOnly');
         }
+
         return hintedPlaceholder(lead ?? t('composer.placeholder.lead'), t('composer.placeholder.joiner'), [
             { key: '/', label: t('composer.placeholder.commands') },
             ...(mentionable ? [{ key: '@', label: t('composer.placeholder.files') }] : []),

package/src/chat/ui/composer/prompt-picks.ts

@@ -0,0 +1,18 @@
+import type { ChatSendExtras } from '../../chat-client';
+import { referenceTokens, type Referables } from '../../chat-references';
+import { presentMentions, presentReferences, presentSkills } from '../../mentions';
+import type { PromptDraft } from './use-prompt-menus';
+
+/* What a prompt still holds of what was picked in it, as a send of the composer carries it. */
+export function promptPicks(value: PromptDraft, referables: Referables): Pick<ChatSendExtras, 'mentions' | 'skills' | 'chats' | 'references'> {
+    const text = value.text.trim();
+    const tokens = referenceTokens([...value.chats, ...value.references], referables.items, value.referenceNames);
+
+    return {
+        mentions: presentMentions(text, value.mentions),
+        skills: presentSkills(text, value.skills),
+        chats: presentReferences(text, value.chats, tokens),
+        // A machine that resolves only chats would drop the rest.
+        references: referables.chatsOnly ? [] : presentReferences(text, value.references, tokens)
+    };
+}

package/src/chat/ui/composer/surface.ts

@@ -33,13 +33,18 @@ const ACTIONS = [
 export function surfacePartOf(target: EventTarget | null, surface: Element): 'input' | 'action' | 'surface' {
     // Not `instanceof Element`, which fails for an element of another window.
     const element = target as Element | null;
+
     if (typeof element?.closest !== 'function' || !surface.contains(element)) {
         return 'action';
     }
+
     const input = element.closest('.cm-editor');
+
     if (input !== null && surface.contains(input)) {
         return 'input';
     }
+
     const action = element.closest(ACTIONS);
+
     return action !== null && surface.contains(action) ? 'action' : 'surface';
 }

package/src/chat/ui/composer/use-chat-controls.ts

@@ -32,8 +32,10 @@ export function useChatControls({ chatId, info, notice: { setNotice, showError }
         if (configuring.current) {
             return;
         }
+
         configuring.current = true;
         setConfigurationPending(true);
+
         void work()
             .catch(showError)
             .finally(() => {
@@ -49,6 +51,7 @@ export function useChatControls({ chatId, info, notice: { setNotice, showError }
                 if (patch.selection) {
                     rememberChatSelection(info.provider, patch.selection);
                 }
+
                 if (patch.account) {
                     rememberChatAccount(scope.id, info.provider, patch.account);
                 }
@@ -59,18 +62,23 @@ export function useChatControls({ chatId, info, notice: { setNotice, showError }
     /* A model of another CLI re-points the whole chat; one of this CLI's own is a configure. */
     const chooseModel = (provider: AgentKind, slug: string): void => {
         const selection: ModelSelection = { model: slug, options: {} };
+
         if (provider !== info.provider) {
             runConfiguration(() => onRetarget(provider, selection).then(() => rememberChatSelection(provider, selection)));
+
             return;
         }
+
         configure({ selection });
     };
 
     const stop = (shiftKey: boolean): void => {
         if (composerStopOf(shiftKey) === 'turn') {
             void actions.stopTurn(chatId, false).catch(showError);
+
             return;
         }
+
         host.confirm.stopSubagents(scope.id, chatId, () => void actions.stopTurn(chatId, true).catch(showError));
     };
 
@@ -81,8 +89,10 @@ export function useChatControls({ chatId, info, notice: { setNotice, showError }
         } catch (e) {
             if (errorCode(e) === 'chat-busy') {
                 setConfirmClear(true);
+
                 return;
             }
+
             setNotice(t('composer.notice.clearFailed'));
         }
     };
@@ -101,12 +111,15 @@ export function useChatControls({ chatId, info, notice: { setNotice, showError }
         switch (name) {
             case 'model':
                 setModelPickerOpen(true);
+
                 return true;
             case 'compact':
                 void actions.compact(chatId).catch(() => undefined);
+
                 return true;
             case 'clear':
                 void clearThread();
+
                 return true;
             default:
                 return false;

package/src/chat/ui/composer/use-compaction-offer.ts

@@ -12,8 +12,10 @@ const PAGE_CLOCK: DueClock = {
         if (typeof window === 'undefined') {
             return () => {};
         }
+
         window.addEventListener('focus', wake);
         document.addEventListener('visibilitychange', wake);
+
         return () => {
             window.removeEventListener('focus', wake);
             document.removeEventListener('visibilitychange', wake);
@@ -38,6 +40,7 @@ export function useCompactionOffer(chatId: string, info: ChatInfo, compaction: P
         if (dueAt === null) {
             return;
         }
+
         return watchDueAt(dueAt, setNow, PAGE_CLOCK);
     }, [dueAt]);