@slats/claude-assets-sync 0.3.0 → 0.3.2

package/dist/ui/InjectApp/utils/eventSelectors.mjs

@@ -0,0 +1,24 @@
+function scopeLabel(phase) {
+    switch (phase.kind) {
+        case 'planning':
+        case 'diff-review':
+        case 'force-confirm':
+        case 'applying':
+        case 'summary':
+            return phase.scope;
+        default:
+            return undefined;
+    }
+}
+function etaSeconds(startedAt, done, total, now = Date.now()) {
+    if (done === 0)
+        return undefined;
+    const elapsedMs = Math.max(now - startedAt, 1);
+    const rate = done / elapsedMs;
+    const remaining = total - done;
+    if (rate <= 0)
+        return undefined;
+    return remaining / rate / 1000;
+}
+
+export { etaSeconds, scopeLabel };

package/dist/ui/InjectApp/utils/phaseReducer.d.ts

@@ -0,0 +1,2 @@
+import type { InjectEvent, Phase } from '../../types/index.js';
+export declare function phaseReducer(phase: Phase, event: InjectEvent): Phase;

package/dist/ui/InjectApp/utils/phaseReducer.mjs

@@ -0,0 +1,133 @@
+function phaseReducer(phase, event) {
+    switch (event.type) {
+        case 'scope-needed': {
+            if (phase.kind === 'booting' || phase.kind === 'resolving') {
+                return {
+                    kind: 'scope-select',
+                    targets: phase.kind === 'resolving' ? phase.targets : [],
+                    pending: event.pending,
+                };
+            }
+            return phase;
+        }
+        case 'scope-selected': {
+            return phase;
+        }
+        case 'planning-started': {
+            const progress = new Map(event.targets.map((t) => [
+                t.name,
+                { packageName: t.name, status: 'pending' },
+            ]));
+            return {
+                kind: 'planning',
+                targets: event.targets,
+                scope: event.scope,
+                progress,
+            };
+        }
+        case 'plan-step': {
+            if (phase.kind !== 'planning')
+                return phase;
+            const next = new Map(phase.progress);
+            next.set(event.step.packageName, event.step);
+            return { ...phase, progress: next };
+        }
+        case 'plans-ready': {
+            if (phase.kind !== 'planning')
+                return phase;
+            return {
+                kind: 'diff-review',
+                plans: event.plans,
+                focusedIndex: 0,
+                scope: phase.scope,
+            };
+        }
+        case 'focus-target': {
+            if (phase.kind !== 'diff-review')
+                return phase;
+            return { ...phase, focusedIndex: event.index };
+        }
+        case 'force-confirm-required': {
+            if (phase.kind !== 'diff-review' && phase.kind !== 'applying')
+                return phase;
+            return {
+                kind: 'force-confirm',
+                plans: phase.kind === 'diff-review' ? phase.plans : phase.plans,
+                warnings: event.warnings,
+                pending: event.pending,
+                scope: phase.scope,
+            };
+        }
+        case 'force-answer': {
+            if (phase.kind !== 'force-confirm')
+                return phase;
+            if (!event.ok) {
+                return {
+                    kind: 'summary',
+                    reports: [],
+                    plans: phase.plans,
+                    exitCode: 2,
+                    scope: phase.scope,
+                    dryRun: false,
+                };
+            }
+            return {
+                kind: 'applying',
+                plans: phase.plans,
+                progress: {
+                    done: 0,
+                    total: phase.plans.reduce((acc, tp) => acc + tp.plan.actions.length, 0),
+                    startedAt: Date.now(),
+                },
+                scope: phase.scope,
+            };
+        }
+        case 'apply-start': {
+            if (phase.kind !== 'diff-review' && phase.kind !== 'force-confirm')
+                return phase;
+            const plans = phase.kind === 'diff-review' ? phase.plans : phase.plans;
+            return {
+                kind: 'applying',
+                plans,
+                progress: { done: 0, total: event.total, startedAt: Date.now() },
+                scope: phase.scope,
+            };
+        }
+        case 'apply-progress': {
+            if (phase.kind !== 'applying')
+                return phase;
+            return {
+                ...phase,
+                progress: {
+                    ...phase.progress,
+                    done: event.done,
+                    current: event.current,
+                },
+            };
+        }
+        case 'done': {
+            const scope = phase.kind === 'applying' || phase.kind === 'diff-review'
+                ? phase.scope
+                : 'user';
+            const plans = phase.kind === 'applying' || phase.kind === 'diff-review'
+                ? phase.plans
+                : [];
+            return {
+                kind: 'summary',
+                reports: event.reports,
+                plans,
+                exitCode: event.exitCode,
+                scope,
+                dryRun: event.dryRun,
+            };
+        }
+        case 'fail': {
+            return { kind: 'error', error: event.error };
+        }
+        default: {
+            return phase;
+        }
+    }
+}
+
+export { phaseReducer };

