@adecore/agents-react 0.39.0 → 0.40.1

package/src/chat/index.ts

@@ -8,6 +8,7 @@ export { stepEffortFromComposer } from './composer-effort';
 export type { EffortStep } from './logic/effort';
 export { EMPTY_DRAFT, useDrafts, readDraft, writeDraft, offerDraft, type ChatDraft } from './drafts';
 export { stripAnsi } from './logic/ansi';
+
 export {
     FORKABLE_PROVIDERS,
     forkRefusal,
@@ -23,6 +24,7 @@ export {
     type ForkPoint,
     type ForkWorktreeChoice
 } from './logic/fork';
+
 export { matchCommandLook, type CommandLookRun, type CommandLookWord } from './logic/command-looks';
 export { handbackReportOf } from './logic/handback';
 export { limitView, type LimitView } from './logic/limit';
@@ -31,6 +33,7 @@ export { type TimedRow, withTimedRows, timedRowsOf } from './logic/thread-cards'
 export { EMPTY_TARGET, readTimelineTarget, type TimelineTarget } from './logic/timeline-target';
 export { type TimelineRow, summarizeGroup, deriveTimelineRows, type SubagentBranch, type BaseMoved } from './logic/timeline';
 export { toolSummary, type FileChange } from './logic/tools';
+
 export {
     MENTION_DRAG_TYPE,
     LEGACY_MENTION_DRAG_TYPE,
@@ -41,6 +44,7 @@ export {
     type MentionQuery,
     type ChipSegment
 } from './mentions';
+
 export {
     defaultProvider,
     selectionFor,
@@ -57,6 +61,7 @@ export {
     rememberChatSelection,
     type ChatPreferences
 } from './preferences';
+
 export type { HoldRelease } from './prompt-hold';
 export { CHAT_READING_WIDTHS, readingWidthLabel, readingWidthHint, type ChatReadingWidth } from './reading-width';
 export { recentChatMessages, recentSubagentMessages, type RecentChatMessage, type RecentChatMessages } from './recent-messages';
@@ -65,6 +70,7 @@ export { CHAT_SEND_KEYS, SEND_AND_NEW_SHORTCUT, sendKeyLabel, sendKeyHint, type
 export type { StashedAttachment, StashedPrompt, StashedQuote } from './stash';
 export { subagentTitle, summaryWordOf, stopOf, type SubagentStop } from './subagent-list';
 export { useSubagentSupport } from './subagent-support';
+
 export {
     crumbOf,
     openFromMain,
@@ -76,6 +82,7 @@ export {
     type SubagentStep,
     type SubagentTrail
 } from './subagent-view';
+
 export { stepTimelineMessage, jumpToTimelineItem, type TurnTarget, registerTurnJumper, jumpToTimelineTurn, type ItemJumpOptions } from './timeline-scroll';
 export { type StatusWord, statusLookOf, taskStatusWord, type StatusLook, type TaskState } from '../agents/status-look';
 

package/src/chat/logic/ansi.ts

@@ -18,6 +18,7 @@ interface AnsiState {
 
 const COLORS = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
 const COLOR_LEVELS = [0, 95, 135, 175, 215, 255];
+
 // Consume non-color controls too, so cursor commands and OSC links never become visible text or HTML.
 /* oxlint-disable no-control-regex */
 const ESCAPES =
@@ -32,6 +33,7 @@ function rgb(channels: number[]): string | undefined {
     if (channels.length !== 3 || channels.some((channel) => !Number.isInteger(channel) || channel < 0 || channel > 255)) {
         return undefined;
     }
+
     return `rgb(${channels.join(' ')})`;
 }
 
@@ -39,27 +41,36 @@ function paletteColor(index: number): string | undefined {
     if (!Number.isInteger(index) || index < 0 || index > 255) {
         return undefined;
     }
+
     if (index < 16) {
         return `var(--term-ansi-${index >= 8 ? 'bright-' : ''}${COLORS[index % 8]})`;
     }
+
     if (index < 232) {
         const cube = index - 16;
+
         return rgb([COLOR_LEVELS[Math.floor(cube / 36)]!, COLOR_LEVELS[Math.floor(cube / 6) % 6]!, COLOR_LEVELS[cube % 6]!]);
     }
+
     const gray = 8 + (index - 232) * 10;
+
     return rgb([gray, gray, gray]);
 }
 
 function extendedColor(parameters: string[]): string | undefined {
     const mode = parameters[0];
+
     if (mode === '5' && parameters.length === 2 && parameters[1] !== '') {
         return paletteColor(Number(parameters[1]));
     }
+
     if (mode === '2') {
         // Colon-form RGB may include an empty color-space parameter before its three channels.
         const channels = parameters.length === 5 ? parameters.slice(2) : parameters.slice(1);
+
         return rgb(channels.map((channel) => (channel === '' ? NaN : Number(channel))));
     }
+
     return undefined;
 }
 
@@ -67,12 +78,16 @@ function applyRendition(state: AnsiState, parameters: string): AnsiState {
     if (!/^[\d;:]*$/.test(parameters)) {
         return state;
     }
+
     const values = parameters.split(';');
+
     for (let i = 0; i < values.length; i++) {
         const parts = values[i]!.split(':');
         const code = Number(parts[0]);
+
         if (code === 38 || code === 48) {
             let color: string | undefined;
+
             if (parts.length > 1) {
                 color = extendedColor(parts.slice(1));
             } else {
@@ -80,6 +95,7 @@ function applyRendition(state: AnsiState, parameters: string): AnsiState {
                 color = extendedColor(values.slice(i + 1, i + 1 + count));
                 i += count;
             }
+
             if (color !== undefined) {
                 state[code === 38 ? 'foreground' : 'background'] = color;
             }
@@ -95,50 +111,65 @@ function applyRendition(state: AnsiState, parameters: string): AnsiState {
             switch (code) {
                 case 0:
                     state = {};
+
                     break;
                 case 1:
                     state.bold = true;
+
                     break;
                 case 2:
                     state.dim = true;
+
                     break;
                 case 3:
                     state.italic = true;
+
                     break;
                 case 4:
                     state.underline = parts[1] !== '0';
+
                     break;
                 case 7:
                     state.inverse = true;
+
                     break;
                 case 9:
                     state.strike = true;
+
                     break;
                 case 22:
                     state.bold = false;
                     state.dim = false;
+
                     break;
                 case 23:
                     state.italic = false;
+
                     break;
                 case 24:
                     state.underline = false;
+
                     break;
                 case 27:
                     state.inverse = false;
+
                     break;
                 case 29:
                     state.strike = false;
+
                     break;
                 case 39:
                     state.foreground = undefined;
+
                     break;
                 case 49:
                     state.background = undefined;
+
                     break;
             }
         }
     }
+
     return state;
 }
 
@@ -146,21 +177,27 @@ function styleOf(state: AnsiState): CSSProperties {
     const style: CSSProperties = {};
     const color = state.inverse ? (state.background ?? 'var(--chat-code-bg)') : state.foreground;
     const background = state.inverse ? (state.foreground ?? 'var(--chat-output)') : state.background;
+
     if (color !== undefined || state.dim) {
         style.color = state.dim ? `color-mix(in srgb, ${color ?? 'currentColor'} 65%, transparent)` : color;
     }
+
     if (background !== undefined) {
         style.backgroundColor = background;
     }
+
     if (state.bold) {
         style.fontWeight = 'bold';
     }
+
     if (state.italic) {
         style.fontStyle = 'italic';
     }
+
     if (state.underline || state.strike) {
         style.textDecorationLine = [state.underline && 'underline', state.strike && 'line-through'].filter(Boolean).join(' ');
     }
+
     return style;
 }
 
@@ -168,18 +205,23 @@ function styledTokens(text: string): AnsiToken[] {
     const tokens: AnsiToken[] = [];
     let state: AnsiState = {};
     let position = 0;
+
     for (const match of text.matchAll(ESCAPES)) {
         if (match.index > position) {
             tokens.push({ content: text.slice(position, match.index), style: styleOf(state) });
         }
+
         if (match[2] === 'm') {
             state = applyRendition(state, match[1]!);
         }
+
         position = match.index + match[0].length;
     }
+
     if (position < text.length) {
         tokens.push({ content: text.slice(position), style: styleOf(state) });
     }
+
     return tokens;
 }
 
@@ -188,21 +230,26 @@ export function parseAnsi(text: string, options: { limit?: number; tailLines?: n
     const plain = tokens.map((token) => token.content).join('');
     let start = 0;
     let end = plain.length;
+
     if (options.tailLines !== undefined) {
         if (plain.endsWith('\n')) {
             end--;
         }
+
         const tail = plain.slice(0, end).split('\n').slice(-options.tailLines).join('\n');
         start = end - tail.length;
     }
+
     const omitted = options.limit === undefined ? 0 : Math.max(0, end - start - options.limit);
     end -= omitted;
     let offset = 0;
+
     return {
         tokens: tokens.flatMap((token) => {
             const from = Math.max(0, start - offset);
             const to = Math.min(token.content.length, end - offset);
             offset += token.content.length;
+
             return to > from ? [{ ...token, content: token.content.slice(from, to) }] : [];
         }),
         omitted

package/src/chat/logic/bookmarks.ts

@@ -9,7 +9,9 @@ export function bookmarkLabel(bookmark: ChatBookmark): string {
 /* The bookmarks in the order of the thread; one whose message this client does not hold goes last. */
 export function bookmarksInThreadOrder(bookmarks: readonly ChatBookmark[], order: readonly string[]): ChatBookmark[] {
     const places = new Map(order.map((id, index) => [id, index]));
+
     const place = (bookmark: ChatBookmark): number => places.get(bookmark.itemId) ?? order.length;
+
     return [...bookmarks].sort((left, right) => place(left) - place(right) || left.createdAt - right.createdAt);
 }
 
@@ -25,18 +27,23 @@ export function bookmarkRows(
 ): Map<string, ChatBookmark> {
     const rowIds = new Set(rows.map((row) => row.id));
     const folds = new Map<string, string>();
+
     for (const row of rows) {
         if (row.kind === 'turn-fold') {
             folds.set(row.turn.id, row.id);
         }
     }
+
     const marked = new Map<string, ChatBookmark>();
+
     for (const bookmark of bookmarks) {
         const turnId = items[bookmark.itemId]?.turnId ?? null;
         const rowId = rowIds.has(bookmark.itemId) ? bookmark.itemId : turnId === null ? undefined : folds.get(turnId);
+
         if (rowId !== undefined && !marked.has(rowId)) {
             marked.set(rowId, bookmark);
         }
     }
+
     return marked;
 }

package/src/chat/logic/command-looks.ts

@@ -39,19 +39,25 @@ const caches = new WeakMap<readonly CommandLook[], Map<string, CommandLookRun |
 /* The look of a simple command and what it says about it, or null when no look knows it. */
 function lookOf(command: ShellSimpleCommand, looks: readonly CommandLook[]): { look: CommandLook; match: CommandLookMatch } | null {
     const program = command.program;
+
     if (program === null) {
         return null;
     }
+
     const args = command.words.slice(program.index + 1).map(({ text }) => text);
+
     for (const look of looks) {
         if (look.program !== program.name) {
             continue;
         }
+
         const match = look.describe(args);
+
         if (match !== null) {
             return { look, match };
         }
     }
+
     return null;
 }
 
@@ -59,16 +65,21 @@ function lookOf(command: ShellSimpleCommand, looks: readonly CommandLook[]): { l
 function foldedWord(source: string, word: ShellWord, fold: boolean): { text: string; body: { start: number; end: number } | null } {
     const text = source.slice(word.start, word.end);
     const body = word.body === null ? null : { start: word.body.start - word.start, end: word.body.end - word.start };
+
     if (!fold) {
         return { text, body };
     }
+
     if (body !== null && body.end - body.start > FOLD_LENGTH) {
         const cut = body.start + FOLD_LENGTH;
+
         return { text: `${text.slice(0, cut)}…${text.slice(body.end)}`, body: { start: body.start, end: cut + 1 } };
     }
+
     if (body === null && text.length > FOLD_LENGTH) {
         return { text: `${text.slice(0, FOLD_LENGTH)}…`, body: null };
     }
+
     return { text, body };
 }
 
@@ -81,25 +92,32 @@ function detailOf(source: string, command: ShellSimpleCommand, match: CommandLoo
     let previous: ShellWord | null = null;
     // The option the word before was, whose value this word may be.
     let option: string | null = null;
+
     for (const word of command.words.slice(first)) {
         if (previous !== null) {
             const gap = source.slice(previous.end, word.start);
             detail += /^[ \t]*$/.test(gap) ? gap : ' ';
         }
+
         const start = detail.length;
         const { text, body } = foldedWord(source, word, option !== null && match.fold?.includes(option) === true);
         const language = option === null ? undefined : match.languages?.[option];
+
         if (language !== undefined && body !== null && body.end > body.start) {
             code.push({ start: start + body.start, end: start + body.end, language });
         }
+
         detail += text;
         const isOption = word.text.startsWith('-') && word.text !== '-';
+
         if (!isOption) {
             words.push({ start, end: detail.length, text: word.text, option });
         }
+
         option = isOption ? word.text : null;
         previous = word;
     }
+
     return { detail, code, words };
 }
 
@@ -107,8 +125,10 @@ function read(command: string, looks: readonly CommandLook[]): CommandLookRun |
     let found: { command: ShellSimpleCommand; look: CommandLook; match: CommandLookMatch } | null = null;
     let more = 0;
     const others: string[] = [];
+
     for (const simple of shellCommands(command)) {
         const known = lookOf(simple, looks);
+
         if (known !== null && found === null) {
             found = { command: simple, ...known };
         } else if (known !== null) {
@@ -117,9 +137,11 @@ function read(command: string, looks: readonly CommandLook[]): CommandLookRun |
             others.push(simple.program.name);
         }
     }
+
     if (found === null) {
         return null;
     }
+
     return {
         look: found.look,
         match: found.match,
@@ -139,19 +161,26 @@ export function matchCommandLook(command: string, looks: readonly CommandLook[]
     if (looks === undefined || looks.length === 0 || command.length > EMBEDDED_CODE_LIMIT || !looks.some(({ program }) => command.includes(program))) {
         return null;
     }
+
     let cache = caches.get(looks);
+
     if (cache === undefined) {
         cache = new Map();
         caches.set(looks, cache);
     }
+
     const known = cache.get(command);
+
     if (known !== undefined) {
         return known;
     }
+
     const run = read(command, looks);
     cache.set(command, run);
+
     if (cache.size > CACHE_LIMIT) {
         cache.delete(cache.keys().next().value!);
     }
+
     return run;
 }

package/src/chat/logic/context-usage.ts

@@ -20,10 +20,13 @@ export function contextFraction(usage: ChatUsage): number {
 /* The stretches of the bar, in the legend's order; null from a host that does not estimate, which draws the plain bar. */
 export function contextSegments(usage: ChatUsage): ContextSegment[] | null {
     const breakdown = usage.breakdown;
+
     if (!breakdown || usage.contextTokens === 0) {
         return null;
     }
+
     const whole = Math.max(usage.contextWindow ?? 0, usage.contextTokens);
+
     return CONTEXT_PARTS.map((part) => ({ part, tokens: breakdown[part], fraction: breakdown[part] / whole }));
 }
 

package/src/chat/logic/continue-after-stop.ts

@@ -18,15 +18,20 @@ export function continuableTurn(info: ChatInfo, items: readonly ChatItem[]): str
     ) {
         return null;
     }
+
     const index = items.findLastIndex((item) => item.kind === 'turn');
     const turn = items[index];
+
     if (turn?.kind !== 'turn' || turn.state !== 'aborted' || turn.limit !== undefined || abortedByMachine(turn, items) || abortedByEnd(turn, items)) {
         return null;
     }
+
     // A message of this turn sits after the turn item too, so only one sent after the turn ended counts.
     const endedAt = turn.endedAt ?? turn.createdAt;
+
     if (items.slice(index + 1).some((item) => item.kind === 'user' && item.createdAt > endedAt)) {
         return null;
     }
+
     return turn.id;
 }

package/src/chat/logic/effort.ts

@@ -16,17 +16,21 @@ export type EffortStepResult =
 /* One step of effort within what the model offers. A value the model no longer offers counts as its default. */
 export function stepEffort(model: ModelInfo | undefined, selection: ModelSelection, step: EffortStep): EffortStepResult {
     const option = model?.options.find((candidate) => candidate.id === EFFORT_OPTION);
+
     if (option === undefined || option.type !== 'select') {
         return { kind: 'none' };
     }
+
     const chosen = selection.options[EFFORT_OPTION];
     const index = option.choices.findIndex((choice) => choice.id === chosen);
     const from = index === -1 ? option.choices.findIndex((choice) => choice.id === option.defaultChoice) : index;
     const current = Math.max(0, from);
     const next = current + (step === 'up' ? 1 : -1);
     const choice = option.choices[next];
+
     if (choice === undefined) {
         return { kind: 'edge', choice: option.choices[current]! };
     }
+
     return { kind: 'stepped', selection: { ...selection, options: { ...selection.options, [EFFORT_OPTION]: choice.id } }, choice };
 }