@slats/claude-assets-sync 0.2.0 → 0.3.1

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 {};

package/dist/ui/components/TargetCard.mjs

@@ -0,0 +1,29 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+import { PlanTable } from './PlanTable.mjs';
+
+function countActions(actions) {
+    let copy = 0;
+    let skip = 0;
+    let warn = 0;
+    let del = 0;
+    for (const action of actions) {
+        if (action.kind === 'copy')
+            copy += 1;
+        else if (action.kind === 'skip-uptodate')
+            skip += 1;
+        else if (action.kind === 'warn-diverged' || action.kind === 'warn-orphan')
+            warn += 1;
+        else if (action.kind === 'delete')
+            del += 1;
+    }
+    return { copy, skip, warn, del };
+}
+function TargetCard({ target, plan, expanded = true, highlighted = false, }) {
+    const counts = plan ? countActions(plan.actions) : null;
+    return (jsxs(Box, { flexDirection: "column", marginTop: 1, children: [jsxs(Box, { children: [jsxs(Text, { color: highlighted ? colors.accent : colors.primary, bold: true, children: [icons.triangleRight, ' '] }), jsx(Text, { bold: true, children: target.name }), jsxs(Text, { color: colors.muted, dimColor: true, children: ["@", target.version] }), counts ? (jsxs(Text, { color: colors.muted, children: ['   [', jsxs(Text, { color: colors.success, bold: true, children: [counts.copy, " copy"] }), ' · ', jsxs(Text, { color: colors.muted, dimColor: true, children: [counts.skip, " skip"] }), counts.warn > 0 ? (jsxs(Fragment, { children: [' · ', jsxs(Text, { color: colors.warn, bold: true, children: [counts.warn, " ", icons.warning] })] })) : null, counts.del > 0 ? (jsxs(Fragment, { children: [' · ', jsxs(Text, { color: colors.danger, bold: true, children: [counts.del, " ", icons.minus] })] })) : null, ']'] })) : null] }), expanded && plan ? (jsx(Box, { marginLeft: 2, children: jsx(PlanTable, { plan: plan }) })) : null] }));
+}
+
+export { TargetCard };

package/dist/ui/hooks/useApplyStep.d.ts

@@ -0,0 +1,12 @@
+import type { InjectReport } from '../../core/index.js';
+import type { InjectEvent, TargetPlan } from '../types/index.js';
+interface ApplyStepInput {
+    readonly plans: readonly TargetPlan[];
+    readonly dryRun: boolean;
+    readonly dispatch: (event: InjectEvent) => void;
+}
+export declare function applyAllPlans({ plans, dryRun, dispatch, }: ApplyStepInput): Promise<{
+    reports: InjectReport[];
+    exitCode: 0 | 1 | 2;
+}>;
+export {};

package/dist/ui/hooks/useApplyStep.mjs

@@ -0,0 +1,30 @@
+import { applyAction } from '../../core/injectDocs/utils/applyAction.mjs';
+import { summarize } from '../../core/injectDocs/utils/summarize.mjs';
+import { asyncPool } from '../../utils/asyncPool.mjs';
+
+const CONCURRENCY = 8;
+async function applyAllPlans({ plans, dryRun, dispatch, }) {
+    const total = plans.reduce((acc, tp) => acc + tp.plan.actions.length, 0);
+    let done = 0;
+    dispatch({ type: 'apply-start', total });
+    if (dryRun) {
+        const reports = plans.map((tp) => summarize(tp.plan, 0));
+        dispatch({ type: 'done', reports, exitCode: 0, dryRun: true });
+        return { reports, exitCode: 0 };
+    }
+    const reports = [];
+    for (const tp of plans) {
+        await asyncPool(CONCURRENCY, tp.plan.actions, async (action) => {
+            await applyAction(action, tp.target.assetRoot);
+            done += 1;
+            dispatch({ type: 'apply-progress', done, current: action.relPath });
+        });
+        reports.push(summarize(tp.plan, 0));
+    }
+    const hasFailure = reports.some((r) => r.exitCode !== 0);
+    const exitCode = hasFailure ? 1 : 0;
+    dispatch({ type: 'done', reports, exitCode, dryRun: false });
+    return { reports, exitCode };
+}
+
+export { applyAllPlans };

package/dist/ui/hooks/useExitApp.d.ts

@@ -0,0 +1,8 @@
+interface UseExitAppOptions {
+    readonly enabled: boolean;
+    readonly exitCode: 0 | 1 | 2;
+    readonly onExit: (code: 0 | 1 | 2) => void;
+    readonly delayMs?: number;
+}
+export declare function useExitApp({ enabled, exitCode, onExit, delayMs, }: UseExitAppOptions): void;
+export {};

package/dist/ui/hooks/useExitApp.mjs

@@ -0,0 +1,19 @@
+import { useEffect } from 'react';
+import { useApp } from 'ink';
+
+function useExitApp({ enabled, exitCode, onExit, delayMs = 0, }) {
+    const { exit } = useApp();
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const handle = setTimeout(() => {
+            onExit(exitCode);
+            exit();
+        }, delayMs);
+        return () => {
+            clearTimeout(handle);
+        };
+    }, [enabled, exitCode, delayMs, exit, onExit]);
+}
+
+export { useExitApp };

package/dist/ui/hooks/useForceConfirmStep.d.ts