package/dist/ui/InjectApp/utils/renderInjectApp.d.ts

@@ -0,0 +1,2 @@
+import type { RenderInput } from '../../types/index.js';
+export declare function renderInjectApp(input: RenderInput): Promise<number>;

package/dist/ui/InjectApp/utils/renderInjectApp.mjs

@@ -0,0 +1,19 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { InjectApp } from '../InjectApp.mjs';
+
+async function renderInjectApp(input) {
+    let exitCode = 0;
+    const instance = render(jsx(InjectApp, { ...input, onExit: (code) => {
+            exitCode = code;
+        } }), { exitOnCtrlC: true });
+    try {
+        await instance.waitUntilExit();
+        return exitCode;
+    }
+    finally {
+        instance.unmount();
+    }
+}
+
+export { renderInjectApp };

package/dist/ui/InjectApp/utils/type.d.ts

@@ -0,0 +1,5 @@
+import type { RenderInput } from '../../types/index.js';
+export type { Phase, InjectEvent, RenderInput } from '../../types/index.js';
+export interface InjectAppProps extends RenderInput {
+    readonly onExit: (code: 0 | 1 | 2) => void;
+}

package/dist/ui/components/ActionRow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { Action } from '../../core/buildPlan/index.js';
+interface ActionRowProps {
+    readonly action: Action;
+}
+export declare function ActionRow({ action }: ActionRowProps): React.ReactElement;
+export {};

package/dist/ui/components/ActionRow.mjs

@@ -0,0 +1,45 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+
+function visualFor(action) {
+    switch (action.kind) {
+        case 'copy':
+            return { icon: icons.plus, color: colors.success };
+        case 'skip-uptodate':
+            return {
+                icon: icons.equals,
+                color: colors.muted,
+                dim: true,
+                note: 'up-to-date',
+            };
+        case 'warn-diverged':
+            return {
+                icon: icons.warning,
+                color: colors.warn,
+                note: 'diverged',
+            };
+        case 'warn-orphan':
+            return {
+                icon: icons.question,
+                color: colors.warn,
+                note: 'orphan',
+            };
+        case 'delete':
+            return {
+                icon: icons.minus,
+                color: colors.danger,
+                note: 'delete',
+            };
+        default: {
+            return { icon: '?', color: colors.muted };
+        }
+    }
+}
+function ActionRow({ action }) {
+    const visual = visualFor(action);
+    return (jsxs(Box, { children: [jsxs(Text, { color: visual.color, bold: true, children: [' ', visual.icon, ' '] }), jsx(Text, { color: colors.muted, dimColor: visual.dim, children: action.relPath }), visual.note ? (jsxs(Text, { color: colors.muted, dimColor: true, children: ['  ', "(", visual.note, ")"] })) : null] }));
+}
+
+export { ActionRow };

package/dist/ui/components/Banner.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface BannerProps {
+    readonly version: string;
+    readonly scope?: string;
+}
+export declare function Banner({ version, scope, }: BannerProps): React.ReactElement;
+export {};

package/dist/ui/components/Banner.mjs

@@ -0,0 +1,9 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+
+function Banner({ version, scope, }) {
+    return (jsxs(Box, { borderStyle: "round", borderColor: colors.primary, paddingX: 1, alignSelf: "flex-start", children: [jsx(Text, { bold: true, color: colors.primary, children: "claude-sync" }), jsxs(Text, { color: colors.muted, children: [' ', "v", version] }), scope ? (jsxs(Text, { children: [jsx(Text, { color: colors.muted, children: '  →  ' }), jsx(Text, { color: colors.accent, bold: true, children: scope })] })) : null] }));
+}
+
+export { Banner };

