@adecore/agents-react 0.31.12 → 0.33.0

package/dist/chat/ui/diff/editor-edit-model.js

@@ -1,19 +1,23 @@
 import { diffRows } from '@adecore/merge';
 // Larger rendering tiers need native production measurements before this gate expands.
 export const EDITOR_DIFF_WORK = 4_000_000;
-export const EDITOR_DIFF_LIMITS = { rows: 2000, characters: 2000000, lineLength: 10000 };
+export const EDITOR_DIFF_LIMITS = {
+  rows: 2000,
+  characters: 2000000,
+  lineLength: 10000
+};
 export function canRenderEditorDiff(document) {
-    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;
-        }
+  let rows = 0;
+  let characters = 0;
+  for (const row of diffRows(document, 'unified')) {
+    if (row.kind === 'gap') {
+      continue;
     }
-    return true;
-}
+    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/dist/chat/ui/diff/review-plan.js

@@ -1,48 +1,71 @@
-export const REVIEW_BUDGET = { editors: 3, rows: 2000, characters: 2000000 };
+export const REVIEW_BUDGET = {
+  editors: 3,
+  rows: 2000,
+  characters: 2000000
+};
 export function reviewEntries(patches, edits) {
-    return [
-        ...patches.map((patch, index) => ({ key: `patch:${index}:${patch.path}`, path: patch.path, change: { kind: 'patch', patch } })),
-        ...edits.map((edit, index) => ({ key: `edit:${index}:${edit.path}`, path: edit.path, change: { kind: 'edit', edit } }))
-    ];
+  return [...patches.map((patch, index) => ({
+    key: `patch:${index}:${patch.path}`,
+    path: patch.path,
+    change: {
+      kind: 'patch',
+      patch
+    }
+  })), ...edits.map((edit, index) => ({
+    key: `edit:${index}:${edit.path}`,
+    path: edit.path,
+    change: {
+      kind: 'edit',
+      edit
+    }
+  }))];
 }
 export function reviewSize(entry, budget = REVIEW_BUDGET) {
-    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 };
+  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++;
     }
-    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 };
-            }
-        }
+    for (let index = text.indexOf('\n'); index >= 0; index = text.indexOf('\n', index + 1)) {
+      if (++rows > budget.rows) {
+        return {
+          rows,
+          characters
+        };
+      }
     }
-    return { rows, characters };
+  }
+  return {
+    rows,
+    characters
+  };
 }
 export function planReview(entries, promoted, budget = REVIEW_BUDGET) {
-    const priority = entries.find((entry) => entry.key === promoted);
-    const ordered = priority === undefined ? entries : [priority, ...entries.filter((entry) => entry !== priority)];
-    const slots = new Map();
-    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');
-            editors++;
-            rows += size.rows;
-            characters += size.characters;
-        }
-        else {
-            slots.set(entry.key, 'deferred');
-        }
+  const priority = entries.find(entry => entry.key === promoted);
+  const ordered = priority === undefined ? entries : [priority, ...entries.filter(entry => entry !== priority)];
+  const slots = new Map();
+  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');
+      editors++;
+      rows += size.rows;
+      characters += size.characters;
+    } else {
+      slots.set(entry.key, 'deferred');
     }
-    return slots;
-}
+  }
+  return slots;
+}

package/dist/chat/ui/diff/review-settle.js

@@ -1,12 +1,27 @@
+import { c as _c } from "react/compiler-runtime";
 import { createContext, useContext, useEffect } from 'react';
 export const ReviewSettleContext = createContext(null);
 export function useReviewSettled() {
-    const scope = useContext(ReviewSettleContext);
-    const key = scope?.key;
-    const settle = scope?.settle;
-    useEffect(() => {
-        if (key !== undefined) {
-            settle?.(key);
-        }
-    }, [key, settle]);
-}
+  const $ = _c(4);
+  const scope = useContext(ReviewSettleContext);
+  const key = scope?.key;
+  const settle = scope?.settle;
+  let t0;
+  let t1;
+  if ($[0] !== key || $[1] !== settle) {
+    t0 = () => {
+      if (key !== undefined) {
+        settle?.(key);
+      }
+    };
+    t1 = [key, settle];
+    $[0] = key;
+    $[1] = settle;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t0 = $[2];
+    t1 = $[3];
+  }
+  useEffect(t0, t1);
+}

package/dist/chat/ui/diff/syntax-runtime.js