@@ -0,0 +1,9 @@
+import type { InjectEvent, TargetPlan, Warning } from '../types/index.js';
+interface RequestForceConfirmInput {
+    readonly plans: readonly TargetPlan[];
+    readonly warnings: readonly Warning[];
+    readonly force: boolean;
+    readonly dispatch: (event: InjectEvent) => void;
+}
+export declare function requestForceConfirm({ plans, warnings, force, dispatch, }: RequestForceConfirmInput): Promise<boolean>;
+export {};

package/dist/ui/hooks/useForceConfirmStep.mjs

@@ -0,0 +1,24 @@
+async function requestForceConfirm({ plans, warnings, force, dispatch, }) {
+    const hasWarnings = plans.some((p) => p.plan.requiresForce);
+    if (!hasWarnings)
+        return true;
+    if (!force) {
+        dispatch({
+            type: 'fail',
+            error: new Error('Re-run with --force to proceed, or inspect with --dry-run.'),
+        });
+        return false;
+    }
+    return new Promise((resolve) => {
+        dispatch({
+            type: 'force-confirm-required',
+            warnings,
+            pending: (ok) => {
+                dispatch({ type: 'force-answer', ok });
+                resolve(ok);
+            },
+        });
+    });
+}
+
+export { requestForceConfirm };

package/dist/ui/hooks/useInjectSession.d.ts

@@ -0,0 +1,10 @@
+import type { ConsumerPackage, DefaultFlags } from '../../commands/runCli/type.js';
+import type { InjectEvent } from '../types/index.js';
+interface UseInjectSessionOptions {
+    readonly targets: readonly ConsumerPackage[];
+    readonly flags: DefaultFlags;
+    readonly originCwd: string;
+    readonly dispatch: (event: InjectEvent) => void;
+}
+export declare function useInjectSession({ targets, flags, originCwd, dispatch, }: UseInjectSessionOptions): void;
+export {};

package/dist/ui/hooks/useInjectSession.mjs

@@ -0,0 +1,63 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { applyAllPlans } from './useApplyStep.mjs';
+import { requestForceConfirm } from './useForceConfirmStep.mjs';
+import { usePlanStep } from './usePlanStep.mjs';
+import { useResolveStep } from './useResolveStep.mjs';
+
+function useInjectSession({ targets, flags, originCwd, dispatch, }) {
+    const [scope, setScope] = useState(null);
+    const [plansReady, setPlansReady] = useState(null);
+    const pipelineStarted = useRef(false);
+    const onScopeResolved = useCallback((resolved) => {
+        setScope(resolved);
+    }, []);
+    const onPlansReady = useCallback((plans, warnings) => {
+        setPlansReady({ plans, warnings });
+    }, []);
+    useResolveStep({ targets, flags, dispatch, onScopeResolved });
+    usePlanStep({
+        targets,
+        scope,
+        originCwd,
+        force: Boolean(flags.force),
+        dispatch,
+        onPlansReady,
+    });
+    useEffect(() => {
+        if (!plansReady || pipelineStarted.current)
+            return;
+        pipelineStarted.current = true;
+        (async () => {
+            const { plans, warnings } = plansReady;
+            if (plans.length === 0) {
+                dispatch({
+                    type: 'done',
+                    reports: [],
+                    exitCode: 2,
+                    dryRun: Boolean(flags.dryRun),
+                });
+                return;
+            }
+            const ok = await requestForceConfirm({
+                plans,
+                warnings,
+                force: Boolean(flags.force),
+                dispatch,
+            });
+            if (!ok)
+                return;
+            await applyAllPlans({
+                plans,
+                dryRun: Boolean(flags.dryRun),
+                dispatch,
+            });
+        })().catch((error) => {
+            dispatch({
+                type: 'fail',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        });
+    }, [plansReady, flags.force, flags.dryRun, dispatch]);
+}
+
+export { useInjectSession };

package/dist/ui/hooks/useInterval.d.ts

@@ -0,0 +1 @@
+export declare function useInterval(callback: () => void, delayMs: number | null): void;

package/dist/ui/hooks/usePhase.d.ts

@@ -0,0 +1,2 @@
+import type { InjectEvent, Phase } from '../types/index.js';
+export declare function usePhase(initial: Phase): [Phase, (event: InjectEvent) => void];

package/dist/ui/hooks/usePhase.mjs

@@ -0,0 +1,9 @@
+import { useReducer } from 'react';
+import { phaseReducer } from '../InjectApp/utils/phaseReducer.mjs';
+
+function usePhase(initial) {
+    const [phase, dispatch] = useReducer(phaseReducer, initial);
+    return [phase, dispatch];
+}
+
+export { usePhase };

package/dist/ui/hooks/usePlanStep.d.ts

@@ -0,0 +1,13 @@
+import type { ConsumerPackage } from '../../commands/runCli/type.js';
+import { type Scope } from '../../core/index.js';
+import type { InjectEvent, TargetPlan, Warning } from '../types/index.js';
+interface UsePlanStepOptions {
+    readonly targets: readonly ConsumerPackage[];
+    readonly scope: Scope | null;
+    readonly originCwd: string;
+    readonly force: boolean;
+    readonly dispatch: (event: InjectEvent) => void;
+    readonly onPlansReady: (plans: readonly TargetPlan[], warnings: readonly Warning[]) => void;
+}
+export declare function usePlanStep({ targets, scope, originCwd, force, dispatch, onPlansReady, }: UsePlanStepOptions): void;
+export {};