package/dist/ui/components/ConfirmForce.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { Warning } from '../types/index.js';
+interface ConfirmForceProps {
+    readonly warnings: readonly Warning[];
+    readonly onAnswer: (ok: boolean) => void;
+}
+export declare function ConfirmForce({ warnings, onAnswer, }: ConfirmForceProps): React.ReactElement;
+export {};

package/dist/ui/components/ConfirmForce.mjs

@@ -0,0 +1,35 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+import { limits } from '../theme/layout.mjs';
+
+function ConfirmForce({ warnings, onAnswer, }) {
+    const [expanded, setExpanded] = useState(false);
+    const showAll = expanded || warnings.length <= limits.maxWarningsBeforeCollapse;
+    const shown = showAll
+        ? warnings
+        : warnings.slice(0, limits.maxWarningsBeforeCollapse);
+    const hidden = warnings.length - shown.length;
+    const diverged = warnings.filter((w) => w.kind === 'warn-diverged').length;
+    const orphans = warnings.filter((w) => w.kind === 'warn-orphan').length;
+    const items = [
+        { label: `Yes, overwrite ${warnings.length} path(s)`, value: 'accept' },
+        { label: 'No, cancel', value: 'cancel' },
+    ];
+    if (!showAll) {
+        items.push({ label: `Show all (${hidden} hidden)`, value: 'expand' });
+    }
+    return (jsxs(Box, { flexDirection: "column", marginTop: 1, children: [jsxs(Text, { color: colors.warn, bold: true, children: [icons.warning, " ", warnings.length, " path(s) need --force confirmation"] }), jsx(Box, { marginLeft: 2, children: jsxs(Text, { color: colors.muted, dimColor: true, children: [diverged, " diverged \u00B7 ", orphans, " orphan"] }) }), jsxs(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [shown.map((warning) => (jsxs(Box, { children: [jsxs(Text, { color: warning.kind === 'warn-diverged' ? colors.warn : colors.accent, bold: true, children: [warning.kind === 'warn-diverged' ? icons.warning : icons.question, ' '] }), jsxs(Text, { color: colors.muted, dimColor: true, children: ["[", warning.packageName, "]", ' '] }), jsx(Text, { children: warning.relPath })] }, `${warning.packageName}:${warning.relPath}`))), !showAll ? (jsxs(Text, { color: colors.muted, dimColor: true, children: ["\u2026 ", hidden, " more hidden"] })) : null] }), jsx(Box, { marginLeft: 2, marginTop: 1, children: jsx(SelectInput, { items: items, onSelect: (item) => {
+                        if (item.value === 'accept')
+                            onAnswer(true);
+                        else if (item.value === 'cancel')
+                            onAnswer(false);
+                        else
+                            setExpanded(true);
+                    } }) })] }));
+}
+
+export { ConfirmForce };

package/dist/ui/components/ErrorPanel.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ErrorPanelProps {
+    readonly error: Error;
+}
+export declare function ErrorPanel({ error, }: ErrorPanelProps): React.ReactElement;
+export {};

package/dist/ui/components/ErrorPanel.mjs

@@ -0,0 +1,14 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+
+function ErrorPanel({ error, }) {
+    return (jsxs(Box, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [jsxs(Text, { color: colors.danger, bold: true, children: [icons.cross, " ", error.name ?? 'Error'] }), jsx(Box, { marginLeft: 2, marginTop: 1, children: jsx(Text, { color: colors.danger, children: error.message }) }), error.stack ? (jsx(Box, { marginLeft: 2, marginTop: 1, children: jsx(Text, { color: colors.muted, dimColor: true, children: error.stack
+                        .split('\n')
+                        .slice(1, 4)
+                        .map((l) => l.trim())
+                        .join('\n') }) })) : null] }));
+}
+
+export { ErrorPanel };

package/dist/ui/components/Footer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { Phase } from '../types/index.js';
+interface FooterProps {
+    readonly phase: Phase;
+    readonly version: string;
+}
+export declare function Footer({ phase, version, }: FooterProps): React.ReactElement;
+export {};

package/dist/ui/components/Footer.mjs

