@adecore/agents-react 0.38.0 → 0.40.0

package/src/chat/ui/markdown-blocks.ts

@@ -63,6 +63,7 @@ const THEMATIC_BREAK = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
 // A heading or a quote, which ends a list item instead of continuing its paragraph.
 const ENDS_ITEM = /^ {0,3}(?:#{1,6}(?:[ \t]|$)|>)/;
 const HTML_START = /^ {0,3}<[A-Za-z/!?]/;
+
 // The HTML that runs on until a marker rather than a blank line, with that marker.
 const HTML_UNTIL: [RegExp, RegExp][] = [
     [/^ {0,3}<(?:pre|script|style|textarea)(?:[ \t>]|$)/i, /<\/(?:pre|script|style|textarea)>/i],
@@ -71,6 +72,7 @@ const HTML_UNTIL: [RegExp, RegExp][] = [
     [/^ {0,3}<![A-Za-z]/, />/],
     [/^ {0,3}<!\[CDATA\[/, /\]\]>/]
 ];
+
 // A reference or footnote definition may be used anywhere in the text, so a block cannot stand alone.
 const DEFINITION = /^ {0,3}\[[^\]]+\]:/m;
 // Markdown ends a line at a lone carriage return too, which a split at line feeds would not see.
@@ -94,6 +96,7 @@ export function splitMarkdownBlocks(text: string): MarkdownBlock[] {
     if (DEFINITION.test(text) || LONE_RETURN.test(text)) {
         return [{ text, openFence: isFenceOpenAtEnd(text) }];
     }
+
     const lines = text.split('\n');
     const blocks: MarkdownBlock[] = [];
     let start = 0;
@@ -121,6 +124,7 @@ export function splitMarkdownBlocks(text: string): MarkdownBlock[] {
         if (end > start) {
             blocks.push({ text: text.slice(start, end), openFence: false });
         }
+
         start = end;
     };
 
@@ -134,6 +138,7 @@ export function splitMarkdownBlocks(text: string): MarkdownBlock[] {
         const blankCut = lineFence === null && afterBlank && !blank && !CONTINUES.test(line);
         lineFence = nextFence(lineFence, line);
         afterBlank = lineFence === null && blank && index > 0;
+
         if (top !== null) {
             if (closesFence(top.marker, content)) {
                 closed = { fence: top, source: text.slice(top.from, at + content.length) };
@@ -143,36 +148,46 @@ export function splitMarkdownBlocks(text: string): MarkdownBlock[] {
                 top.body += (top.ending ?? '') + outdent(content, top.indent);
                 top.ending = line.length > content.length ? '\r\n' : '\n';
             }
+
             continue;
         }
+
         if (closed !== null) {
             if (empty) {
                 continue;
             }
+
             blocks.push(fenceBlock(text.slice(start, at), closed.fence, closed.source, true));
             start = at;
             closed = null;
         }
+
         if (html !== null) {
             // Raw HTML holds no fence and no blank line to cut at until its marker.
             if (html.test(content)) {
                 html = null;
             }
+
             continue;
         }
+
         if (known && fence !== null && item !== null && !empty && columns(content) < item.column) {
             // Code is no paragraph a line may continue lazily, so a line left of the item's content ends
             // the item and its code. A next item of the same list keeps the list going.
             fence = null;
+
             if (!LIST_MARKER.test(content)) {
                 item = null;
             }
         }
+
         if (blankCut && fence === null) {
             cutAt(at);
         }
+
         const above = index > 0 ? withoutReturn(lines[index - 1]!) : '';
         const opening = known && fence === null ? openingFence(content) : null;
+
         if (opening !== null && EMPTY_ITEM.test(above)) {
             // Markdown reads an empty item right above a fence as a list or as text depending on what
             // stands before it, so the two stay in one block.
@@ -185,12 +200,15 @@ export function splitMarkdownBlocks(text: string): MarkdownBlock[] {
             top = { ...opening, from: at + opening.indent, body: '', ending: null };
             item = null;
             blankAbove = null;
+
             continue;
         }
+
         if (known && item?.empty === true && empty) {
             // An item with nothing on its first line ends at a blank line right under it.
             item = null;
         }
+
         if (known && fence === null && !empty) {
             // A fence in an item is followed only while the item is known to be open, and less than four
             // columns deeper than its content: deeper it is code of the item, or of an item inside it.
@@ -200,19 +218,24 @@ export function splitMarkdownBlocks(text: string): MarkdownBlock[] {
                 item = nextItem(item, content, index > 0 && !BLANK.test(above));
             }
         }
+
         if (fence === null && HTML_START.test(content)) {
             known = false;
             const until = HTML_UNTIL.find(([begins]) => begins.test(content))?.[1];
             html = until !== undefined && !until.test(content) ? until : null;
         }
+
         if (known && (fence !== null || item !== null)) {
             fence = nextFence(fence, fence === null ? itemContent(content) : content);
         }
+
         if (item?.empty === true && !empty && columns(content) >= item.column) {
             item = { ...item, empty: false };
         }
+
         blankAbove = empty ? at : null;
     }
+
     if (top !== null) {
         blocks.push(fenceBlock(text.slice(start), top, text.slice(top.from), false));
     } else if (closed !== null) {
@@ -220,6 +243,7 @@ export function splitMarkdownBlocks(text: string): MarkdownBlock[] {
     } else {
         blocks.push({ text: text.slice(start), openFence: (known ? fence : lineFence) !== null });
     }
+
     return blocks;
 }
 
@@ -241,21 +265,28 @@ export function settledBlocksText(text: string): string {
 function withoutTrailingTitles(text: string): string {
     const lines = text.split('\n');
     let end = lines.length;
+
     for (let index = lines.length - 1; index >= 0; index--) {
         const line = lines[index]!;
+
         if (BLANK.test(line)) {
             continue;
         }
+
         // A bold line right under a line of text continues that paragraph.
         const title = HEADING.test(line) || (BOLD_LINE.test(line) && (index === 0 || BLANK.test(lines[index - 1]!)));
+
         if (!title) {
             break;
         }
+
         end = index;
     }
+
     if (end === lines.length) {
         return text;
     }
+
     return lines
         .slice(0, end)
         .map((line) => `${line}\n`)
@@ -265,46 +296,58 @@ function withoutTrailingTitles(text: string): string {
 /* The fence a line leaves open: it opens one, closes the one that is open, or changes nothing. */
 function nextFence(fence: OpenFence | null, line: string): OpenFence | null {
     const match = FENCE.exec(line);
+
     if (!match) {
         return fence;
     }
+
     const indent = match[1]!.length;
     const run = match[2]!;
     const rest = match[3]!;
+
     if (fence === null) {
         // A backtick fence's info string may not hold a backtick, or the line is inline code.
         if (run[0] === '`' && rest.includes('`')) {
             return null;
         }
+
         return { marker: run[0]!, length: run.length, indent };
     }
+
     // A closing fence carries no info string, and a line far deeper than the opening is code.
     if (run[0] === fence.marker && run.length >= fence.length && BLANK.test(rest) && indent <= fence.indent + CLOSING_INDENT) {
         return null;
     }
+
     return fence;
 }
 
 function isFenceOpenAtEnd(text: string): boolean {
     let fence: OpenFence | null = null;
+
     for (const line of text.split('\n')) {
         fence = nextFence(fence, withoutReturn(line));
     }
+
     return fence !== null;
 }
 
 /* The fence a line opens wherever it stands, with its indentation in columns. */
 function openingFence(content: string): Pick<TopFence, 'marker' | 'info' | 'indent' | 'direct'> | null {
     const match = FENCE.exec(content);
+
     if (!match) {
         return null;
     }
+
     const marker = match[2]!;
     const info = match[3]!.replace(/^[ \t]+|[ \t]+$/g, '');
+
     // A backtick fence's info string may not hold a backtick, or the line is inline code.
     if (marker[0] === '`' && info.includes('`')) {
         return null;
     }
+
     return { marker, info, indent: columns(content), direct: !/[\\&]/.test(info.split(/[ \t]/, 1)[0]!) };
 }
 
@@ -315,6 +358,7 @@ function withoutReturn(line: string): string {
 
 function closesFence(marker: string, content: string): boolean {
     const run = CLOSING_FENCE.exec(content)?.[1];
+
     return run !== undefined && run[0] === marker[0] && run.length >= marker.length;
 }
 
@@ -322,38 +366,48 @@ function fenceBlock(text: string, fence: TopFence, source: string, closed: boole
     if (!fence.direct) {
         return { text, openFence: !closed };
     }
+
     return { text, openFence: !closed, fence: { marker: fence.marker, info: fence.info, body: fence.body, closed, source } };
 }
 
 /* The list item a line that is neither blank nor a fence leaves open, as far as a fence needs to know. */
 function nextItem(item: ListItem | null, content: string, underLine: boolean): ListItem | null {
     const indent = columns(content);
+
     if (item !== null && indent >= item.column) {
         return item;
     }
+
     if (THEMATIC_BREAK.test(content) || ENDS_ITEM.test(content)) {
         return null;
     }
+
     const marker = indent < CODE_INDENT ? itemMarker(content) : null;
+
     if (marker === null) {
         if (item === null || !underLine) {
             return null;
         }
+
         // A line right under an item may continue its paragraph, or follow an item that ends in something else.
         return { ...item, certain: false };
     }
+
     // Right under another line, only a bullet or a 1 with text after it surely starts a list; anything
     // else may be text of a paragraph above.
     const certain = !underLine || (item !== null && item.certain && item.kind === marker.kind) || (marker.first && marker.rest !== '');
+
     return { column: marker.column, kind: marker.kind, certain, empty: marker.rest === '' };
 }
 
 /* The marker a list item starts with: its kind, whether it may start a list under text, and the column its content starts at. */
 function itemMarker(content: string): { kind: string; first: boolean; column: number; rest: string } | null {
     const match = LIST_MARKER.exec(content);
+
     if (match === null) {
         return null;
     }
+
     const [, bullet, number, delimiter, spacing = '', rest = ''] = match;
     const indent = columns(content);
     const width = bullet !== undefined ? 1 : number!.length + 1;
@@ -361,18 +415,21 @@ function itemMarker(content: string): { kind: string; first: boolean; column: nu
     // item starts with indented code one column after the marker.
     const gap = rest === '' ? 1 : columns(spacing, indent + width);
     const column = indent + width + (gap > CODE_INDENT ? 1 : gap);
+
     return { kind: bullet ?? delimiter!, first: bullet !== undefined || Number(number) === 1, column, rest };
 }
 
 /* A list item's line with its marker as spaces, so a fence on that line is seen where the item's content starts. */
 function itemContent(content: string): string {
     const marker = itemMarker(content);
+
     return marker === null ? content : ' '.repeat(marker.column) + marker.rest;
 }
 
 /* The columns of the indentation of a line, which starts at column `from`; a tab reaches to the next stop of four. */
 function columns(line: string, from = 0): number {
     let column = from;
+
     for (const character of line) {
         if (character === '\t') {
             column += TAB_STOP - (column % TAB_STOP);
@@ -382,6 +439,7 @@ function columns(line: string, from = 0): number {
             break;
         }
     }
+
     return column - from;
 }
 
@@ -392,20 +450,26 @@ function columns(line: string, from = 0): number {
 function outdent(line: string, indent: number): string {
     let column = 0;
     let index = 0;
+
     while (column < indent && index < line.length) {
         const character = line[index];
+
         if (character === '\t') {
             const stop = column + TAB_STOP - (column % TAB_STOP);
+
             if (stop > indent) {
                 return ' '.repeat(stop - indent) + line.slice(index + 1);
             }
+
             column = stop;
         } else if (character === ' ') {
             column += 1;
         } else {
             break;
         }
+
         index += 1;
     }
+
     return line.slice(index);
 }

package/src/chat/ui/mermaid.ts

@@ -57,15 +57,19 @@ function attributeText(value: string): string {
  */
 export function themedSvg(svg: string, colors: Readonly<Record<string, string>>): string {
     const root = ROOT.exec(svg);
+
     if (root === null) {
         return svg;
     }
+
     const variables = attributeText(
         Object.entries(colors)
             .map(([name, value]) => `${name}:${value};`)
             .join('')
     );
+
     const tag = STYLE.test(root[0]) ? root[0].replace(STYLE, (style) => style + variables) : root[0].replace(/^<svg\b/, `<svg style="${variables}"`);
+
     return svg.slice(0, root.index) + tag + svg.slice(root.index + root[0].length);
 }
 

package/src/chat/ui/quote-selection.ts

@@ -21,18 +21,22 @@ function answerAt(node: Node): Element | null {
  */
 function selectsOutside(range: Range, answer: Element): boolean {
     const walker = document.createTreeWalker(range.commonAncestorContainer, NodeFilter.SHOW_TEXT);
+
     for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) {
         if (!range.intersectsNode(node) || answer.contains(node)) {
             continue;
         }
+
         const text = node.textContent ?? '';
         const start = node === range.startContainer ? range.startOffset : 0;
         const end = node === range.endContainer ? range.endOffset : text.length;
         const parent = node.parentElement;
+
         if (text.slice(start, end).trim() !== '' && parent !== null && getComputedStyle(parent).userSelect !== 'none') {
             return true;
         }
     }
+
     return false;
 }
 
@@ -41,15 +45,21 @@ export function selectedAnswerQuote(selection: Selection | null, thread: HTMLEle
     if (thread === null || selection === null || selection.isCollapsed || selection.rangeCount === 0) {
         return null;
     }
+
     const range = selection.getRangeAt(0);
     const answer = answerAt(range.startContainer) ?? answerAt(range.endContainer);
+
     if (answer === null || !thread.contains(answer)) {
         return null;
     }
+
     const inside = answer.contains(range.startContainer) && answer.contains(range.endContainer);
+
     if (!inside && selectsOutside(range, answer)) {
         return null;
     }
+
     const text = quoteOf(selection.toString());
+
     return text === null ? null : { text, itemId: answer.closest('[data-find-item]')?.getAttribute('data-find-item') ?? null };
 }

package/src/chat/ui/rehype-chips.ts

@@ -35,6 +35,7 @@ function valueOf(segment: Exclude<ChipSegment, { kind: 'text' }>): string {
     if (segment.kind === 'mention') {
         return segment.path;
     }
+
     return segment.kind === 'skill' ? segment.name : segment.id;
 }
 
@@ -59,9 +60,11 @@ function split(parent: HastParent, tokenize: (text: string) => ChipSegment[], sk
         if (child.type === 'text') {
             return tokenize(child.value).map((segment) => (segment.kind === 'text' ? { type: 'text', value: segment.text } : chipElement(segment)));
         }
+
         if (child.type === 'element' && !skipped.has(child.tagName)) {
             split(child, tokenize, skipped);
         }
+
         return [child];
     });
 }
@@ -72,6 +75,7 @@ export function rehypeChips({ mentions = [], skills = [], references = [] }: Chi
         if (mentions.length === 0 && skills.length === 0 && references.length === 0) {
             return;
         }
+
         split(tree, (text) => tokenizeChips(text, mentions, skills, references), SKIPPED);
     };
 }
@@ -82,6 +86,7 @@ export function rehypeNamedReferences({ items, referenced = [] }: NamedReference
         if (items.length === 0) {
             return;
         }
+
         split(tree, (text) => (text.includes('#') ? tokenizeNamedReferences(text, items, referenced) : [{ kind: 'text', text }]), SKIPPED_IN_REPLIES);
     };
 }

package/src/chat/ui/rehype-fade.ts

@@ -45,9 +45,11 @@ function wrap(parent: HastParent): void {
                     : { type: 'element', tagName: 'span', properties: { className: [FADE_CLASS] }, children: [{ type: 'text', value: segment }] }
             );
         }
+
         if (child.type === 'element' && !SKIPPED.has(child.tagName)) {
             wrap(child);
         }
+
         return [child];
     });
 }

package/src/chat/ui/remark-html-as-text.ts

@@ -13,13 +13,18 @@ function literal(parent: MdastNode): void {
     if (parent.children === undefined) {
         return;
     }
+
     const flow = FLOW_PARENTS.has(parent.type);
+
     parent.children = parent.children.map((child): MdastNode => {
         if (child.type !== 'html') {
             literal(child);
+
             return child;
         }
+
         const text = { ...child, type: 'text' };
+
         return flow ? { type: 'paragraph', position: child.position, children: [text] } : text;
     });
 }

package/src/chat/ui/reveal.ts

@@ -34,9 +34,11 @@ export function advanceReveal(position: number, target: number, elapsedMs: numbe
     if (position >= target) {
         return target;
     }
+
     const elapsed = Math.min(Math.max(elapsedMs, 0), REVEAL_MAX_FRAME_MS);
     const eased = (target - position) * (1 - Math.exp(-elapsed / REVEAL_TAU_MS));
     const floor = ((finished ? REVEAL_FINISH_MIN_CPS : REVEAL_MIN_CPS) * elapsed) / 1000;
+
     return Math.min(target, position + Math.max(eased, floor));
 }
 
@@ -48,18 +50,24 @@ export function advanceReveal(position: number, target: number, elapsedMs: numbe
  */
 export function revealBoundary(text: string, position: number, complete: boolean): number {
     const end = Math.min(text.length, Math.max(0, Math.floor(position)));
+
     if (end === text.length && complete) {
         return end;
     }
+
     let cut = end;
+
     while (cut > 0 && !isSpace(text, cut) && !isSpace(text, cut - 1)) {
         cut -= 1;
     }
+
     if (end - cut <= REVEAL_MAX_HELD_WORD) {
         return cut;
     }
+
     // Half of a surrogate pair renders as a replacement box.
     const last = text.charCodeAt(end - 1);
+
     return last >= 0xd800 && last <= 0xdbff ? end - 1 : end;
 }
 
@@ -91,6 +99,7 @@ export function useRevealedText(text: string, streaming: boolean): RevealedText
         if (!streaming || activeRef.current) {
             return;
         }
+
         position.current = latest.current.text.length;
         shownRef.current = revealBoundary(latest.current.text, position.current, false);
         activeRef.current = true;
@@ -102,9 +111,11 @@ export function useRevealedText(text: string, streaming: boolean): RevealedText
         if (!active) {
             return;
         }
+
         let frame = 0;
         let previous: number | null = null;
         let grewAt = -Infinity;
+
         const tick = (now: number) => {
             const elapsed = previous === null ? 0 : now - previous;
             previous = now;
@@ -112,24 +123,31 @@ export function useRevealedText(text: string, streaming: boolean): RevealedText
             const finished = !current.streaming;
             position.current = advanceReveal(position.current, current.text.length, elapsed, finished);
             const length = revealBoundary(current.text, position.current, finished);
+
             if (length !== shownRef.current) {
                 shownRef.current = length;
                 grewAt = now;
                 setShown(length);
             }
+
             if (finished && length >= current.text.length && now - grewAt >= FADE_SETTLE_MS) {
                 activeRef.current = false;
                 setActive(false);
+
                 return;
             }
+
             frame = requestAnimationFrame(tick);
         };
+
         frame = requestAnimationFrame(tick);
+
         return () => cancelAnimationFrame(frame);
     }, [active]);
 
     if (!active) {
         return { text, active: false };
     }
+
     return { text: text.slice(0, Math.min(shown, text.length)), active: true };
 }

package/src/chat/ui/rows/ForksRow.tsx

@@ -16,12 +16,15 @@ export function ForksRow({ chatId, turnId }: { chatId: string; turnId: string })
     const { t } = useTranslation('agent-chat');
     const forks = useForkIdsAfter(chatId, turnId);
     const label = t('work.forksAfter', { count: forks.length });
+
     if (forks.length === 0) {
         return null;
     }
+
     if (forks.length === 1) {
         return <OneFork forkId={forks[0]!} label={label} />;
     }
+
     return (
         <div className="flex">
             <Menu.Root>
@@ -53,6 +56,7 @@ function ForksLabel({ label, link = true }: { label: string; link?: boolean }) {
 // A fork no longer in this project has nowhere to lead, so it only says it is there.
 function OneFork({ forkId, label }: { forkId: string; label: string }) {
     const place = useHostChatPlace(forkId);
+
     return (
         <div className="flex">
             {place.title === null ? (
@@ -71,6 +75,7 @@ function OneFork({ forkId, label }: { forkId: string; label: string }) {
 function ForkItem({ forkId }: { forkId: string }) {
     const { t } = useTranslation('agent-chat');
     const place = useHostChatPlace(forkId);
+
     return (
         <Menu.Item disabled={place.title === null} onClick={place.go}>
             <Icon icon={GitFork} size={14} /> <span className="truncate">{place.title ?? t('fork.pill.label')}</span>

package/src/chat/ui/rows/GeneratedImageRow.tsx

@@ -27,13 +27,17 @@ const savedPaths = new Map<string, string>();
 /* True for `ms` after `start()`, for a check mark that says an action landed. */
 function useFlash(ms: number): [boolean, () => void] {
     const [on, setOn] = useState(false);
+
     useEffect(() => {
         if (!on) {
             return;
         }
+
         const timer = setTimeout(() => setOn(false), ms);
+
         return () => clearTimeout(timer);
     }, [on, ms]);
+
     return [on, () => setOn(true)];
 }
 
@@ -71,15 +75,18 @@ function SavedFile({ path }: { path: string }) {
     const { id } = useChatScope();
     const { fileLinks } = useChatHost();
     const openFileLink = useOpenFileLink();
+
     const chip = (
         <>
             <FileIcon path={path} size={14} />
             <span className="truncate">{path}</span>
         </>
     );
+
     if (fileLinks === null) {
         return <span className={clsx(CHIP_IN_MESSAGE, MENTION_TONE)}>{chip}</span>;
     }
+
     return (
         <button
             type="button"
@@ -124,8 +131,10 @@ function ReadyImage({ chatId, attachment, prompt, transparent }: { chatId: strin
             ? undefined
             : async (): Promise<void> => {
                   setSaving(true);
+
                   try {
                       const path = await saveToProject(scopeId, chatId, attachment.id, attachment.name);
+
                       if (path !== null) {
                           savedPaths.set(savedKey, path);
                           setSavedPath(path);
@@ -229,6 +238,7 @@ export function GeneratedImageRow({ chatId, tool: derived }: { chatId: string; t
     const { t } = useTranslation('agent-chat');
     const tool = useCurrentItem(chatId, derived);
     const view = generatedImageView(tool);
+
     switch (view.state) {
         case 'generating':
             return <HeadLine label={t('generatedImage.generating')} live startedAt={toolStartedAt(tool)} />;