@adecore/agents-react 0.39.0 → 0.40.1

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

@@ -34,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);
@@ -45,48 +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. */
 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') {
             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;
 }
 
@@ -98,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 },
         {
@@ -109,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({
@@ -121,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.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

@@ -7,6 +7,7 @@ import type { PromptDraft } from './use-prompt-menus';
 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),

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]);
 

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

@@ -34,6 +34,7 @@ export function useComposerMenus({ chatId, info, capabilities, providerName, dra
      */
     useEffect(() => {
         let stale = false;
+
         scope.chats
             .listSkills(chatId)
             .then((found) => {
@@ -42,6 +43,7 @@ export function useComposerMenus({ chatId, info, capabilities, providerName, dra
                 }
             })
             .catch(() => undefined);
+
         return () => {
             stale = true;
         };

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

@@ -62,9 +62,11 @@ export function useComposerSubmit({
     /* Opens the host's new chat once the host took the message; a host that answers nothing took it. */
     const afterSend = (sent: void | Promise<boolean>, andNew: boolean): void => {
         const openNewChat = host.openNewChat;
+
         if (!andNew || openNewChat === null) {
             return;
         }
+
         void Promise.resolve(sent)
             .then((taken) => {
                 if (taken !== false) {
@@ -79,39 +81,53 @@ export function useComposerSubmit({
         const delivery = steerable && (alternate ? sendDelivery === 'queue' : sendDelivery === 'steer') ? 'steer' : 'queue';
         const { text, quote, quoteSource } = draft;
         const trimmed = text.trim();
+
         if (isEmptyDraft(draft) || !writable || guard.tooLong) {
             return;
         }
+
         // Recheck restored drafts and files that finished reading concurrently.
         const rejected = checkAttachmentLimits(
             0,
             draft.attachments.map((attachment) => ({ ...attachment, bytes: uploadBytes(attachment) }))
         ).rejected[0];
+
         if (rejected) {
             setNotice(`${rejected.name}: ${rejected.reason}`);
+
             return;
         }
+
         hold.release('send');
         const { commandQuery } = menus;
         const chosen = menus.commands[menus.activeIndex];
+
         if (commandQuery !== null && chosen?.local && controls.runCommand(chosen.name)) {
             box.clear();
+
             return;
         }
+
         if (commandQuery !== null && chosen?.skill) {
             menus.chooseSkill(chosen.name);
+
             return;
         }
+
         // Whoever sends wants to see what comes back, wherever they were reading.
         scrollTimelineToEnd(chatId, 'instant');
+
         if (commandQuery !== null && chosen && !chosen.local) {
             afterSend(onSend(`/${chosen.name}`, {}), how === 'and-new');
             box.clear();
+
             return;
         }
+
         const chats = presentReferences(trimmed, draft.chats, menus.referenceChips);
         // A machine without `viewReferences` drops the field, so only the chats it does know reach it.
         const references = menus.referables.chatsOnly ? [] : presentReferences(trimmed, draft.references, menus.referenceChips);
+
         const sent = onSend(withQuote(quote, trimmed), {
             delivery,
             mentions: presentMentions(trimmed, draft.mentions),
@@ -121,6 +137,7 @@ export function useComposerSubmit({
             attachments: draft.attachments,
             references: references.length > 0 ? references : undefined
         });
+
         afterSend(sent, how === 'and-new');
         box.clear();
         menus.close();
@@ -129,9 +146,11 @@ export function useComposerSubmit({
 
     // A menu row means the draft as it stands when it is picked, so the registration reads the latest submit.
     const submitRef = useRef(submit);
+
     useEffect(() => {
         submitRef.current = submit;
     });
+
     useEffect(() => registerComposerSender(scope.keyOf(chatId), (how) => submitRef.current(how)), [scope, chatId]);
 
     /*
@@ -142,11 +161,13 @@ export function useComposerSubmit({
     const restoreStashed = (prompt: StashedPrompt): void => {
         const stashedQuote = prompt.quote;
         const here = stashedQuote !== undefined && stashedQuote.chatId === chatId;
+
         const { chats, dropped } = restorableChats(
             prompt.chats,
             new Set(menus.referables.items.filter((item) => item.kind === 'chat').map((item) => item.id)),
             chatId
         );
+
         setDraft((current) => ({
             ...current,
             text: stashedQuote === undefined || here ? prompt.text : withQuote(stashedQuote.text, prompt.text),
@@ -156,9 +177,11 @@ export function useComposerSubmit({
             references: [...prompt.references],
             ...(here ? { quote: stashedQuote.text, quoteSource: stashedQuote.itemId } : {})
         }));
+
         if (dropped > 0) {
             setNotice(t('composer.notice.stashChatsDropped', { count: dropped }), 'info');
         }
+
         history.forget();
         inputRef.current?.focus();
     };
@@ -168,6 +191,7 @@ export function useComposerSubmit({
         if (!writable) {
             return;
         }
+
         scrollTimelineToEnd(chatId, 'instant');
         afterSend(onSend(CONTINUE_PROMPT, {}), false);
     };
@@ -176,11 +200,14 @@ export function useComposerSubmit({
     const toggleStash = (): void => {
         if (isEmptyDraft(draft)) {
             const newest = useStash.getState().prompts[0];
+
             if (newest) {
                 restoreStashed(newest);
             }
+
             return;
         }
+
         if (stashDraft(draft, chatId)) {
             box.clear();
             menus.close();

package/src/chat/ui/composer/use-continuable-turn.ts

@@ -1,4 +1,3 @@
-import { useMemo } from 'react';
 import type { ChatInfo, ChatItem } from '@adecore/agent-contracts';
 import { useChatRow } from '../../../state/chats';
 import { continuableTurn } from '../../logic/continue-after-stop';
@@ -7,8 +6,7 @@ import { continuableTurn } from '../../logic/continue-after-stop';
 export function useContinuableTurn(chatId: string, info: ChatInfo): string | null {
     const order = useChatRow(chatId, (row) => row?.order);
     const structure = useChatRow(chatId, (row) => row?.structure);
-    return useMemo(() => {
-        const items = (order ?? []).map((id) => structure?.[id]).filter((item): item is ChatItem => item !== undefined);
-        return continuableTurn(info, items);
-    }, [info, order, structure]);
+    const items = (order ?? []).map((id) => structure?.[id]).filter((item): item is ChatItem => item !== undefined);
+
+    return continuableTurn(info, items);
 }