@@ -0,0 +1,27 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+
+function hintsFor(kind) {
+    switch (kind) {
+        case 'scope-select':
+            return '↑↓:select · enter:confirm · ctrl-c:cancel';
+        case 'diff-review':
+            return 'enter:apply · a:accept all warn · esc:cancel';
+        case 'force-confirm':
+            return 'y:accept · n:cancel';
+        case 'applying':
+            return 'ctrl-c:abort';
+        case 'summary':
+            return 'enter:exit';
+        case 'error':
+            return 'enter:exit';
+        default:
+            return 'ctrl-c:cancel';
+    }
+}
+function Footer({ phase, version, }) {
+    return (jsxs(Box, { marginTop: 1, children: [jsx(Text, { color: colors.muted, dimColor: true, children: hintsFor(phase.kind) }), jsxs(Text, { color: colors.muted, dimColor: true, children: ['        v', version] }), jsxs(Text, { color: colors.muted, dimColor: true, children: ['  phase: ', phase.kind] })] }));
+}
+
+export { Footer };

package/dist/ui/components/PlanTable.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { InjectPlan } from '../../core/buildPlan/index.js';
+interface PlanTableProps {
+    readonly plan: InjectPlan;
+    readonly maxRows?: number;
+}
+export declare function PlanTable({ plan, maxRows, }: PlanTableProps): React.ReactElement;
+export {};

package/dist/ui/components/PlanTable.mjs

@@ -0,0 +1,15 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+import { limits } from '../theme/layout.mjs';
+import { ActionRow } from './ActionRow.mjs';
+
+function PlanTable({ plan, maxRows = limits.maxPlanRowsBeforeTruncate, }) {
+    const actions = plan.actions;
+    const overflow = actions.length > maxRows;
+    const shown = overflow ? actions.slice(0, limits.planTruncatedReveal) : actions;
+    const hidden = actions.length - shown.length;
+    return (jsxs(Box, { flexDirection: "column", children: [shown.map((action) => (jsx(ActionRow, { action: action }, `${action.kind}-${action.relPath}`))), overflow ? (jsx(Box, { marginLeft: 2, children: jsxs(Text, { color: colors.muted, dimColor: true, children: ["\u2026 ", hidden, " more action(s) hidden"] }) })) : null] }));
+}
+
+export { PlanTable };

package/dist/ui/components/ProgressBar.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface ProgressBarProps {
+    readonly done: number;
+    readonly total: number;
+    readonly width?: number;
+    readonly etaSeconds?: number;
+    readonly label?: string;
+}
+export declare function ProgressBar({ done, total, width, etaSeconds, label, }: ProgressBarProps): React.ReactElement;
+export {};

package/dist/ui/components/ProgressBar.mjs

@@ -0,0 +1,28 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+import { widths } from '../theme/layout.mjs';
+
+function formatEta(seconds) {
+    if (seconds === undefined || !Number.isFinite(seconds))
+        return null;
+    if (seconds < 1)
+        return '<1s';
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    const m = Math.floor(seconds / 60);
+    const s = Math.round(seconds % 60);
+    return `${m}m${s}s`;
+}
+function ProgressBar({ done, total, width = widths.progressBarDefault, etaSeconds, label, }) {
+    const safeTotal = Math.max(total, 1);
+    const ratio = Math.min(Math.max(done / safeTotal, 0), 1);
+    const filled = Math.round(ratio * width);
+    const empty = width - filled;
+    const percent = Math.round(ratio * 100);
+    const eta = formatEta(etaSeconds);
+    return (jsxs(Box, { children: [jsx(Text, { color: colors.success, children: icons.blockFull.repeat(filled) }), jsx(Text, { color: colors.muted, dimColor: true, children: icons.blockEmpty.repeat(empty) }), jsxs(Text, { color: colors.muted, children: [' ', String(percent).padStart(3), "%"] }), jsxs(Text, { color: colors.muted, dimColor: true, children: ['  ', "(", done, "/", total, eta ? ` · ETA ${eta}` : '', ")"] }), label ? (jsxs(Text, { color: colors.muted, dimColor: true, children: ['  ', label] })) : null] }));
+}
+
+export { ProgressBar };

package/dist/ui/components/ScopePicker.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { Scope } from '../../core/index.js';
+interface ScopePickerProps {
+    readonly onSelect: (scope: Scope) => void;
+}
+export declare function ScopePicker({ onSelect, }: ScopePickerProps): React.ReactElement;
+export {};

