@adecore/agents-react 0.21.0 → 0.21.2

package/src/chat/drafts.ts

@@ -28,14 +28,6 @@ const storage = persistedJson<Record<string, DraftRecord>>(
     () => chatStorageLegacyKeys('drafts')
 );
 
-function readAll(): Record<string, DraftRecord> {
-    return storage.read();
-}
-
-function store(drafts: Record<string, DraftRecord>): boolean {
-    return storage.write(drafts);
-}
-
 export function isEmptyDraft(draft: ChatDraft): boolean {
     return draft.text.trim() === '' && draft.attachments.length === 0 && draft.quote === '';
 }
@@ -46,7 +38,7 @@ export function isEmptyDraft(draft: ChatDraft): boolean {
  */
 export const useDrafts = createChatStore<{ ids: string[] }>(
     () => ({ ids: [] }),
-    (store) => store.setState({ ids: Object.keys(readAll()) })
+    (store) => store.setState({ ids: Object.keys(storage.read()) })
 );
 
 export function useHasDraft(chatId: string): boolean {
@@ -63,7 +55,7 @@ function trackDraft(chatId: string, held: boolean): void {
 
 /* An unsent prompt per chat node, kept across reloads so a half-written message is never lost. */
 export function readDraft(chatId: string): ChatDraft {
-    const record = readAll()[chatId];
+    const record = storage.read()[chatId];
     return record
         ? {
               text: record.text,
@@ -77,11 +69,11 @@ export function readDraft(chatId: string): ChatDraft {
 }
 
 export function writeDraft(chatId: string, draft: ChatDraft): void {
-    const drafts = readAll();
+    const drafts = storage.read();
     trackDraft(chatId, !isEmptyDraft(draft));
     if (isEmptyDraft(draft)) {
         delete drafts[chatId];
-        store(drafts);
+        storage.write(drafts);
         return;
     }
     drafts[chatId] = {
@@ -92,12 +84,12 @@ export function writeDraft(chatId: string, draft: ChatDraft): void {
         attachments: draft.attachments,
         quote: draft.quote
     };
-    if (store(drafts)) {
+    if (storage.write(drafts)) {
         return;
     }
     // A file can outgrow the storage quota; the text is the part worth keeping then.
     drafts[chatId] = { text: draft.text, mentions: draft.mentions, skills: draft.skills, chats: draft.chats, quote: draft.quote };
-    store(drafts);
+    storage.write(drafts);
 }
 
 /* Text handed to a draft from outside the composer goes under what was already typed, never over it. */

package/src/chat/logic/ansi.ts

@@ -164,7 +164,7 @@ function styleOf(state: AnsiState): CSSProperties {
     return style;
 }
 
-export function parseAnsi(text: string, options: { limit?: number; tailLines?: number } = {}): { tokens: AnsiToken[]; omitted: number } {
+function styledTokens(text: string): AnsiToken[] {
     const tokens: AnsiToken[] = [];
     let state: AnsiState = {};
     let position = 0;
@@ -180,7 +180,11 @@ export function parseAnsi(text: string, options: { limit?: number; tailLines?: n
     if (position < text.length) {
         tokens.push({ content: text.slice(position), style: styleOf(state) });
     }
+    return tokens;
+}
 
+export function parseAnsi(text: string, options: { limit?: number; tailLines?: number } = {}): { tokens: AnsiToken[]; omitted: number } {
+    const tokens = styledTokens(text);
     const plain = tokens.map((token) => token.content).join('');
     let start = 0;
     let end = plain.length;

package/src/chat/logic/fork.ts

@@ -172,20 +172,19 @@ export function forkPayload(input: {
     worktree?: ForkWorktreeChoice | null;
     cli?: { original: ForkCliChoice; chosen: ForkCliChoice };
 }): ChatForkPayload {
+    const { cli, worktree } = input;
+    const provider = cli !== undefined && cli.chosen.provider !== cli.original.provider ? cli.chosen.provider : null;
+    const selection = cli !== undefined && (provider !== null || cli.chosen.selection.model !== cli.original.selection.model) ? cli.chosen.selection : null;
+    const account = cli?.chosen.account !== undefined && (provider !== null || cli.chosen.account !== cli.original.account) ? cli.chosen.account : null;
     return {
         chatId: input.chatId,
         turnId: input.turnId,
         title: input.title,
         ...(input.shape === 'view' ? { asView: true } : {}),
-        ...(input.cli && input.cli.chosen.provider !== input.cli.original.provider ? { provider: input.cli.chosen.provider } : {}),
-        ...(input.cli && (input.cli.chosen.provider !== input.cli.original.provider || input.cli.chosen.selection.model !== input.cli.original.selection.model)
-            ? { selection: input.cli.chosen.selection }
-            : {}),
-        ...(input.cli?.chosen.account !== undefined &&
-        (input.cli.chosen.provider !== input.cli.original.provider || input.cli.chosen.account !== input.cli.original.account)
-            ? { account: input.cli.chosen.account }
-            : {}),
-        ...(input.worktree ? { worktree: { branch: input.worktree.branch }, ...(input.worktree.filesAfterTurn ? { filesAfterTurn: true } : {}) } : {})
+        ...(provider === null ? {} : { provider }),
+        ...(selection === null ? {} : { selection }),
+        ...(account === null ? {} : { account }),
+        ...(worktree ? { worktree: { branch: worktree.branch }, ...(worktree.filesAfterTurn ? { filesAfterTurn: true } : {}) } : {})
     };
 }
 

package/src/chat/logic/limit.ts

@@ -27,20 +27,21 @@ export function limitView(info: Pick<ChatInfo, 'limit' | 'resumeAt' | 'activeTur
             detail: resumes === null ? i18next.t('agent-chat:limit.overload.sendAgain') : i18next.t('agent-chat:limit.overload.retries', { time: resumes })
         };
     }
-    const resets = limit.resetsAt === undefined ? null : formatMoment(limit.resetsAt, now);
-    return {
-        pill:
-            resumes !== null
-                ? i18next.t('agent-chat:limit.usage.pillResumes', { time: resumes })
-                : resets !== null
-                  ? i18next.t('agent-chat:limit.usage.pillUntil', { time: resets })
-                  : i18next.t('agent-chat:limit.usage.pill'),
-        title: i18next.t('agent-chat:limit.usage.title'),
-        detail:
-            resumes !== null
-                ? i18next.t('agent-chat:limit.usage.resumes', { time: resumes })
-                : resets !== null
-                  ? i18next.t('agent-chat:limit.usage.resets', { time: resets })
-                  : null
-    };
+    const title = i18next.t('agent-chat:limit.usage.title');
+    if (resumes !== null) {
+        return {
+            pill: i18next.t('agent-chat:limit.usage.pillResumes', { time: resumes }),
+            title,
+            detail: i18next.t('agent-chat:limit.usage.resumes', { time: resumes })
+        };
+    }
+    if (limit.resetsAt !== undefined) {
+        const resets = formatMoment(limit.resetsAt, now);
+        return {
+            pill: i18next.t('agent-chat:limit.usage.pillUntil', { time: resets }),
+            title,
+            detail: i18next.t('agent-chat:limit.usage.resets', { time: resets })
+        };
+    }
+    return { pill: i18next.t('agent-chat:limit.usage.pill'), title, detail: null };
 }

package/src/chat/logic/resume-compaction.ts

@@ -16,19 +16,10 @@ export interface ResumeCompactionOffer {
 }
 
 function lastTurn(items: readonly ChatItem[]): Extract<ChatItem, { kind: 'turn' }> | null {
-    for (let i = items.length - 1; i >= 0; i--) {
-        const item = items[i]!;
-        if (item.kind === 'turn') {
-            return item;
-        }
-    }
-    return null;
+    return items.findLast((item): item is Extract<ChatItem, { kind: 'turn' }> => item.kind === 'turn') ?? null;
 }
 
-/*
- * Whether to offer compacting before the next message. The caller passes `now`, so this stays pure
- * and the test needs no clock.
- */
+/* Whether to offer compacting before the next message. */
 export function resumeCompactionOffer({
     info,
     compaction,

package/src/chat/logic/scrubber.ts

@@ -127,19 +127,10 @@ export function tickOfRow(ticks: readonly ScrubberTick[], rowIndex: number): num
     if (ticks.length === 0) {
         return null;
     }
-    let low = 0;
-    let high = ticks.length - 1;
-    let found = 0;
-    while (low <= high) {
-        const middle = (low + high) >> 1;
-        if (ticks[middle]!.rowIndex <= rowIndex) {
-            found = middle;
-            low = middle + 1;
-        } else {
-            high = middle - 1;
-        }
-    }
-    return found;
+    return Math.max(
+        0,
+        lastIndexAtOrBelow(ticks.length, (index) => ticks[index]!.rowIndex, rowIndex)
+    );
 }
 
 /* Per tick, whether any of the rows has a find hit in its stretch. */
@@ -199,14 +190,14 @@ export function tickWidth(kind: TickKind, distanceFromPointer: number | null): n
     return kind === 'wake' ? WIDTH_WAKE_PX : WIDTH_PERSON_PX;
 }
 
-/* The last index whose start lies at or above a line, or -1. The starts only grow. */
-function lastAtOrAbove(starts: readonly number[], line: number): number {
+/* The last index whose value is at most `limit`, or -1. The values only grow. */
+function lastIndexAtOrBelow(length: number, valueAt: (index: number) => number, limit: number): number {
     let low = 0;
-    let high = starts.length - 1;
+    let high = length - 1;
     let found = -1;
     while (low <= high) {
         const middle = (low + high) >> 1;
-        if (starts[middle]! <= line) {
+        if (valueAt(middle) <= limit) {
             found = middle;
             low = middle + 1;
         } else {
@@ -216,6 +207,11 @@ function lastAtOrAbove(starts: readonly number[], line: number): number {
     return found;
 }
 
+/* The last index whose start lies at or above a line, or -1. */
+function lastAtOrAbove(starts: readonly number[], line: number): number {
+    return lastIndexAtOrBelow(starts.length, (index) => starts[index]!, line);
+}
+
 export interface ReadingPosition {
     /* Where each message's row starts in the thread, in the virtualizer's measurements. */
     starts: readonly number[];

package/src/chat/logic/timeline.ts

@@ -88,10 +88,9 @@ export function summarizeGroup(tools: ChatToolItem[]): string {
     if (only !== null && toolEntry(only)?.grouped === true) {
         return i18next.t(`agent-chat:group.tools.${only}`, { count: tools.length });
     }
-    /* A run that only touches files says so once, whether it took one tool or three, and counts the
-       files rather than the calls: three edits to one file are one file edited. */
+    // Counts the files rather than the calls: three edits to one file are one file edited.
     if (tools.every((tool) => isFileChange(tool.name))) {
-        const paths = new Set(tools.map((tool) => (tool.input as { file_path?: string })?.file_path ?? tool.id));
+        const paths = new Set(tools.map(editedPath));
         return i18next.t('agent-chat:group.edited', { count: paths.size });
     }
     if (only !== null) {
@@ -100,6 +99,10 @@ export function summarizeGroup(tools: ChatToolItem[]): string {
     return i18next.t('agent-chat:group.toolCalls', { count: tools.length });
 }
 
+function editedPath(tool: ChatToolItem): string {
+    return (tool.input as { file_path?: string })?.file_path ?? tool.id;
+}
+
 /*
  * What a folded turn did, a sentence per kind of call in the order it first came: "Read 11 files",
  * "Searched 2 patterns". Every file change reads as one sentence, and calls without a sentence of
@@ -112,7 +115,7 @@ export function summarizeTurn(tools: readonly ChatToolItem[]): string[] {
     let other = 0;
     for (const tool of tools) {
         if (isFileChange(tool.name)) {
-            edited.add((tool.input as { file_path?: string })?.file_path ?? tool.id);
+            edited.add(editedPath(tool));
             counts.set('agent-chat:group.edited', edited.size);
         } else if (toolEntry(tool.name)?.grouped === true) {
             const key = `agent-chat:group.tools.${tool.name}`;
@@ -345,12 +348,14 @@ function lastAssistantRow(rows: TimelineRow[]): TimelineRow | null {
     return null;
 }
 
-/* The whole thread as rows; items without a turn (older records) are shown as they are. */
-export function deriveTimelineRows(items: ChatItem[], options: TimelineOptions): TimelineRow[] {
-    const rows: TimelineRow[] = [];
-    const children = groupChildren(items);
-    // Items are grouped by turn, in order of first appearance; runs of turnless items keep their place.
-    const chunks: Array<{ turnId: string | null; items: ChatItem[] }> = [];
+interface TurnChunk {
+    turnId: string | null;
+    items: ChatItem[];
+}
+
+/* Items grouped by turn, in order of first appearance; runs of turnless items keep their place. */
+function chunksByTurn(items: ChatItem[]): TurnChunk[] {
+    const chunks: TurnChunk[] = [];
     const byTurn = new Map<string, ChatItem[]>();
     for (const item of items) {
         if (item.turnId === null) {
@@ -370,8 +375,14 @@ export function deriveTimelineRows(items: ChatItem[], options: TimelineOptions):
         }
         bucket.push(item);
     }
+    return chunks;
+}
 
-    for (const chunk of chunks) {
+/* The whole thread as rows; items without a turn (older records) are shown as they are. */
+export function deriveTimelineRows(items: ChatItem[], options: TimelineOptions): TimelineRow[] {
+    const rows: TimelineRow[] = [];
+    const children = groupChildren(items);
+    for (const chunk of chunksByTurn(items)) {
         if (chunk.turnId === null) {
             rows.push(...rowsForItems(chunk.items, options, children));
             continue;

package/src/chat/logic/tool-catalog.ts

@@ -6,8 +6,10 @@ export interface ToolEntry {
     icon: LucideIcon;
     /* The input keys that hold the one line saying what the call is about, best first. */
     summary: readonly string[];
-    /* Whether a run of calls of this name reads as a sentence of its own (`agent-chat:group.tools.<name>`).
-       One that changes files without a sentence falls to `agent-chat:group.edited`, which counts files rather than calls. */
+    /*
+     * Whether a run of calls of this name reads as a sentence of its own (`agent-chat:group.tools.<name>`).
+     * One that changes files without a sentence falls to `agent-chat:group.edited`, which counts files.
+     */
     grouped: boolean;
     /* Whether the call writes to a file, which is what a mixed run of calls is named after. */
     changesFiles: boolean;
@@ -27,10 +29,9 @@ function entry(icon: LucideIcon, summary: readonly string[], rest: Partial<ToolE
 }
 
 /*
- * The icon, the summary line, the group sentence and the file-changing flag of every tool the thread
- * has a word for, in one table, because they used to sit in four and a name added to one of them was
- * missing from the rest. A name that is not here still draws, reads and groups; it falls back to the
- * wrench and to the first string of its input.
+ * Every tool the thread has a word for, in one table so a new name is never missing from a lookup. A
+ * name that is not here still draws, reads and groups; it falls back to the wrench and to the first
+ * string of its input.
  */
 export const TOOL_CATALOG: Record<string, ToolEntry> = {
     Read: entry(Eye, ['file_path'], { readsImage: true }),

package/src/chat/mentions.ts

@@ -1,5 +1,7 @@
-/* What a file dragged out of an app's own list of files carries: the paths, space separated, relative
-   to the folder. The composer takes it next to the image files it already accepts. */
+/*
+ * What a file dragged out of an app's own list of files carries: the paths, space separated, relative
+ * to the folder. The composer takes it next to the image files it already accepts.
+ */
 export const MENTION_DRAG_TYPE = 'application/x-adecore-mention';
 export const LEGACY_MENTION_DRAG_TYPE = 'application/x-ruimte-mention';
 export const MENTION_DRAG_TYPES = [MENTION_DRAG_TYPE, LEGACY_MENTION_DRAG_TYPE] as const;
@@ -145,10 +147,7 @@ export function presentSkills(text: string, chosen: string[]): string[] {
     return present(text, '$', chosen);
 }
 
-/*
- * The characters a segment stands for, sigil included. Joined, the segments spell the text they
- * were cut from.
- */
+/* The characters a segment stands for, sigil included; joined, the segments spell the text they were cut from. */
 export function chipText(segment: ChipSegment): string {
     if (segment.kind === 'mention') {
         return `@${segment.path}`;

package/src/chat/runtime-modes.ts

@@ -2,10 +2,8 @@ import i18next from 'i18next';
 import { RuntimeModeSchema, type RuntimeMode } from '@adecore/agent-contracts';
 
 /*
- * The runtime modes in the order they are offered, shared by the composer's mode picker, the
- * settings dialog and the agent menus. That order is the schema's, which the host reads as the
- * rank from narrowest to widest. Only the ids live here: the words are in `modes.<id>` of the `chat`
- * namespace, read when a surface draws one rather than when this module loads.
+ * The runtime modes in the order they are offered: the schema's, which the host reads as the rank
+ * from narrowest to widest. Their words are read when a surface draws one, not when this module loads.
  */
 export const RUNTIME_MODES: readonly RuntimeMode[] = RuntimeModeSchema.options;
 

package/src/chat/stash.ts

@@ -94,9 +94,7 @@ export function stashedFrom(draft: ChatDraft, id: string, now: number): StashedP
 
 const storage = persistedJson<StashedPrompt[]>(storageKey, parseStash, [], () => chatStorageLegacyKeys('stash'));
 
-/*
- * Prompts put aside for later can move to another chat, so the shelf is shared across chats.
- */
+/* Prompts put aside for later can move to another chat, so the shelf is shared across chats. */
 export const useStash = createChatStore<{ prompts: StashedPrompt[] }>(
     () => ({ prompts: [] }),
     (store) => store.setState({ prompts: storage.read() })

package/src/chat/thumbnails.ts

@@ -45,10 +45,9 @@ function dataUrlOf(blob: Blob): Promise<string> {
 }
 
 /*
- * A still of the middle of an image, decoded once. The composer used to draw the full data URL in a
- * 56 px box, which a browser decodes again for every paint, so a tall screenshot made typing stutter.
- * An animated image gives its first frame. Whatever cannot be decoded this way (an SVG, a browser
- * without `OffscreenCanvas`) falls back to the image itself, which is what it was before.
+ * A still of the middle of an image, decoded once: a browser decodes a full data URL again on every
+ * paint, so a tall screenshot made typing stutter. An animated image gives its first frame; what
+ * cannot be decoded this way (an SVG, a browser without `OffscreenCanvas`) falls back to the image.
  */
 async function makeThumbnail(upload: ChatAttachmentUpload): Promise<string> {
     try {

package/src/chat/timeline-scroll.ts

@@ -10,6 +10,10 @@ type Scroller = {
 
 const scrollers = new Map<string, Scroller>();
 
+/* The timeline owns following; the composer subscribes here to show its jump-to-end button. */
+const ends = new Map<string, boolean>();
+const listeners = new Set<() => void>();
+
 /* The timeline hands its scroller over so the composer, which never sees it, can page through it. */
 export function registerTimeline(
     chatId: string,
@@ -29,10 +33,6 @@ export function registerTimeline(
     };
 }
 
-/* The timeline owns following; the composer subscribes here to show its jump-to-end button. */
-const ends = new Map<string, boolean>();
-const listeners = new Set<() => void>();
-
 export function setTimelineAtEnd(chatId: string, atEnd: boolean): void {
     if (ends.get(chatId) === atEnd) {
         return;
@@ -97,72 +97,63 @@ export function stepTimelineMessage(key: string, direction: -1 | 1): boolean {
 }
 
 /*
- * A jump to one message of a chat, asked from outside its thread (the chat's menu). A thread that is
- * not on screen yet gets it when it registers, since the menu may have to show the chat first.
- * Keyed with the scope's `keyOf`, like the steppers.
+ * Jumps asked from outside a thread (the chat's menu, a card that names a turn), keyed with the
+ * scope's `keyOf` like the steppers. A thread that is not on screen yet gets its jump when it
+ * registers, since the asker may have to show the chat first.
  */
-const jumpers = new Map<string, (itemId: string) => void>();
-const waitingJumps = new Map<string, string>();
-
-export function registerItemJumper(key: string, jump: (itemId: string) => void): () => void {
-    jumpers.set(key, jump);
-    const waiting = waitingJumps.get(key);
-    if (waiting !== undefined) {
-        waitingJumps.delete(key);
-        jump(waiting);
-    }
-    return () => {
-        if (jumpers.get(key) === jump) {
-            jumpers.delete(key);
+function waitingJumps<T>(): { register(key: string, jump: (target: T) => void): () => void; jump(key: string, target: T): boolean } {
+    const jumpers = new Map<string, (target: T) => void>();
+    const waiting = new Map<string, T>();
+    return {
+        register(key, jump) {
+            jumpers.set(key, jump);
+            if (waiting.has(key)) {
+                const target = waiting.get(key)!;
+                waiting.delete(key);
+                jump(target);
+            }
+            return () => {
+                if (jumpers.get(key) === jump) {
+                    jumpers.delete(key);
+                }
+            };
+        },
+        jump(key, target) {
+            const jump = jumpers.get(key);
+            if (jump === undefined) {
+                waiting.set(key, target);
+                return false;
+            }
+            jump(target);
+            return true;
         }
     };
 }
 
+const itemJumps = waitingJumps<string>();
+
+export function registerItemJumper(key: string, jump: (itemId: string) => void): () => void {
+    return itemJumps.register(key, jump);
+}
+
 /* False when that chat has no thread on screen; the jump then waits for the next one that registers. */
 export function jumpToTimelineItem(key: string, itemId: string): boolean {
-    const jump = jumpers.get(key);
-    if (jump === undefined) {
-        waitingJumps.set(key, itemId);
-        return false;
-    }
-    jump(itemId);
-    return true;
+    return itemJumps.jump(key, itemId);
 }
 
-/*
- * A jump to the turn of a chat, for a card that says which turn wrote something: the message that opened
- * it, or the files it changed. Kept like the jump to an item, so a chat that is not on screen yet gets it
- * when its thread registers.
- */
+/* Which part of a turn a jump lands on: the message that opened it, or the files it changed. */
 export type TurnTarget = 'prompt' | 'changes';
 
 type TurnJump = (turnId: string, target: TurnTarget) => void;
-const turnJumpers = new Map<string, TurnJump>();
-const waitingTurnJumps = new Map<string, { turnId: string; target: TurnTarget }>();
+const turnJumps = waitingJumps<{ turnId: string; target: TurnTarget }>();
 
 export function registerTurnJumper(key: string, jump: TurnJump): () => void {
-    turnJumpers.set(key, jump);
-    const waiting = waitingTurnJumps.get(key);
-    if (waiting !== undefined) {
-        waitingTurnJumps.delete(key);
-        jump(waiting.turnId, waiting.target);
-    }
-    return () => {
-        if (turnJumpers.get(key) === jump) {
-            turnJumpers.delete(key);
-        }
-    };
+    return turnJumps.register(key, ({ turnId, target }) => jump(turnId, target));
 }
 
 /* False when that chat has no thread on screen; the jump then waits for the next one that registers. */
 export function jumpToTimelineTurn(key: string, turnId: string, target: TurnTarget): boolean {
-    const jump = turnJumpers.get(key);
-    if (jump === undefined) {
-        waitingTurnJumps.set(key, { turnId, target });
-        return false;
-    }
-    jump(turnId, target);
-    return true;
+    return turnJumps.jump(key, { turnId, target });
 }
 
 /* How near the top, in screens, the page before is asked for, so it is there before a reader reaches the edge. */

package/src/chat/ui/BookmarkSubmenu.tsx

@@ -9,11 +9,7 @@ import { useChatScope } from '../../scope';
 import { useChatRow } from '../../state/chats';
 import { Icon, Menu } from '@adecore/ui';
 
-/*
- * "Bookmarks" in the menu of a chat node or a chat view: the chat's bookmarks in the order of the
- * thread, each a jump to its message, with rename and remove on the row. A chat without bookmarks
- * draws nothing.
- */
+/* A chat's bookmarks in thread order, each a jump to its message with rename and remove; nothing without bookmarks. */
 export function BookmarkSubmenu({ chatId }: { chatId: string }) {
     const { t } = useTranslation('agent-chat');
     const scope = useChatScope();

package/src/chat/ui/CodeBlock.tsx

@@ -123,9 +123,8 @@ const CodeLine = memo(function CodeLine({ tokens }: { tokens: CodeToken[] }) {
 
 /*
  * A fenced block, highlighted a line at a time. Until shiki and the grammar are there it holds its
- * place invisibly in the same shape, so there is never a frame of bare code that turns colored. A
- * fence that is still open is tokenized as it grows, and the same component carries on once it
- * closes, so closing it does not draw it again.
+ * place invisibly, so bare code never turns colored. An open fence is tokenized as it grows, and
+ * closing it does not draw it again.
  */
 export function CodeBlock({ code, lang, actions }: { code: string; lang: string; actions?: ReactNode }) {
     const { t } = useTranslation('agent-chat');