@@ -3,213 +3,248 @@ let nextGeneration = 0;
 const shared = new WeakMap();
 /* The runtime of a host's `code`, made on first use and shared by every diff under that host. */
 export function diffSyntaxRuntime(code) {
-    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;
+  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;
 }
 export function createDiffSyntaxRuntime(options) {
-    const sessions = new Map();
-    let worker;
-    let fallback;
-    let highlighter;
-    let started = false;
-    let stopped = false;
-    // The names of the custom themes the current worker or fallback has, each sent once.
-    const sentThemes = new Set();
-    const themes = () => (typeof options.themes === 'function' ? options.themes() : options.themes);
-    const settle = (session) => {
-        for (const pending of session.pending.values()) {
-            pending.resolve(null);
-        }
-        session.pending.clear();
-    };
-    const stopWorker = () => {
-        worker?.removeEventListener('message', onMessage);
-        worker?.removeEventListener('error', onError);
-        worker?.removeEventListener('messageerror', onError);
-        worker?.terminate();
-        worker = undefined;
-    };
-    const loadHighlighter = () => {
-        highlighter ??= import('shiki').then(({ createHighlighter }) => createHighlighter({ langs: [], themes: [] }));
-        return highlighter;
-    };
-    const start = () => {
-        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) => {
-        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 = () => {
-        stopWorker();
-        if (fallback !== undefined || stopped) {
-            return;
-        }
-        fallback = createSyntaxService({ highlighter: options.highlighter ?? loadHighlighter, send: receive });
+  const sessions = new Map();
+  let worker;
+  let fallback;
+  let highlighter;
+  let started = false;
+  let stopped = false;
+  // The names of the custom themes the current worker or fallback has, each sent once.
+  const sentThemes = new Set();
+  const themes = () => typeof options.themes === 'function' ? options.themes() : options.themes;
+  const settle = session => {
+    for (const pending of session.pending.values()) {
+      pending.resolve(null);
+    }
+    session.pending.clear();
+  };
+  const stopWorker = () => {
+    worker?.removeEventListener('message', onMessage);
+    worker?.removeEventListener('error', onError);
+    worker?.removeEventListener('messageerror', onError);
+    worker?.terminate();
+    worker = undefined;
+  };
+  const loadHighlighter = () => {
+    highlighter ??= import('shiki').then(({
+      createHighlighter
+    }) => createHighlighter({
+      langs: [],
+      themes: []
+    }));
+    return highlighter;
+  };
+  const start = () => {
+    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 => {
+    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 = () => {
+    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.preventDefault();
+    startFallback();
+  };
+  const onMessage = event => {
+    receive(event.data);
+  };
+  const initialize = () => {
+    if (started || stopped) {
+      return;
+    }
+    started = true;
+    if (options.workerFactory !== undefined) {
+      try {
+        worker = options.workerFactory();
+        worker.addEventListener('message', onMessage);
+        worker.addEventListener('error', onError);
+        worker.addEventListener('messageerror', onError);
         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.preventDefault();
+        return;
+      } catch {
         startFallback();
-    };
-    const onMessage = (event) => {
-        receive(event.data);
-    };
-    const initialize = () => {
-        if (started || stopped) {
-            return;
-        }
-        started = true;
-        if (options.workerFactory !== undefined) {
-            try {
-                worker = options.workerFactory();
-                worker.addEventListener('message', onMessage);
-                worker.addEventListener('error', onError);
-                worker.addEventListener('messageerror', onError);
-                start();
-                return;
-            }
-            catch {
-                startFallback();
-            }
-        }
-        else {
-            startFallback();
-        }
-    };
-    const dispatch = (message) => {
-        if (stopped) {
-            return;
+      }
+    } else {
+      startFallback();
+    }
+  };
+  const dispatch = message => {
+    if (stopped) {
+      return;
+    }
+    if (worker !== undefined) {
+      try {
+        worker.postMessage(message);
+      } catch {
+        startFallback();
+      }
+    } else if (fallback !== undefined) {
+      void fallback.handle(message).catch(() => {
+        for (const session of sessions.values()) {
+          settle(session);
         }
-        if (worker !== undefined) {
-            try {
-                worker.postMessage(message);
-            }
-            catch {
-                startFallback();
-            }
+      });
+    }
+  };
+  const request = (generation, session, index, resend = false) => {
+    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 => {
+    if (stopped || message.type === 'ready') {
+      return;
+    }
+    if (message.type === 'error') {
+      if (worker !== undefined) {
+        startFallback();
+      } else {
+        for (const session of sessions.values()) {
+          settle(session);
         }
-        else if (fallback !== undefined) {
-            void fallback.handle(message).catch(() => {
-                for (const session of sessions.values()) {
-                    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 = {
+        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;
+          const promise = new Promise(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
             });
-        }
-    };
-    const request = (generation, session, index, resend = false) => {
-        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) => {
-        if (stopped || message.type === 'ready') {
-            return;
-        }
-        if (message.type === 'error') {
-            if (worker !== undefined) {
-                startFallback();
-            }
-            else {
-                for (const session of sessions.values()) {
-                    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 = { 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;
-                    const promise = new Promise((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 });
-                    }
-                },
-                dispose() {
-                    settle(session);
-                    sessions.delete(generation);
-                    if (started) {
-                        dispatch({ type: 'dispose', generation });
-                    }
-                }
-            };
+          }
         },
         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(), () => undefined);
-            }
-        }
-    };
-}
+          settle(session);
+          sessions.delete(generation);
+          if (started) {
+            dispatch({
+              type: 'dispose',
+              generation
+            });
+          }
+        }
+      };
+    },
+    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(), () => undefined);
+      }
+    }
+  };
+}