@adecore/agents-react 0.22.0 → 0.23.0

package/dist/chat/ui/EditDiff.d.ts

@@ -1,4 +1,6 @@
 import type { FileChange } from '../logic/tools.js';
-export default function EditDiff({ change }: {
+export default function EditDiff({ change, allowEditor, maxHeight }: {
     change: FileChange;
+    allowEditor?: boolean;
+    maxHeight?: number;
 }): import("react").JSX.Element;

package/dist/chat/ui/EditDiff.js

@@ -1,21 +1,28 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useMemo } from 'react';
-import { MultiFileDiff } from '@pierre/diffs/react';
+import { Suspense, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { lazyNamed } from '../../lazy.js';
+import { diffSourceBudget, legacyDiffBudget } from './diff/diff-source-budget.js';
+import { DiffOmitted } from './diff/DiffOmitted.js';
+import { DiffUnavailable } from './diff/DiffUnavailable.js';
+import { DiffFallbackBoundary } from './diff/DiffFallbackBoundary.js';
 import { chatHost } from '../../host.js';
-import { useDiffTheme } from './diff-theme.js';
-/* One hunk of a file edit, highlighted in a worker. The header is ours, so the library's is off. */
-export default function EditDiff({ change }) {
-    const resolved = chatHost().code.useMode();
-    const theme = useDiffTheme();
-    const oldFile = useMemo(() => ({ name: change.path, contents: change.before }), [change.path, change.before]);
-    const newFile = useMemo(() => ({ name: change.path, contents: change.after }), [change.path, change.after]);
-    const options = useMemo(() => ({
-        diffStyle: 'unified',
-        theme,
-        themeType: resolved,
-        disableFileHeader: true,
-        overflow: 'wrap',
-        hunkSeparators: 'simple'
-    }), [theme, resolved]);
-    return (_jsx("div", { className: "chat-diff select-text", children: _jsx(MultiFileDiff, { oldFile: oldFile, newFile: newFile, options: options }) }));
+const LegacyEditDiff = lazyNamed(() => import('./diff/LegacyEditDiff.js'), 'default', { prefetch: false });
+const EditorEditDiff = lazyNamed(() => import('./diff/EditorEditDiff.js'), 'default');
+export default function EditDiff({ change, allowEditor = true, maxHeight }) {
+    const { t } = useTranslation('agent-chat');
+    const loadEngine = chatHost().code.editor;
+    const sourceAllowed = useMemo(() => diffSourceBudget(change.before, change.after), [change.before, change.after]);
+    const legacyMode = !allowEditor || loadEngine === undefined;
+    const legacyAllowed = useMemo(() => legacyMode && legacyDiffBudget(change.before, change.after), [legacyMode, change.before, change.after]);
+    const omitted = _jsx(DiffOmitted, { path: change.path });
+    const fallback = legacyAllowed ? (_jsx(DiffFallbackBoundary, { fallback: omitted, resetKeys: [change.path, change.before, change.after], children: _jsx(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: _jsx(LegacyEditDiff, { change: change, maxHeight: maxHeight }) }) })) : (omitted);
+    if (!sourceAllowed) {
+        return omitted;
+    }
+    if (legacyMode) {
+        return fallback;
+    }
+    const unavailable = _jsx(DiffUnavailable, { path: change.path });
+    return (_jsx(DiffFallbackBoundary, { fallback: unavailable, resetKeys: [change.path, change.before, change.after, loadEngine], children: _jsx(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: _jsx(EditorEditDiff, { change: change, loadEngine: loadEngine, fallback: unavailable, maxHeight: maxHeight, sourceChecked: true }) }) }));
 }

package/dist/chat/ui/UnifiedDiff.d.ts

@@ -1,11 +1,2 @@
-import type { ChatFileChange } from '@adecore/agent-contracts';
-import { type DiffContents } from './full-diff.js';
-interface UnifiedDiffProps {
-    change: ChatFileChange;
-    overflow?: 'wrap' | 'scroll';
-    diffStyle?: 'unified' | 'split';
-    fill?: boolean;
-    contents?: DiffContents;
-}
-export default function UnifiedDiff({ change, overflow, diffStyle, fill, contents }: UnifiedDiffProps): import("react").JSX.Element;
-export {};
+import type { UnifiedDiffProps } from './diff/diff-props.js';
+export default function UnifiedDiff(props: UnifiedDiffProps): import("react").JSX.Element;

package/dist/chat/ui/UnifiedDiff.js

@@ -1,64 +1,37 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useMemo } from 'react';
-import clsx from 'clsx';
-import { FileDiff, PatchDiff } from '@pierre/diffs/react';
+import { Suspense, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { lazyNamed } from '../../lazy.js';
+import { diffSourceBudget, legacyDiffBudget, patchSourceBudget } from './diff/diff-source-budget.js';
+import { DiffOmitted } from './diff/DiffOmitted.js';
+import { DiffUnavailable } from './diff/DiffUnavailable.js';
+import { RawDiff } from './diff/RawDiff.js';
+import { DiffFallbackBoundary } from './diff/DiffFallbackBoundary.js';
 import { chatHost } from '../../host.js';
-import { useDiffTheme } from './diff-theme.js';
-import { fullFileDiff } from './full-diff.js';
-/*
- * A patch the CLI reported itself. The renderer needs a file header, which a CLI that only sends hunks
- * gets from the path we know; a diff without hunks is shown as its own lines, so nothing is swallowed.
- */
-function asPatch(change) {
-    if (!/^@@/m.test(change.diff)) {
-        return null;
+const LegacyUnifiedDiff = lazyNamed(() => import('./diff/LegacyUnifiedDiff.js'), 'default', { prefetch: false });
+const EditorPatchDiff = lazyNamed(() => import('./diff/EditorPatchDiff.js'), 'default');
+export default function UnifiedDiff(props) {
+    const { t } = useTranslation('agent-chat');
+    const { change, contents, allowEditor = true, ignoreWhitespace = false, overflow = 'wrap', diffStyle = 'unified', fill = false, maxHeight } = props;
+    const loadEngine = chatHost().code.editor;
+    const oldText = contents?.old ?? '';
+    const newText = contents?.new ?? '';
+    const sourceAllowed = useMemo(() => diffSourceBudget(oldText, newText) && patchSourceBudget(change.diff), [oldText, newText, change.diff]);
+    const legacyMode = !allowEditor || loadEngine === undefined;
+    const hasHunks = /^@@/m.test(change.diff);
+    const legacyAllowed = useMemo(() => legacyMode && legacyDiffBudget(oldText, newText, change.diff), [legacyMode, oldText, newText, change.diff]);
+    const rawAllowed = useMemo(() => hasHunks || legacyDiffBudget('', '', change.diff), [hasHunks, change.diff]);
+    const omitted = _jsx(DiffOmitted, { path: change.path });
+    const fallback = legacyAllowed ? (_jsx(DiffFallbackBoundary, { fallback: omitted, resetKeys: [change.path, change.diff, oldText, newText, diffStyle], children: _jsx(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: _jsx(LegacyUnifiedDiff, { ...props }) }) })) : (omitted);
+    if (!sourceAllowed) {
+        return omitted;
     }
-    if (/^\+\+\+ /m.test(change.diff)) {
-        return change.diff;
+    if (!hasHunks) {
+        return rawAllowed ? _jsx(RawDiff, { text: change.diff, overflow: overflow, fill: fill, maxHeight: maxHeight }) : omitted;
     }
-    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}`;
-}
-/* Lets a diff with a view of its own run to its bottom, so a short one's scrollbar sits there and not under its last line. */
-const FILL_CSS = `
-:host { display: flex; flex-direction: column; flex-grow: 1; }
-pre { flex-grow: 1; align-content: start; }
-pre[data-diff-type="single"] { display: flex; flex-direction: column; }
-pre[data-diff-type="split"][data-overflow="scroll"]:not([data-dehydrated]) { align-content: stretch; }
-pre > [data-code] { flex-grow: 1; align-self: stretch; align-content: start; }
-`;
-function lineClass(line) {
-    if (line.startsWith('+')) {
-        return 'text-chat-added';
-    }
-    if (line.startsWith('-')) {
-        return 'text-chat-removed';
-    }
-    return 'text-text-muted';
-}
-export default function UnifiedDiff({ change, overflow = 'wrap', diffStyle = 'unified', fill = false, contents }) {
-    const resolved = chatHost().code.useMode();
-    const theme = useDiffTheme();
-    const patch = useMemo(() => asPatch(change), [change]);
-    const oldText = contents?.old;
-    const newText = contents?.new;
-    const full = useMemo(() => (patch === null || oldText === undefined || newText === undefined ? null : fullFileDiff(patch, change.path, { old: oldText, new: newText })), [patch, change.path, oldText, newText]);
-    const unfolds = full !== null;
-    const options = useMemo(() => ({
-        theme,
-        themeType: resolved,
-        disableFileHeader: true,
-        diffStyle,
-        overflow,
-        hunkSeparators: unfolds ? 'line-info' : 'simple',
-        unsafeCSS: fill ? FILL_CSS : undefined
-    }), [diffStyle, overflow, theme, resolved, fill, unfolds]);
-    if (patch === null) {
-        return (_jsx("pre", { className: "max-h-64 overflow-auto px-3 py-2 font-mono text-code select-text", children: change.diff
-                .replace(/\n$/, '')
-                .split('\n')
-                .map((line, index) => (_jsx("div", { className: clsx(lineClass(line), 'whitespace-pre-wrap'), children: line }, index))) }));
+    if (legacyMode) {
+        return fallback;
     }
-    return (_jsx("div", { className: clsx('chat-diff select-text', fill && 'flex grow flex-col'), children: full === null ? _jsx(PatchDiff, { patch: patch, options: options }) : _jsx(FileDiff, { fileDiff: full, options: options }) }));
+    const unavailable = _jsx(DiffUnavailable, { path: change.path });
+    return (_jsx(DiffFallbackBoundary, { fallback: unavailable, resetKeys: [change.path, change.diff, oldText, newText, ignoreWhitespace, diffStyle, loadEngine], children: _jsx(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: _jsx(EditorPatchDiff, { change: change, sourceChecked: true, contents: contents, ignoreWhitespace: ignoreWhitespace, wrap: overflow === 'wrap', fill: fill, maxHeight: maxHeight, layout: diffStyle, loadEngine: loadEngine, fallback: unavailable }) }) }));
 }

package/dist/chat/ui/diff/ApprovalReview.d.ts

@@ -0,0 +1,5 @@
+import type { ReviewEntry } from './review-plan.js';
+export declare function ApprovalReview({ entries, maxHeight }: {
+    entries: readonly ReviewEntry[];
+    maxHeight: number;
+}): import("react").JSX.Element | null;

package/dist/chat/ui/diff/ApprovalReview.js

@@ -0,0 +1,29 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Button } from '@adecore/ui';
+import { formatNumber } from '@adecore/ui/format';
+import { ReviewDiff } from './ReviewDiff.js';
+export function ApprovalReview({ entries, maxHeight }) {
+    const { t } = useTranslation('agent-prompts');
+    const [selected, setSelected] = useState(null);
+    const active = entries.find((entry) => entry.key === selected) ?? entries[0];
+    const labels = useMemo(() => {
+        const totals = new Map();
+        const counts = new Map();
+        for (const entry of entries) {
+            totals.set(entry.path, (totals.get(entry.path) ?? 0) + 1);
+        }
+        return entries.map((entry) => {
+            const count = (counts.get(entry.path) ?? 0) + 1;
+            counts.set(entry.path, count);
+            const total = totals.get(entry.path);
+            const suffix = total > 1 ? ` (${formatNumber(count)}/${formatNumber(total)})` : '';
+            return { short: `${entry.path.split(/[\\/]/).at(-1)}${suffix}`, full: `${entry.path}${suffix}` };
+        });
+    }, [entries]);
+    if (active === undefined) {
+        return null;
+    }
+    return (_jsxs("div", { children: [entries.length > 1 && (_jsxs(_Fragment, { children: [_jsx("div", { role: "toolbar", "aria-label": t('approval.reviewChanges'), className: "flex flex-wrap gap-1 border-b border-border p-1", children: entries.map((entry, index) => (_jsx(Button, { size: "sm", variant: active.key === entry.key ? 'secondary' : 'ghost', "aria-label": labels[index].full, "aria-pressed": active.key === entry.key, onClick: () => setSelected(entry.key), children: labels[index].short }, entry.key))) }), _jsx("p", { className: "break-all px-3 py-2 font-mono text-xs text-text-muted", children: active.path })] })), _jsx(ReviewDiff, { entry: active, maxHeight: maxHeight }, active.key)] }));
+}

package/dist/chat/ui/diff/DiffFallbackBoundary.d.ts

@@ -0,0 +1,17 @@
+import { Component, type ReactNode } from 'react';
+interface Props {
+    fallback: ReactNode;
+    children: ReactNode;
+    resetKeys: readonly unknown[];
+}
+interface State {
+    failed: boolean;
+    resetKeys: readonly unknown[];
+}
+export declare class DiffFallbackBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(): Partial<State>;
+    static getDerivedStateFromProps(props: Props, state: State): State | null;
+    render(): ReactNode;
+}
+export {};

package/dist/chat/ui/diff/DiffFallbackBoundary.js

@@ -0,0 +1,17 @@
+import { Component } from 'react';
+/* A failed view or lazy chunk must leave the containing review card usable. */
+export class DiffFallbackBoundary extends Component {
+    state = { failed: false, resetKeys: this.props.resetKeys };
+    static getDerivedStateFromError() {
+        return { failed: true };
+    }
+    static getDerivedStateFromProps(props, state) {
+        if (state.resetKeys.length !== props.resetKeys.length || state.resetKeys.some((value, index) => !Object.is(value, props.resetKeys[index]))) {
+            return { failed: false, resetKeys: props.resetKeys };
+        }
+        return null;
+    }
+    render() {
+        return this.state.failed ? this.props.fallback : this.props.children;
+    }
+}

package/dist/chat/ui/diff/DiffOmitted.d.ts

@@ -0,0 +1,3 @@
+export declare function DiffOmitted({ path }: {
+    path: string;
+}): import("react").JSX.Element;

package/dist/chat/ui/diff/DiffOmitted.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useReviewSettled } from './review-settle.js';
+import { useTranslation } from 'react-i18next';
+export function DiffOmitted({ path }) {
+    useReviewSettled();
+    const { t } = useTranslation('agent-chat');
+    return (_jsxs("div", { role: "status", "data-diff-omitted": true, className: "px-3 py-2 text-xs text-text-muted", children: [_jsx("p", { className: "truncate font-mono", children: path }), _jsx("p", { children: t('work.omitted.tooLarge') })] }));
+}

package/dist/chat/ui/diff/DiffStack.d.ts

@@ -0,0 +1,9 @@
+import { type ReviewEntry } from './review-plan.js';
+import { type ReviewStack } from './use-review-stack.js';
+export declare function ReviewStackView({ entries, stack }: {
+    entries: readonly ReviewEntry[];
+    stack: ReviewStack;
+}): import("react").JSX.Element;
+export declare function DiffStack({ entries }: {
+    entries: readonly ReviewEntry[];
+}): import("react").JSX.Element;

package/dist/chat/ui/diff/DiffStack.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslation } from 'react-i18next';
+import { Button } from '@adecore/ui';
+import { ReviewSettleContext } from './review-settle.js';
+import { ReviewDiff } from './ReviewDiff.js';
+import { reviewSize } from './review-plan.js';
+import { useReviewStack } from './use-review-stack.js';
+export function ReviewStackView({ entries, stack }) {
+    const { t } = useTranslation('agent-chat');
+    return (_jsx("div", { "data-review-stack": true, children: entries.map((entry) => (_jsxs("div", { className: "border-t border-border first:border-t-0", children: [_jsxs("div", { className: "flex items-center gap-2 px-3 py-2", children: [_jsx("p", { className: "min-w-0 grow break-all font-mono text-xs text-text-muted", children: entry.path }), stack.slots.get(entry.key) === 'deferred' && (_jsx(Button, { size: "sm", "data-review-show": entry.key, onClick: () => stack.promote(entry.key), children: t('work.showDiff') }))] }), stack.ready.has(entry.key) ? (_jsx(ReviewSettleContext, { value: { key: entry.key, settle: stack.settle }, children: _jsx(ReviewDiff, { entry: entry }) })) : stack.slots.get(entry.key) === 'editor' ? (_jsx("div", { "data-review-pending": entry.key, role: "status", className: "px-3 py-2 text-xs text-text-faint", style: { height: Math.max(28, Math.min(reviewSize(entry).rows * 20, 480)) }, children: t('work.loadingDiff') })) : null] }, entry.key))) }));
+}
+export function DiffStack({ entries }) {
+    const stack = useReviewStack(entries);
+    return _jsx(ReviewStackView, { entries: entries, stack: stack });
+}

package/dist/chat/ui/diff/DiffUnavailable.d.ts

@@ -0,0 +1,3 @@
+export declare function DiffUnavailable({ path }: {
+    path: string;
+}): import("react").JSX.Element;

package/dist/chat/ui/diff/DiffUnavailable.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslation } from 'react-i18next';
+import { useReviewSettled } from './review-settle.js';
+export function DiffUnavailable({ path }) {
+    useReviewSettled();
+    const { t } = useTranslation('agent-chat');
+    return (_jsxs("div", { role: "status", "data-diff-unavailable": true, className: "px-3 py-2 text-xs text-text-muted", children: [_jsx("p", { className: "truncate font-mono", children: path }), _jsx("p", { children: t('work.diffUnavailable') })] }));
+}

package/dist/chat/ui/diff/EditorEditDiff.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from 'react';
+import type { EditorEngine } from '@adecore/editor';
+import { type DiffDocument } from '@adecore/merge';
+import type { FileChange } from '../../logic/tools.js';
+type EngineLoader = () => Promise<EditorEngine>;
+export declare function EditorDocumentDiff({ document, path, loadEngine, fallback, wrap, fill, layout, maxHeight }: {
+    document: DiffDocument;
+    path: string;
+    loadEngine: EngineLoader;
+    fallback: ReactNode;
+    wrap?: boolean;
+    fill?: boolean;
+    layout?: 'unified' | 'split';
+    maxHeight?: number;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+export default function EditorEditDiff({ change, loadEngine, fallback, maxHeight, sourceChecked }: {
+    change: FileChange;
+    sourceChecked?: boolean;
+    loadEngine: EngineLoader;
+    fallback: ReactNode;
+    maxHeight?: number;
+}): import("react").JSX.Element;
+export {};

package/dist/chat/ui/diff/EditorEditDiff.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useReviewSettled } from './review-settle.js';
+import { useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { getFiletypeFromFileName } from '@pierre/diffs';
+import { DiffView } from '@adecore/editor-react';
+import { diffDocument, patchOf } from '@adecore/merge';
+import { chatHost } from '../../../host.js';
+import { useDiffSourceTokens } from '../use-diff-source-tokens.js';
+import { diffSourceBudget } from './diff-source-budget.js';
+import { DiffOmitted } from './DiffOmitted.js';
+import { canRenderEditorDiff, EDITOR_DIFF_LIMITS, EDITOR_DIFF_WORK } from './editor-edit-model.js';
+// Virtualized rows remount; retain the engine so their height does not return to the loading placeholder.
+const engines = new WeakMap();
+function ReadyDiff({ document, path, engine, wrap, fill, layout, maxHeight }) {
+    useReviewSettled();
+    const { t } = useTranslation('agent-chat');
+    const mode = chatHost().code.useMode();
+    const theme = chatHost().code.useThemes()[mode];
+    const language = getFiletypeFromFileName(path);
+    const tokens = useDiffSourceTokens(document, language, theme);
+    return (_jsx(DiffView, { engine: engine, document: document, tokens: tokens, theme: theme, maxHeight: maxHeight, unfoldLimits: EDITOR_DIFF_LIMITS, label: t('work.diffLabel', { path }), layout: layout, wrap: wrap, fill: fill, className: "chat-diff select-text" }));
+}
+export function EditorDocumentDiff({ document, path, loadEngine, fallback, wrap = true, fill = false, layout = 'unified', maxHeight = 480 }) {
+    const { t } = useTranslation('agent-chat');
+    const withinLimits = useMemo(() => canRenderEditorDiff(document), [document]);
+    const [loaded, setLoaded] = useState();
+    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 _jsx(DiffOmitted, { path: path });
+    }
+    if (engine === undefined) {
+        return _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') });
+    }
+    return engine === null ? (fallback) : (_jsx(ReadyDiff, { document: document, path: path, engine: engine, wrap: wrap, fill: fill, layout: layout, maxHeight: maxHeight }));
+}
+export default function EditorEditDiff({ change, loadEngine, fallback, maxHeight, sourceChecked = false }) {
+    const document = useMemo(() => sourceChecked || diffSourceBudget(change.before, change.after)
+        ? diffDocument(patchOf(change.before, change.after, 3, { maxWork: EDITOR_DIFF_WORK }), { old: change.before, new: change.after })
+        : undefined, [change.before, change.after, sourceChecked]);
+    if (document === undefined) {
+        return _jsx(DiffOmitted, { path: change.path });
+    }
+    return _jsx(EditorDocumentDiff, { document: document, path: change.path, loadEngine: loadEngine, fallback: fallback, maxHeight: maxHeight });
+}

package/dist/chat/ui/diff/EditorPatchDiff.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import type { ChatFileChange } from '@adecore/agent-contracts';
+import type { EditorEngine } from '@adecore/editor';
+import type { DiffContents } from '../full-diff.js';
+export default function EditorPatchDiff({ change, sourceChecked, contents, ignoreWhitespace, wrap, fill, maxHeight, layout, loadEngine, fallback }: {
+    change: ChatFileChange;
+    sourceChecked?: boolean;
+    contents?: DiffContents;
+    ignoreWhitespace: boolean;
+    wrap: boolean;
+    fill: boolean;
+    layout?: 'unified' | 'split';
+    maxHeight?: number;
+    loadEngine: () => Promise<EditorEngine>;
+    fallback: ReactNode;
+}): import("react").JSX.Element;

package/dist/chat/ui/diff/EditorPatchDiff.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { diffDocument, parsePatch } from '@adecore/merge';
+import { diffSourceBudget, patchSourceBudget } from './diff-source-budget.js';
+import { DiffOmitted } from './DiffOmitted.js';
+import { EditorDocumentDiff } from './EditorEditDiff.js';
+export default function EditorPatchDiff({ change, sourceChecked = false, contents, ignoreWhitespace, wrap, fill, maxHeight, layout = 'unified', loadEngine, fallback }) {
+    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 _jsx(DiffOmitted, { path: change.path });
+    }
+    return (_jsx(EditorDocumentDiff, { document: document, path: change.path, loadEngine: loadEngine, fallback: fallback, wrap: wrap, fill: fill, layout: layout, maxHeight: maxHeight }));
+}

package/dist/chat/ui/diff/LegacyDiffPool.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export declare function LegacyDiffPool({ children }: {
+    children: ReactNode;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;

package/dist/chat/ui/diff/LegacyDiffPool.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useWorkerPool } from '@pierre/diffs/react';
+import { chatHost } from '../../../host.js';
+import DiffPool from '../DiffPool.js';
+export function LegacyDiffPool({ children }) {
+    const outer = useWorkerPool();
+    const workerFactory = chatHost().code.legacyDiffWorker;
+    if (outer !== undefined || workerFactory === undefined) {
+        return children;
+    }
+    return _jsx(DiffPool, { workerFactory: workerFactory, children: children });
+}

package/dist/chat/ui/diff/LegacyEditDiff.d.ts

@@ -0,0 +1,5 @@
+import type { FileChange } from '../../logic/tools.js';
+export default function LegacyEditDiff({ change, maxHeight }: {
+    change: FileChange;
+    maxHeight?: number;
+}): import("react").JSX.Element;

package/dist/chat/ui/diff/LegacyEditDiff.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { LegacyDiffPool } from './LegacyDiffPool.js';
+import { useReviewSettled } from './review-settle.js';
+import { useMemo } from 'react';
+import { MultiFileDiff } from '@pierre/diffs/react';
+import { chatHost } from '../../../host.js';
+import { useDiffTheme } from '../diff-theme.js';
+export default function LegacyEditDiff({ change, maxHeight }) {
+    useReviewSettled();
+    const resolved = chatHost().code.useMode();
+    const theme = useDiffTheme();
+    const oldFile = useMemo(() => ({ name: change.path, contents: change.before }), [change.path, change.before]);
+    const newFile = useMemo(() => ({ name: change.path, contents: change.after }), [change.path, change.after]);
+    const options = useMemo(() => ({
+        diffStyle: 'unified',
+        theme,
+        themeType: resolved,
+        disableFileHeader: true,
+        overflow: 'wrap',
+        hunkSeparators: 'simple'
+    }), [theme, resolved]);
+    return (_jsx("div", { className: "chat-diff select-text", style: maxHeight === undefined ? undefined : { maxHeight, overflow: 'auto' }, children: _jsx(LegacyDiffPool, { children: _jsx(MultiFileDiff, { oldFile: oldFile, newFile: newFile, options: options }) }) }));
+}

package/dist/chat/ui/diff/LegacyUnifiedDiff.d.ts

@@ -0,0 +1,2 @@
+import type { UnifiedDiffProps } from './diff-props.js';
+export default function LegacyUnifiedDiff({ change, overflow, diffStyle, fill, contents, maxHeight }: UnifiedDiffProps): import("react").JSX.Element;

package/dist/chat/ui/diff/LegacyUnifiedDiff.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { LegacyDiffPool } from './LegacyDiffPool.js';
+import { useReviewSettled } from './review-settle.js';
+import { useMemo } from 'react';
+import clsx from 'clsx';
+import { FileDiff, PatchDiff } from '@pierre/diffs/react';
+import { chatHost } from '../../../host.js';
+import { useDiffTheme } from '../diff-theme.js';
+import { fullFileDiff } from '../full-diff.js';
+/*
+ * A patch the CLI reported itself. The renderer needs a file header, which a CLI that only sends hunks
+ * gets from the path we know; a diff without hunks is shown as its own lines, so nothing is swallowed.
+ */
+function asPatch(change) {
+    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}`;
+}
+/* Lets a diff with a view of its own run to its bottom, so a short one's scrollbar sits there and not under its last line. */
+const FILL_CSS = `
+:host { display: flex; flex-direction: column; flex-grow: 1; }
+pre { flex-grow: 1; align-content: start; }
+pre[data-diff-type="single"] { display: flex; flex-direction: column; }
+pre[data-diff-type="split"][data-overflow="scroll"]:not([data-dehydrated]) { align-content: stretch; }
+pre > [data-code] { flex-grow: 1; align-self: stretch; align-content: start; }
+`;
+function lineClass(line) {
+    if (line.startsWith('+')) {
+        return 'text-chat-added';
+    }
+    if (line.startsWith('-')) {
+        return 'text-chat-removed';
+    }
+    return 'text-text-muted';
+}
+export default function LegacyUnifiedDiff({ change, overflow = 'wrap', diffStyle = 'unified', fill = false, contents, maxHeight }) {
+    useReviewSettled();
+    const resolved = chatHost().code.useMode();
+    const theme = useDiffTheme();
+    const patch = useMemo(() => asPatch(change), [change]);
+    const oldText = contents?.old;
+    const newText = contents?.new;
+    const full = useMemo(() => (patch === null || oldText === undefined || newText === undefined ? null : fullFileDiff(patch, change.path, { old: oldText, new: newText })), [patch, change.path, oldText, newText]);
+    const unfolds = full !== null;
+    const options = useMemo(() => ({
+        theme,
+        themeType: resolved,
+        disableFileHeader: true,
+        diffStyle,
+        overflow,
+        hunkSeparators: unfolds ? 'line-info' : 'simple',
+        unsafeCSS: fill ? FILL_CSS : undefined
+    }), [diffStyle, overflow, theme, resolved, fill, unfolds]);
+    if (patch === null) {
+        return (_jsx("pre", { className: "max-h-64 overflow-auto px-3 py-2 font-mono text-code select-text", style: fill ? undefined : { maxHeight }, children: change.diff
+                .replace(/\n$/, '')
+                .split('\n')
+                .map((line, index) => (_jsx("div", { className: clsx(lineClass(line), 'whitespace-pre-wrap'), children: line }, index))) }));
+    }
+    return (_jsx("div", { className: clsx('chat-diff select-text', fill && 'flex grow flex-col'), style: fill || maxHeight === undefined ? undefined : { maxHeight, overflow: 'auto' }, children: _jsx(LegacyDiffPool, { children: full === null ? _jsx(PatchDiff, { patch: patch, options: options }) : _jsx(FileDiff, { fileDiff: full, options: options }) }) }));
+}

package/dist/chat/ui/diff/RawDiff.d.ts

@@ -0,0 +1,6 @@
+export declare function RawDiff({ text, overflow, fill, maxHeight }: {
+    text: string;
+    overflow: 'wrap' | 'scroll';
+    fill: boolean;
+    maxHeight?: number;
+}): import("react").JSX.Element;

package/dist/chat/ui/diff/RawDiff.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import clsx from 'clsx';
+import { useReviewSettled } from './review-settle.js';
+export function RawDiff({ text, overflow, fill, maxHeight }) {
+    useReviewSettled();
+    return (_jsx("pre", { "data-diff-raw": true, className: clsx('overflow-auto px-3 py-2 font-mono text-code text-text-muted select-text', fill && 'h-full min-h-0', overflow === 'wrap' ? 'whitespace-pre-wrap' : 'whitespace-pre'), style: fill ? undefined : { maxHeight: maxHeight ?? 256 }, children: text.replace(/\n$/, '') }));
+}

package/dist/chat/ui/diff/ReviewDiff.d.ts

@@ -0,0 +1,5 @@
+import type { ReviewEntry } from './review-plan.js';
+export declare function ReviewDiff({ entry, maxHeight }: {
+    entry: ReviewEntry;
+    maxHeight?: number;
+}): import("react").JSX.Element;

package/dist/chat/ui/diff/ReviewDiff.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense } from 'react';
+import { useTranslation } from 'react-i18next';
+import { lazyNamed } from '../../../lazy.js';
+const EditDiff = lazyNamed(() => import('../EditDiff.js'), 'default');
+const UnifiedDiff = lazyNamed(() => import('../UnifiedDiff.js'), 'default');
+export function ReviewDiff({ entry, maxHeight = 480 }) {
+    const { t } = useTranslation('agent-chat');
+    return (_jsx("div", { "data-review-entry": entry.key, children: _jsx(Suspense, { fallback: _jsx("p", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: entry.change.kind === 'edit' ? (_jsx(EditDiff, { change: entry.change.edit, maxHeight: maxHeight })) : (_jsx(UnifiedDiff, { change: entry.change.patch, contents: entry.change.contents, maxHeight: maxHeight })) }) }));
+}

package/dist/chat/ui/diff/diff-props.d.ts

@@ -0,0 +1,12 @@
+import type { ChatFileChange } from '@adecore/agent-contracts';
+import type { DiffContents } from '../full-diff.js';
+export interface UnifiedDiffProps {
+    allowEditor?: boolean;
+    maxHeight?: number;
+    ignoreWhitespace?: boolean;
+    change: ChatFileChange;
+    overflow?: 'wrap' | 'scroll';
+    diffStyle?: 'unified' | 'split';
+    fill?: boolean;
+    contents?: DiffContents;
+}

package/dist/chat/ui/diff/diff-props.js

@@ -0,0 +1 @@
+export {};

package/dist/chat/ui/diff/diff-source-budget.d.ts

@@ -0,0 +1,10 @@
+interface TextBudget {
+    readonly rows: number;
+    readonly characters: number;
+    readonly lineLength: number;
+}
+export declare function textFitsBudget(text: string, budget: TextBudget): boolean;
+export declare function diffSourceBudget(before: string, after: string): boolean;
+export declare function patchSourceBudget(patch: string): boolean;
+export declare function legacyDiffBudget(before: string, after: string, patch?: string): boolean;
+export {};