package/dist/ui/components/ScopePicker.mjs

@@ -0,0 +1,26 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+
+const ITEMS = [
+    {
+        label: 'user',
+        value: 'user',
+        hint: '~/.claude (global)',
+    },
+    {
+        label: 'project',
+        value: 'project',
+        hint: 'nearest ancestor .claude (or cwd)',
+    },
+];
+function ScopePicker({ onSelect, }) {
+    return (jsxs(Box, { flexDirection: "column", marginTop: 1, children: [jsxs(Text, { bold: true, color: colors.primary, children: [icons.triangleRight, " Select the target scope"] }), jsx(Box, { marginLeft: 2, marginTop: 1, children: jsx(SelectInput, { items: ITEMS.map((it) => ({ label: it.label, value: it.value })), onSelect: (item) => onSelect(item.value), itemComponent: ({ isSelected, label }) => {
+                        const entry = ITEMS.find((it) => it.label === label);
+                        return (jsxs(Box, { children: [jsxs(Text, { color: isSelected ? colors.accent : colors.muted, bold: true, children: [isSelected ? icons.triangleRight : ' ', ' '] }), jsx(Text, { color: isSelected ? colors.primary : colors.muted, bold: isSelected, children: label.padEnd(8) }), entry ? (jsx(Text, { color: colors.muted, dimColor: true, children: entry.hint })) : null] }));
+                    } }) })] }));
+}
+
+export { ScopePicker };

package/dist/ui/components/Spinner.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface SpinnerProps {
+    readonly label?: string;
+    readonly color?: string;
+    readonly variant?: 'dots' | 'line' | 'arc';
+}
+export declare function Spinner({ label, color, variant, }: SpinnerProps): React.ReactElement;
+export {};

package/dist/ui/components/Spinner.mjs

@@ -0,0 +1,10 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import InkSpinner from 'ink-spinner';
+import { colors } from '../theme/colors.mjs';
+
+function Spinner({ label, color = colors.primary, variant = 'dots', }) {
+    return (jsxs(Box, { children: [jsx(Text, { color: color, children: jsx(InkSpinner, { type: variant }) }), label ? (jsxs(Text, { color: colors.muted, children: [' ', label] })) : null] }));
+}
+
+export { Spinner };

package/dist/ui/components/StatusBadge.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export type StatusKind = 'created' | 'updated' | 'skipped' | 'warn' | 'delete' | 'pending' | 'running' | 'done' | 'failed';
+interface StatusBadgeProps {
+    readonly kind: StatusKind;
+    readonly label?: string;
+}
+export declare function StatusBadge({ kind, label, }: StatusBadgeProps): React.ReactElement;
+export {};

package/dist/ui/components/StepTracker.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Phase } from '../types/index.js';
+interface StepTrackerProps {
+    readonly phase: Phase;
+    readonly targetCount?: number;
+    readonly scope?: string;
+}
+export declare function StepTracker({ phase, targetCount, scope, }: StepTrackerProps): React.ReactElement;
+export {};

package/dist/ui/components/StepTracker.mjs

@@ -0,0 +1,43 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import React from 'react';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+import { Spinner } from './Spinner.mjs';
+
+const STEPS = [
+    { key: 'resolve', label: 'resolve', phases: ['booting', 'resolving'] },
+    { key: 'scope', label: 'scope', phases: ['scope-select'] },
+    { key: 'plan', label: 'plan', phases: ['planning', 'diff-review', 'force-confirm'] },
+    { key: 'apply', label: 'apply', phases: ['applying'] },
+    { key: 'done', label: 'done', phases: ['summary', 'error'] },
+];
+function stepState(phaseIndex, stepIndex) {
+    if (stepIndex < phaseIndex)
+        return 'done';
+    if (stepIndex === phaseIndex)
+        return 'active';
+    return 'pending';
+}
+function phaseToIndex(kind) {
+    for (let i = 0; i < STEPS.length; i += 1) {
+        const step = STEPS[i];
+        if (step.phases.includes(kind))
+            return i;
+    }
+    return 0;
+}
+function StepTracker({ phase, targetCount, scope, }) {
+    const phaseIndex = phaseToIndex(phase.kind);
+    return (jsxs(Box, { children: [STEPS.map((step, idx) => {
+                const state = stepState(phaseIndex, idx);
+                const bulletColor = state === 'done'
+                    ? colors.success
+                    : state === 'active'
+                        ? colors.warn
+                        : colors.muted;
+                return (jsxs(React.Fragment, { children: [idx > 0 ? (jsxs(Text, { color: colors.muted, dimColor: true, children: [' ', icons.divider, ' '] })) : null, state === 'active' ? (jsx(Spinner, { color: bulletColor })) : (jsx(Text, { color: bulletColor, children: state === 'done' ? icons.bulletDone : icons.bulletPending })), jsxs(Text, { color: bulletColor, bold: state === 'active', dimColor: state === 'pending', children: [' ', step.label] })] }, step.key));
+            }), typeof targetCount === 'number' || scope ? (jsxs(Text, { color: colors.muted, dimColor: true, children: ['     ', typeof targetCount === 'number' ? `${targetCount} target${targetCount === 1 ? '' : 's'}` : '', scope ? ` · scope ${scope}` : ''] })) : null] }));
+}
+
+export { StepTracker };

