@adecore/agents-react 0.38.0 → 0.40.0

package/src/chat/ui/diff/EditorEditDiff.tsx

@@ -40,6 +40,7 @@ function ReadyDiff({
     const theme = useHostCodeThemes()[mode];
     const language = getFiletypeFromFileName(path);
     const tokens = useDiffSourceTokens(document, language, theme);
+
     return (
         <DiffView
             engine={engine}
@@ -79,38 +80,48 @@ export function EditorDocumentDiff({
     const { t } = useTranslation('agent-chat');
     const withinLimits = canRenderEditorDiff(document);
     const [loaded, setLoaded] = useState<{ load: EngineLoader; engine: EditorEngine | null }>();
+
     useEffect(() => {
         if (!withinLimits || engines.has(loadEngine)) {
             return;
         }
+
         let active = true;
+
         void Promise.resolve()
             .then(loadEngine)
             .then(
                 (engine) => {
                     engines.set(loadEngine, engine);
+
                     if (active) {
                         setLoaded({ load: loadEngine, engine });
                     }
                 },
                 () => {
                     engines.set(loadEngine, null);
+
                     if (active) {
                         setLoaded({ load: loadEngine, engine: null });
                     }
                 }
             );
+
         return () => {
             active = false;
         };
     }, [loadEngine, withinLimits]);
+
     const engine = loaded?.load === loadEngine ? loaded.engine : engines.get(loadEngine);
+
     if (!withinLimits) {
         return <DiffOmitted path={path} />;
     }
+
     if (engine === undefined) {
         return <div className="px-3 py-2 text-xs text-text-faint">{t('work.loadingDiff')}</div>;
     }
+
     return engine === null ? (
         fallback
     ) : (
@@ -135,8 +146,10 @@ export default function EditorEditDiff({
         sourceChecked || diffSourceBudget(change.before, change.after)
             ? diffDocument(patchOf(change.before, change.after, 3, { maxWork: EDITOR_DIFF_WORK }), { old: change.before, new: change.after })
             : undefined;
+
     if (document === undefined) {
         return <DiffOmitted path={change.path} />;
     }
+
     return <EditorDocumentDiff document={document} path={change.path} loadEngine={loadEngine} fallback={fallback} maxHeight={maxHeight} />;
 }

package/src/chat/ui/diff/EditorPatchDiff.tsx

@@ -32,19 +32,23 @@ export default function EditorPatchDiff({
 }) {
     const oldText = contents?.old;
     const newText = contents?.new;
+
     const document = useMemo(() => {
         if (!sourceChecked && (!diffSourceBudget(oldText ?? '', newText ?? '') || !patchSourceBudget(change.diff))) {
             return undefined;
         }
+
         return diffDocument(
             parsePatch(change.diff),
             oldText === undefined || newText === undefined ? undefined : { old: oldText, new: newText },
             ignoreWhitespace
         );
     }, [change.diff, oldText, newText, ignoreWhitespace, sourceChecked]);
+
     if (document === undefined) {
         return <DiffOmitted path={change.path} />;
     }
+
     return (
         <EditorDocumentDiff
             document={document}

package/src/chat/ui/diff/LegacyDiffPool.tsx

@@ -7,8 +7,10 @@ export function LegacyDiffPool({ children }: { children: ReactNode }) {
     const host = useChatHost();
     const outer = useWorkerPool();
     const workerFactory = host.code.legacyDiffWorker;
+
     if (outer !== undefined || workerFactory === undefined) {
         return children;
     }
+
     return <DiffPool workerFactory={workerFactory}>{children}</DiffPool>;
 }

package/src/chat/ui/diff/LegacyEditDiff.tsx

@@ -11,6 +11,7 @@ export default function LegacyEditDiff({ change, maxHeight }: { change: FileChan
     const theme = useDiffTheme();
     const oldFile = { name: change.path, contents: change.before };
     const newFile = { name: change.path, contents: change.after };
+
     const options = {
         diffStyle: 'unified' as const,
         theme,
@@ -19,6 +20,7 @@ export default function LegacyEditDiff({ change, maxHeight }: { change: FileChan
         overflow: 'wrap' as const,
         hunkSeparators: 'simple' as const
     };
+
     return (
         <div className="chat-diff select-text" style={maxHeight === undefined ? undefined : { maxHeight, overflow: 'auto' }}>
             <LegacyDiffPool>

package/src/chat/ui/diff/LegacyUnifiedDiff.tsx

@@ -16,11 +16,14 @@ function asPatch(change: ChatFileChange): string | null {
     if (!/^@@/m.test(change.diff)) {
         return null;
     }
+
     if (/^\+\+\+ /m.test(change.diff)) {
         return change.diff;
     }
+
     const from = change.kind === 'add' ? '/dev/null' : `a/${change.path}`;
     const to = change.kind === 'delete' ? '/dev/null' : `b/${change.path}`;
+
     return `--- ${from}\n+++ ${to}\n${change.diff}`;
 }
 
@@ -37,9 +40,11 @@ function lineClass(line: string): string {
     if (line.startsWith('+')) {
         return 'text-chat-added';
     }
+
     if (line.startsWith('-')) {
         return 'text-chat-removed';
     }
+
     return 'text-text-muted';
 }
 
@@ -52,6 +57,7 @@ export default function LegacyUnifiedDiff({ change, overflow = 'wrap', diffStyle
     const newText = contents?.new;
     const full = patch === null || oldText === undefined || newText === undefined ? null : fullFileDiff(patch, change.path, { old: oldText, new: newText });
     const unfolds = full !== null;
+
     const options = {
         theme,
         themeType: resolved,
@@ -61,6 +67,7 @@ export default function LegacyUnifiedDiff({ change, overflow = 'wrap', diffStyle
         hunkSeparators: unfolds ? ('line-info' as const) : ('simple' as const),
         unsafeCSS: fill ? FILL_CSS : undefined
     };
+
     if (patch === null) {
         return (
             <pre className="max-h-64 overflow-auto px-3 py-2 font-mono text-code select-text" style={fill ? undefined : { maxHeight }}>
@@ -75,6 +82,7 @@ export default function LegacyUnifiedDiff({ change, overflow = 'wrap', diffStyle
             </pre>
         );
     }
+
     return (
         <div
             className={clsx('chat-diff select-text', fill && 'flex grow flex-col')}

package/src/chat/ui/diff/RawDiff.tsx

@@ -3,6 +3,7 @@ import { useReviewSettled } from './review-settle';
 
 export function RawDiff({ text, overflow, fill, maxHeight }: { text: string; overflow: 'wrap' | 'scroll'; fill: boolean; maxHeight?: number }) {
     useReviewSettled();
+
     return (
         <pre
             data-diff-raw

package/src/chat/ui/diff/ReviewDiff.tsx

@@ -8,6 +8,7 @@ const UnifiedDiff = lazyNamed(() => import('../UnifiedDiff'), 'default');
 
 export function ReviewDiff({ entry, maxHeight = 480 }: { entry: ReviewEntry; maxHeight?: number }) {
     const { t } = useTranslation('agent-chat');
+
     return (
         <div data-review-entry={entry.key}>
             <LazyBoundary fallback={<p className="px-3 py-2 text-xs text-text-faint">{t('work.loadingDiff')}</p>}>

package/src/chat/ui/diff/diff-source-budget.ts

@@ -13,18 +13,22 @@ export function textFitsBudget(text: string, budget: TextBudget): boolean {
     if (text.length > budget.characters) {
         return false;
     }
+
     let rows = text.length === 0 ? 0 : 1;
     let length = 0;
+
     for (let index = 0; index < text.length; index++) {
         if (text.charCodeAt(index) === 10) {
             if (index < text.length - 1 && ++rows > budget.rows) {
                 return false;
             }
+
             length = 0;
         } else if (++length > budget.lineLength) {
             return false;
         }
     }
+
     return rows <= budget.rows;
 }
 
@@ -41,16 +45,20 @@ export function legacyDiffBudget(before: string, after: string, patch = ''): boo
     if (before.length + after.length + patch.length > LEGACY_BUDGET.characters) {
         return false;
     }
+
     let rows = 2;
+
     for (const text of [before, after, patch]) {
         if (!textFitsBudget(text, LEGACY_BUDGET)) {
             return false;
         }
+
         for (let index = 0; index < text.length; index++) {
             if (text.charCodeAt(index) === 10 && ++rows > LEGACY_BUDGET.rows) {
                 return false;
             }
         }
     }
+
     return true;
 }

package/src/chat/ui/diff/editor-edit-model.ts

@@ -7,15 +7,19 @@ export const EDITOR_DIFF_LIMITS = { rows: 2000, characters: 2000000, lineLength:
 export function canRenderEditorDiff(document: DiffDocument): boolean {
     let rows = 0;
     let characters = 0;
+
     for (const row of diffRows(document, 'unified')) {
         if (row.kind === 'gap') {
             continue;
         }
+
         const text = row.new === undefined ? document.sides.old[row.old!.index]! : document.sides.new[row.new.index]!;
         characters += text.length + (rows > 0 ? 1 : 0);
+
         if (++rows > EDITOR_DIFF_LIMITS.rows || characters > EDITOR_DIFF_LIMITS.characters || text.length > EDITOR_DIFF_LIMITS.lineLength) {
             return false;
         }
     }
+
     return true;
 }

package/src/chat/ui/diff/review-plan.ts

@@ -17,6 +17,7 @@ export interface ReviewBudget {
 }
 
 export const REVIEW_BUDGET: ReviewBudget = { editors: 3, rows: 2000, characters: 2000000 };
+
 export type ReviewSlot = 'editor' | 'deferred';
 
 export function reviewEntries(patches: readonly ChatFileChange[], edits: readonly FileChange[]): readonly ReviewEntry[] {
@@ -29,20 +30,25 @@ export function reviewEntries(patches: readonly ChatFileChange[], edits: readonl
 export function reviewSize(entry: ReviewEntry, budget: ReviewBudget = REVIEW_BUDGET): { rows: number; characters: number } {
     const texts = entry.change.kind === 'edit' ? [entry.change.edit.before, entry.change.edit.after] : [entry.change.patch.diff];
     const characters = texts.reduce((sum, text) => sum + text.length, 0);
+
     if (characters > budget.characters) {
         return { rows: budget.rows + 1, characters };
     }
+
     let rows = 0;
+
     for (const text of texts) {
         if (text.length > 0) {
             rows++;
         }
+
         for (let index = text.indexOf('\n'); index >= 0; index = text.indexOf('\n', index + 1)) {
             if (++rows > budget.rows) {
                 return { rows, characters };
             }
         }
     }
+
     return { rows, characters };
 }
 
@@ -53,8 +59,10 @@ export function planReview(entries: readonly ReviewEntry[], promoted: string | n
     let editors = 0;
     let rows = 0;
     let characters = 0;
+
     for (const entry of ordered) {
         const size = reviewSize(entry, budget);
+
         // The first review keeps its own omission and error handling, even when the group estimate exceeds the budget.
         if (editors === 0 || (editors < budget.editors && rows + size.rows <= budget.rows && characters + size.characters <= budget.characters)) {
             slots.set(entry.key, 'editor');
@@ -65,5 +73,6 @@ export function planReview(entries: readonly ReviewEntry[], promoted: string | n
             slots.set(entry.key, 'deferred');
         }
     }
+
     return slots;
 }

package/src/chat/ui/diff/review-settle.ts

@@ -6,6 +6,7 @@ export function useReviewSettled(): void {
     const scope = useContext(ReviewSettleContext);
     const key = scope?.key;
     const settle = scope?.settle;
+
     useEffect(() => {
         if (key !== undefined) {
             settle?.(key);

package/src/chat/ui/diff/syntax-runtime.ts

@@ -45,10 +45,12 @@ const shared = new WeakMap<ChatHost['code'], DiffSyntaxRuntime>();
 /* The runtime of a host's `code`, made on first use and shared by every diff under that host. */
 export function diffSyntaxRuntime(code: ChatHost['code']): DiffSyntaxRuntime {
     let runtime = shared.get(code);
+
     if (runtime === undefined) {
         runtime = createDiffSyntaxRuntime({ workerFactory: code.syntaxWorker, themes: () => code.custom, highlighter: code.highlighter });
         shared.set(code, runtime);
     }
+
     return runtime;
 }
 
@@ -61,13 +63,17 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
     let stopped = false;
     // The names of the custom themes the current worker or fallback has, each sent once.
     const sentThemes = new Set<string>();
+
     const themes = (): readonly ThemeRegistration[] => (typeof options.themes === 'function' ? options.themes() : options.themes);
+
     const settle = (session: Session): void => {
         for (const pending of session.pending.values()) {
             pending.resolve(null);
         }
+
         session.pending.clear();
     };
+
     const stopWorker = (): void => {
         worker?.removeEventListener('message', onMessage);
         worker?.removeEventListener('error', onError);
@@ -75,57 +81,75 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
         worker?.terminate();
         worker = undefined;
     };
+
     const loadHighlighter = (): Promise<Highlighter> => {
         highlighter ??= import('shiki').then(({ createHighlighter }) => createHighlighter({ langs: [], themes: [] }));
+
         return highlighter;
     };
+
     const start = (): void => {
         const current = themes();
         sentThemes.clear();
+
         for (const theme of current) {
             if (theme.name !== undefined) {
                 sentThemes.add(theme.name);
             }
         }
+
         dispatch({ type: 'start', themes: current, maxLines: 100000 });
     };
+
     /* Sends a custom theme the host added after the start, ahead of the first request drawn in it. */
     const sendTheme = (name: string): void => {
         if (sentThemes.has(name)) {
             return;
         }
+
         const theme = themes().find((candidate) => candidate.name === name);
+
         if (theme !== undefined) {
             sentThemes.add(name);
             dispatch({ type: 'themes', themes: [theme] });
         }
     };
+
     const startFallback = (): void => {
         stopWorker();
+
         if (fallback !== undefined || stopped) {
             return;
         }
+
         fallback = createSyntaxService({ highlighter: options.highlighter ?? loadHighlighter, send: receive });
         start();
+
         for (const [generation, session] of sessions) {
             session.sent = false;
+
             for (const index of session.pending.keys()) {
                 request(generation, session, index);
             }
         }
     };
+
     const onError = (event: Event): void => {
         event.preventDefault();
         startFallback();
     };
+
     const onMessage = (event: MessageEvent<DiffSyntaxOutput>): void => {
         receive(event.data);
     };
+
     const initialize = (): void => {
         if (started || stopped) {
             return;
         }
+
         started = true;
+
         if (options.workerFactory !== undefined) {
             try {
                 worker = options.workerFactory();
@@ -133,6 +157,7 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
                 worker.addEventListener('error', onError);
                 worker.addEventListener('messageerror', onError);
                 start();
+
                 return;
             } catch {
                 startFallback();
@@ -141,10 +166,12 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
             startFallback();
         }
     };
+
     const dispatch = (message: DiffSyntaxInput): void => {
         if (stopped) {
             return;
         }
+
         if (worker !== undefined) {
             try {
                 worker.postMessage(message);
@@ -159,18 +186,23 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
             });
         }
     };
+
     const request = (generation: number, session: Session, index: number, resend = false): void => {
         const document = !session.sent || resend ? session.definition : undefined;
+
         if (document !== undefined) {
             sendTheme(document.theme);
         }
+
         session.sent = true;
         dispatch({ type: 'request', generation, index, ...(document ? { document } : {}) });
     };
+
     const receive = (message: DiffSyntaxOutput): void => {
         if (stopped || message.type === 'ready') {
             return;
         }
+
         if (message.type === 'error') {
             if (worker !== undefined) {
                 startFallback();
@@ -179,50 +211,66 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
                     settle(session);
                 }
             }
+
             return;
         }
+
         const session = sessions.get(message.generation);
         const pending = session?.pending.get(message.index);
+
         if (session === undefined || pending === undefined) {
             return;
         }
+
         if (message.type === 'failed' && message.reason === 'missing' && !pending.resent) {
             pending.resent = true;
             request(message.generation, session, message.index, true);
+
             return;
         }
+
         session.pending.delete(message.index);
         pending.resolve(message.type === 'tokens' ? message : null);
     };
+
     return {
         open(document) {
             const generation = ++nextGeneration;
             const session: Session = { definition: document, pending: new Map(), sent: false };
             sessions.set(generation, session);
+
             return {
                 request(index) {
                     if (stopped || !sessions.has(generation)) {
                         return Promise.resolve(null);
                     }
+
                     const existing = session.pending.get(index);
+
                     if (existing !== undefined) {
                         return existing.promise;
                     }
+
                     let resolve!: Pending['resolve'];
+
                     const promise = new Promise<DiffSyntaxTokens | null>((done) => {
                         resolve = done;
                     });
+
                     session.pending.set(index, { promise, resolve, resent: false });
                     const initialized = started;
                     initialize();
+
                     // Fallback initialization replays pending requests, including this first one.
                     if (initialized || worker !== undefined) {
                         request(generation, session, index);
                     }
+
                     return promise;
                 },
                 cancel() {
                     settle(session);
+
                     if (started) {
                         dispatch({ type: 'cancel', generation });
                     }
@@ -230,6 +278,7 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
                 dispose() {
                     settle(session);
                     sessions.delete(generation);
+
                     if (started) {
                         dispatch({ type: 'dispose', generation });
                     }
@@ -238,12 +287,15 @@ export function createDiffSyntaxRuntime(options: DiffSyntaxRuntimeOptions): Diff
         },
         dispose() {
             stopped = true;
+
             for (const session of sessions.values()) {
                 settle(session);
             }
+
             sessions.clear();
             stopWorker();
             fallback?.dispose();
+
             if (options.highlighter === undefined) {
                 void highlighter?.then(
                     (loaded) => loaded.dispose(),

package/src/chat/ui/diff/use-review-stack.ts

@@ -15,24 +15,33 @@ export function useReviewStack(entries: readonly ReviewEntry[]): ReviewStack {
     const [admitted, setAdmitted] = useState<string[]>(() => selected.slice(0, 1));
     const retained = admitted.filter((key) => selected.includes(key));
     const live = retained.length === 0 ? selected.slice(0, 1) : retained;
+
     if (live.length !== admitted.length || live.some((key, index) => key !== admitted[index])) {
         setAdmitted(live);
     }
+
     const [settled, setSettled] = useState<ReadonlySet<string>>(() => new Set());
+
     if ([...settled].some((key) => !selected.includes(key))) {
         setSettled(new Set([...settled].filter((key) => selected.includes(key))));
     }
+
     const settle = (key: string) => {
         setSettled((previous) => (previous.has(key) ? previous : new Set([...previous, key])));
     };
+
     const allSettled = live.every((key) => settled.has(key));
     const next = selected.find((key) => !live.includes(key));
+
     useEffect(() => {
         if (next === undefined || !allSettled) {
             return;
         }
+
         const frame = window.requestAnimationFrame(() => setAdmitted((previous) => [...previous, next]));
+
         return () => window.cancelAnimationFrame(frame);
     }, [next, allSettled]);
+
     return { slots, ready: new Set(live), promote: setPromoted, settle };
 }

package/src/chat/ui/diff-syntax.ts

@@ -24,31 +24,41 @@ export function diffSourceTokens(document: DiffDocument, mapping: DiffSyntaxMapp
     const pending = { old: new Set<number>(), new: new Set<number>() };
     const listeners = new Set<() => void>();
     let disposed = false;
+
     return {
         get(side, index) {
             const location = mapping.locate(side, index);
+
             if (disposed || location === undefined || document.sides[side][index] === undefined) {
                 return null;
             }
+
             const { block, line } = location;
             const known = cache[side].get(block);
+
             if (known !== undefined) {
                 return known[line] ?? null;
             }
+
             if (!pending[side].has(block)) {
                 pending[side].add(block);
                 const text = mapping.documents[side].blocks[block]!.split('\n');
+
                 const publish = (lines: ReadonlyArray<readonly LineToken[] | null>): void => {
                     if (disposed) {
                         return;
                     }
+
                     pending[side].delete(block);
                     cache[side].set(block, lines);
+
                     for (const listener of [...listeners]) {
                         listener();
                     }
                 };
+
                 const count = text.length;
+
                 void sides[side].request(block).then(
                     (packet) => {
                         if (!disposed) {
@@ -58,12 +68,14 @@ export function diffSourceTokens(document: DiffDocument, mapping: DiffSyntaxMapp
                     () => publish(text.map(() => null))
                 );
             }
+
             return undefined;
         },
         subscribe(listener) {
             if (!disposed) {
                 listeners.add(listener);
             }
+
             return () => {
                 listeners.delete(listener);
             };

package/src/chat/ui/diff-theme.ts

@@ -14,6 +14,7 @@ function registerThemes(custom: ChatHost['code']['custom']): void {
         if (registered.has(theme.name)) {
             continue;
         }
+
         registered.add(theme.name);
         registerCustomTheme(theme.name, () => Promise.resolve(theme));
     }
@@ -24,5 +25,6 @@ export function useDiffTheme(): ThemesType {
     const { code } = useChatHost();
     registerThemes(code.custom);
     const { light, dark } = useHostCodeThemes();
+
     return { light, dark };
 }

package/src/chat/ui/file-links.ts

@@ -22,11 +22,13 @@ export function useFileLinkTarget(text: string): FileRef | null {
     const cwd = useFileLinkCwd();
     const scopeId = useFileLinkScopeId();
     const { fileLinks } = useChatHost();
+
     return fileLinks?.target(text, cwd, scopeId) ?? null;
 }
 
 /* Follows a reference the way the app opens a file or a folder. */
 export function useOpenFileLink(): (cwd: string | null, ref: FileRef, scopeId?: string | null) => void {
     const { fileLinks } = useChatHost();
+
     return (cwd, ref, scopeId = null) => fileLinks?.open(cwd, ref, scopeId);
 }

package/src/chat/ui/find-reveal.ts

@@ -15,6 +15,7 @@ export const FindRevealContext = createContext<FindReveal | null>(null);
 export function useOpenForFind(itemId: string, field: ChatFindField, setOpen: (open: boolean) => void): void {
     const reveal = useContext(FindRevealContext);
     const wanted = reveal !== null && reveal.itemId === itemId && reveal.field === field;
+
     useEffect(() => {
         if (wanted) {
             setOpen(true);