package/dist/ui/components/Summary.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { InjectReport } from '../../core/index.js';
+interface SummaryProps {
+    readonly reports: readonly InjectReport[];
+    readonly exitCode: 0 | 1 | 2;
+    readonly dryRun: boolean;
+}
+export declare function Summary({ reports, exitCode, dryRun, }: SummaryProps): React.ReactElement;
+export {};

package/dist/ui/components/Summary.mjs

@@ -0,0 +1,30 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+
+function aggregate(reports) {
+    return reports.reduce((acc, report) => ({
+        created: acc.created + report.created.length,
+        updated: acc.updated + report.updated.length,
+        skipped: acc.skipped + report.skipped.length,
+        warnings: acc.warnings + report.warnings.length,
+        deleted: acc.deleted + report.deleted.length,
+    }), { created: 0, updated: 0, skipped: 0, warnings: 0, deleted: 0 });
+}
+function exitColor(code) {
+    if (code === 0)
+        return colors.success;
+    if (code === 2)
+        return colors.warn;
+    return colors.danger;
+}
+function Row({ label, value, labelColor, valueColor, labelBold, valueBold, }) {
+    return (jsxs(Box, { children: [jsx(Box, { width: 10, children: jsx(Text, { color: labelColor, bold: labelBold, children: label }) }), jsx(Text, { color: valueColor ?? colors.muted, bold: valueBold, children: String(value).padStart(3) })] }));
+}
+function Summary({ reports, exitCode, dryRun, }) {
+    const totals = aggregate(reports);
+    const exitTone = exitColor(exitCode);
+    return (jsxs(Box, { flexDirection: "column", borderStyle: "double", borderColor: colors.primary, paddingX: 2, paddingY: 0, marginTop: 1, alignSelf: "flex-start", children: [jsx(Box, { children: jsxs(Text, { bold: true, color: colors.primary, children: ["Summary", dryRun ? ' (dry-run)' : ''] }) }), jsxs(Box, { marginTop: 1, children: [jsxs(Box, { flexDirection: "column", marginRight: 4, children: [jsx(Row, { label: "created", value: totals.created, labelColor: colors.success, labelBold: true }), jsx(Row, { label: "skipped", value: totals.skipped, labelColor: colors.muted }), jsx(Row, { label: "deleted", value: totals.deleted, labelColor: colors.danger })] }), jsxs(Box, { flexDirection: "column", children: [jsx(Row, { label: "updated", value: totals.updated, labelColor: colors.success }), jsx(Row, { label: "warnings", value: totals.warnings, labelColor: colors.warn, labelBold: true }), jsx(Row, { label: "exit", value: exitCode, labelColor: exitTone, labelBold: true, valueColor: exitTone, valueBold: true })] })] })] }));
+}
+
+export { Summary };

package/dist/ui/components/TargetCard.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { InjectPlan } from '../../core/buildPlan/index.js';
+import type { ConsumerPackage } from '../../commands/runCli/type.js';
+interface TargetCardProps {
+    readonly target: ConsumerPackage;
+    readonly plan?: InjectPlan;
+    readonly expanded?: boolean;
+    readonly highlighted?: boolean;
+}
+export declare function TargetCard({ target, plan, expanded, highlighted, }: TargetCardProps): React.ReactElement;
+export {};