@rainy-updates/cli 0.5.4 → 0.5.6

package/dist/ui/dashboard/components/Sidebar.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+import { useDashboardStore } from "../store.js";
+// A heavily memoized single row
+const DependencyRow = React.memo(({ update, isActive }) => {
+    return (_jsxs(Box, { paddingX: 1, width: "100%", children: [_jsx(Box, { width: 2, children: _jsx(Text, { color: "cyan", children: isActive ? "> " : "  " }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { color: isActive ? "white" : "gray", bold: isActive, children: update.name }) }), _jsx(Box, { width: 15, justifyContent: "flex-end", children: _jsx(Text, { dimColor: true, children: update.fromRange }) }), _jsx(Box, { width: 3, justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "\u2192" }) }), _jsx(Box, { width: 15, children: _jsx(Text, { color: "green", children: update.toRange }) })] }));
+});
+DependencyRow.displayName = "DependencyRow";
+function SidebarComponent() {
+    const updates = useDashboardStore((s) => s.updates);
+    const selectedIndex = useDashboardStore((s) => s.selectedIndex);
+    // Simple windowing: in a real robust TUI we'd calculate terminal height
+    // For now we'll just slice the array based on a fixed viewport (e.g., 20 items)
+    const windowSize = 20;
+    const start = Math.max(0, Math.min(selectedIndex - windowSize / 2, updates.length - windowSize));
+    const visibleUpdates = updates.slice(start, start + windowSize);
+    return (_jsxs(Box, { width: "50%", flexDirection: "column", borderStyle: "single", borderColor: "gray", height: windowSize + 2, children: [visibleUpdates.map((update, i) => {
+                const actualIndex = start + i;
+                return (_jsx(DependencyRow, { update: update, index: actualIndex, isActive: actualIndex === selectedIndex }, `${update.name}-${update.toRange}`));
+            }), updates.length === 0 && (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "No updates found." }) }))] }));
+}
+export const Sidebar = React.memo(SidebarComponent);

package/dist/ui/dashboard/store.d.ts

@@ -0,0 +1,34 @@
+import type { DashboardOptions, CheckResult, PackageUpdate } from "../../types/index.js";
+export interface DashboardState {
+    selectedIndex: number;
+    view: "dependencies" | "security" | "health";
+    modal: "none" | "resolving" | "auditing" | "applying";
+    updates: PackageUpdate[];
+    summary: CheckResult["summary"];
+    options: DashboardOptions;
+    error?: string;
+    shouldApply: boolean;
+}
+type Listener = () => void;
+declare class DashboardStore {
+    private state;
+    private listeners;
+    constructor(initialState: DashboardState);
+    getState: () => DashboardState;
+    setState: (partial: Partial<DashboardState> | ((state: DashboardState) => Partial<DashboardState>)) => void;
+    subscribe: (listener: Listener) => () => boolean;
+    private emit;
+}
+export declare function initStore(options: DashboardOptions, initialResult: CheckResult): DashboardStore;
+export declare function useDashboardStore<T>(selector: (state: DashboardState) => T): T;
+export declare const dashboardActions: {
+    moveCursorUp: () => void;
+    moveCursorDown: () => void;
+    setView: (view: DashboardState["view"]) => void;
+    setModal: (modal: DashboardState["modal"]) => void;
+    setShouldApply: (shouldApply: boolean) => void;
+    runResolveAction: () => Promise<void>;
+    runAuditAction: () => Promise<void>;
+};
+export declare function getStore(): DashboardStore | null;
+export {};

package/dist/ui/dashboard/store.js

@@ -0,0 +1,148 @@
+import { useSyncExternalStore } from "react";
+import { runResolve } from "../../commands/resolve/runner.js";
+import { runAudit } from "../../commands/audit/runner.js";
+class DashboardStore {
+    state;
+    listeners = new Set();
+    constructor(initialState) {
+        this.state = initialState;
+    }
+    getState = () => this.state;
+    setState = (partial) => {
+        const changes = typeof partial === "function" ? partial(this.state) : partial;
+        this.state = { ...this.state, ...changes };
+        this.emit();
+    };
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    emit() {
+        for (const listener of this.listeners) {
+            listener();
+        }
+    }
+}
+// Global singleton per run
+let store = null;
+export function initStore(options, initialResult) {
+    if (!store) {
+        store = new DashboardStore({
+            selectedIndex: 0,
+            view: options.view ?? "dependencies",
+            modal: "none",
+            updates: initialResult.updates,
+            summary: initialResult.summary,
+            options,
+            shouldApply: false,
+        });
+    }
+    return store;
+}
+// Hook to use the store in components, taking a selector to prevent unnecessary re-renders
+export function useDashboardStore(selector) {
+    if (!store)
+        throw new Error("Store not initialized");
+    // Custom equality check could be added, but returning primitive/stable references from selector works best
+    return useSyncExternalStore(store.subscribe, () => selector(store.getState()));
+}
+// Export actions to modify state without re-rendering the caller
+export const dashboardActions = {
+    moveCursorUp: () => {
+        store?.setState((s) => ({
+            selectedIndex: Math.max(0, s.selectedIndex - 1),
+        }));
+    },
+    moveCursorDown: () => {
+        store?.setState((s) => ({
+            selectedIndex: Math.min(s.updates.length - 1, s.selectedIndex + 1),
+        }));
+    },
+    setView: (view) => {
+        store?.setState({ view, selectedIndex: 0 }); // reset cursor on view change
+    },
+    setModal: (modal) => {
+        store?.setState({ modal });
+    },
+    setShouldApply: (shouldApply) => {
+        store?.setState({ shouldApply });
+    },
+    runResolveAction: async () => {
+        if (!store)
+            return;
+        const s = store.getState();
+        store.setState({ modal: "resolving" });
+        try {
+            const resolveOpts = {
+                cwd: s.options.cwd,
+                workspace: s.options.workspace,
+                afterUpdate: true,
+                safe: true,
+                concurrency: s.options.concurrency,
+                registryTimeoutMs: s.options.registryTimeoutMs,
+                cacheTtlSeconds: s.options.cacheTtlSeconds,
+                silent: true,
+            };
+            const result = await runResolve(resolveOpts);
+            // Update updates array with the conflict severity
+            const updatedUpdates = s.updates.map((update) => {
+                const hasError = result.conflicts.some((c) => c.requester === update.name && c.severity === "error");
+                const hasWarning = result.conflicts.some((c) => c.requester === update.name && c.severity === "warning");
+                const severity = (hasError ? "error" : hasWarning ? "warning" : "none");
+                return { ...update, peerConflictSeverity: severity };
+            });
+            store.setState({ updates: updatedUpdates });
+        }
+        catch (err) {
+            store.setState({ error: String(err) });
+        }
+        finally {
+            store.setState({ modal: "none" });
+        }
+    },
+    runAuditAction: async () => {
+        if (!store)
+            return;
+        const s = store.getState();
+        store.setState({ modal: "auditing" });
+        try {
+            const auditOpts = {
+                cwd: s.options.cwd,
+                workspace: s.options.workspace,
+                fix: false,
+                dryRun: false,
+                commit: false,
+                packageManager: "auto",
+                reportFormat: "summary",
+                sourceMode: "auto",
+                concurrency: s.options.concurrency,
+                registryTimeoutMs: s.options.registryTimeoutMs,
+                silent: true,
+            };
+            const result = await runAudit(auditOpts);
+            // Map advisories back to updates
+            const updatedUpdates = s.updates.map((update) => {
+                const pkgSummary = result.packages.find((p) => p.packageName === update.name);
+                if (pkgSummary) {
+                    return {
+                        ...update,
+                        riskLevel: pkgSummary.severity,
+                        advisoryCount: pkgSummary.advisoryCount,
+                        toRange: pkgSummary.patchedVersion || update.toRange, // suggest the patch!
+                    };
+                }
+                return update;
+            });
+            store.setState({ updates: updatedUpdates });
+        }
+        catch (err) {
+            store.setState({ error: String(err) });
+        }
+        finally {
+            store.setState({ modal: "none" });
+        }
+    },
+};
+export function getStore() {
+    return store;
+}

package/dist/ui/tui.d.ts

@@ -1,2 +1,2 @@
-import type { PackageUpdate } from "../types/index.js";
-export declare function runTui(updates: PackageUpdate[]): Promise<PackageUpdate[]>;
+import type { ReviewItem } from "../types/index.js";
+export declare function runTui(items: ReviewItem[]): Promise<ReviewItem[]>;

package/dist/ui/tui.js

@@ -6,9 +6,307 @@ const FILTER_ORDER = [
     "security",
     "risky",
     "major",
+    "peer-conflict",
+    "license",
+    "unused",
+    "blocked",
 ];
-function VersionDiff({ from, to }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: from }), _jsxs(Text, { color: "gray", children: [" ", " -> ", " "] }), _jsx(Text, { color: "green", children: to })] }));
+const SORT_ORDER = ["risk", "advisories", "diff", "name", "workspace"];
+const GROUP_ORDER = ["none", "workspace", "scope", "risk", "decision"];
+const DETAIL_TABS = [
+    "overview",
+    "risk",
+    "security",
+    "peer",
+    "license",
+    "health",
+    "changelog",
+];
+function TuiApp({ items, onComplete }) {
+    const [cursorIndex, setCursorIndex] = useState(0);
+    const [filterIndex, setFilterIndex] = useState(0);
+    const [sortIndex, setSortIndex] = useState(0);
+    const [groupIndex, setGroupIndex] = useState(0);
+    const [tabIndex, setTabIndex] = useState(0);
+    const [showHelp, setShowHelp] = useState(false);
+    const [searchMode, setSearchMode] = useState(false);
+    const [search, setSearch] = useState("");
+    const [selectedIndices, setSelectedIndices] = useState(new Set(items.flatMap((item, index) => item.update.selectedByDefault === false ? [] : [index])));
+    const activeFilter = FILTER_ORDER[filterIndex] ?? "all";
+    const activeSort = SORT_ORDER[sortIndex] ?? "risk";
+    const activeGroup = GROUP_ORDER[groupIndex] ?? "none";
+    const activeTab = DETAIL_TABS[tabIndex] ?? "overview";
+    const visibleRows = buildVisibleRows(items, {
+        filter: activeFilter,
+        sort: activeSort,
+        group: activeGroup,
+        search,
+    });
+    const itemRows = visibleRows.filter((row) => row.kind === "item" && typeof row.index === "number");
+    const boundedCursor = Math.min(cursorIndex, Math.max(0, itemRows.length - 1));
+    const focusedIndex = itemRows[boundedCursor]?.index ?? 0;
+    const focusedItem = items[focusedIndex];
+    useInput((input, key) => {
+        if (searchMode) {
+            if (key.escape) {
+                setSearchMode(false);
+                setSearch("");
+                setCursorIndex(0);
+                return;
+            }
+            if (key.return) {
+                setSearchMode(false);
+                setCursorIndex(0);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setSearch((value) => value.slice(0, -1));
+                setCursorIndex(0);
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setSearch((value) => value + input);
+                setCursorIndex(0);
+            }
+            return;
+        }
+        if (input === "/") {
+            setSearchMode(true);
+            return;
+        }
+        if (input === "?") {
+            setShowHelp((value) => !value);
+            return;
+        }
+        if (key.escape && showHelp) {
+            setShowHelp(false);
+            return;
+        }
+        if (key.leftArrow) {
+            setFilterIndex((prev) => Math.max(0, prev - 1));
+            setCursorIndex(0);
+        }
+        if (key.rightArrow) {
+            setFilterIndex((prev) => Math.min(FILTER_ORDER.length - 1, prev + 1));
+            setCursorIndex(0);
+        }
+        if (key.upArrow) {
+            setCursorIndex((prev) => Math.max(0, prev - 1));
+        }
+        if (key.downArrow) {
+            setCursorIndex((prev) => Math.min(itemRows.length - 1, Math.max(0, prev + 1)));
+        }
+        if (input === "o") {
+            setSortIndex((prev) => (prev + 1) % SORT_ORDER.length);
+            setCursorIndex(0);
+        }
+        if (input === "g") {
+            setGroupIndex((prev) => (prev + 1) % GROUP_ORDER.length);
+            setCursorIndex(0);
+        }
+        if (key.tab) {
+            setTabIndex((prev) => (prev + 1) % DETAIL_TABS.length);
+        }
+        if (input === "a") {
+            setSelectedIndices((prev) => addVisible(prev, itemRows));
+        }
+        if (input === "n") {
+            setSelectedIndices((prev) => removeVisible(prev, itemRows));
+        }
+        if (input === "s") {
+            setSelectedIndices((prev) => selectSafe(prev, itemRows, items));
+        }
+        if (input === "b") {
+            setSelectedIndices((prev) => clearBlocked(prev, itemRows, items));
+        }
+        if (input === " ") {
+            setSelectedIndices((prev) => {
+                const next = new Set(prev);
+                if (next.has(focusedIndex))
+                    next.delete(focusedIndex);
+                else
+                    next.add(focusedIndex);
+                return next;
+            });
+        }
+        if (input === "q" || key.escape) {
+            onComplete(items.filter((_, index) => selectedIndices.has(index)));
+            return;
+        }
+        if (key.return) {
+            onComplete(items.filter((_, index) => selectedIndices.has(index)));
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Rainy Review Queue" }), _jsx(Text, { color: "gray", children: "Detect with check, summarize with doctor, decide here in review, then apply with upgrade." }), _jsx(Text, { color: "gray", children: "Filters: \u2190/\u2192  Sort: o  Group: g  Tabs: Tab  Search: /  Help: ?  Space: toggle  Enter: confirm" }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsxs(Box, { width: 24, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Filter Rail" }), FILTER_ORDER.map((filter, index) => (_jsxs(Text, { color: index === filterIndex ? "cyan" : "gray", children: [index === filterIndex ? ">" : " ", " ", filter] }, filter))), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Search" }), _jsx(Text, { color: searchMode ? "cyan" : "gray", children: searchMode ? `/${search}` : search ? `/${search}` : "inactive" })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Modes" }), _jsxs(Text, { color: "gray", children: ["sort: ", activeSort] }), _jsxs(Text, { color: "gray", children: ["group: ", activeGroup] }), _jsxs(Text, { color: "gray", children: ["tab: ", activeTab] })] })] }), _jsxs(Box, { marginLeft: 1, width: 82, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Review Queue" }), itemRows.length === 0 ? (_jsx(Text, { color: "gray", children: "No review candidates match this view." })) : (visibleRows.map((row, visibleIndex) => {
+                                if (row.kind === "group") {
+                                    return (_jsx(Text, { bold: true, color: "gray", children: row.label }, `group:${row.label}`));
+                                }
+                                const index = row.index ?? 0;
+                                const item = items[index];
+                                const update = item.update;
+                                const decision = update.decisionState ?? deriveDecision(item);
+                                const itemPosition = itemRows.findIndex((candidate) => candidate.index === index);
+                                const isFocused = itemPosition === boundedCursor;
+                                const isSelected = selectedIndices.has(index);
+                                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: isFocused ? "cyan" : "gray", children: [isFocused ? ">" : " ", " ", isSelected ? "[x]" : "[ ]", " "] }), _jsx(Box, { width: 22, children: _jsx(Text, { bold: isFocused, children: update.name }) }), _jsx(Box, { width: 14, children: _jsx(Text, { color: diffColor(update.diffType), children: update.diffType }) }), _jsx(Box, { width: 14, children: _jsx(Text, { color: riskColor(update.riskLevel), children: update.riskLevel ?? "low" }) }), _jsx(Box, { width: 14, children: _jsx(Text, { color: decisionColor(decision), children: decision }) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: decisionColor(decision), children: update.riskScore ?? "--" }) }), _jsx(Text, { color: "gray", children: update.fromRange }), _jsx(Text, { color: "gray", children: " \u2192 " }), _jsx(Text, { color: "green", children: update.toVersionResolved })] }, `${update.packagePath}:${update.name}`));
+                            }))] }), _jsxs(Box, { marginLeft: 1, width: 54, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Decision Panel" }), _jsxs(Text, { color: "gray", children: ["tab: ", activeTab] }), focusedItem ? renderTab(focusedItem, activeTab) : _jsx(Text, { color: "gray", children: "No review candidate selected." })] })] }), _jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsxs(Text, { color: "gray", children: [selectedIndices.size, " selected of ", items.length, ". view=", activeFilter, " sort=", activeSort, " group=", activeGroup] }) }), _jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(Text, { color: "gray", children: "A select visible  N clear visible  S select safe  B clear blocked  Q finish  Esc clears search/help" }) }), showHelp ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Help" }), _jsx(Text, { color: "gray", children: "Use review as the decision center. Search packages with / and inspect details with Tab." }), _jsx(Text, { color: "gray", children: "Blocked items default to deselected. Safe items can be bulk-selected with S." })] })) : null] }));
+}
+function renderTab(item, tab) {
+    const update = item.update;
+    if (tab === "risk") {
+        return (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["state: ", _jsx(Text, { color: decisionColor(update.decisionState ?? deriveDecision(item)), children: update.decisionState ?? deriveDecision(item) })] }), _jsxs(Text, { children: ["policy: ", _jsx(Text, { color: decisionColor(policyToDecision(update.policyAction)), children: update.policyAction ?? "allow" })] }), _jsxs(Text, { children: ["risk score: ", update.riskScore ?? 0] }), _jsxs(Text, { children: ["impact score: ", update.impactScore?.score ?? 0] }), _jsxs(Text, { children: ["recommended action: ", update.recommendedAction ?? "Safe to keep in the selected set."] }), update.riskReasons && update.riskReasons.length > 0 ? update.riskReasons.slice(0, 5).map((reason) => (_jsxs(Text, { color: "gray", children: ["- ", reason] }, reason))) : _jsx(Text, { color: "gray", children: "No elevated risk reasons." })] }));
+    }
+    if (tab === "security") {
+        return (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["advisories: ", item.advisories.length] }), item.advisories.length > 0 ? item.advisories.slice(0, 4).map((advisory) => (_jsxs(Text, { color: "gray", children: ["- ", advisory.severity, " ", advisory.cveId, ": ", advisory.title] }, `${advisory.packageName}:${advisory.cveId}`))) : _jsx(Text, { color: "gray", children: "No security advisories detected." })] }));
+    }
+    if (tab === "peer") {
+        return (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["peer status: ", update.peerConflictSeverity ?? "none"] }), item.peerConflicts.length > 0 ? item.peerConflicts.slice(0, 4).map((conflict) => (_jsxs(Text, { color: "gray", children: ["- ", conflict.requester, " requires ", conflict.peer, " ", conflict.requiredRange] }, `${conflict.requester}:${conflict.peer}`))) : _jsx(Text, { color: "gray", children: "No peer conflicts detected." })] }));
+    }
+    if (tab === "license") {
+        return (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["license status: ", update.licenseStatus ?? "allowed"] }), _jsxs(Text, { children: ["repository: ", update.repository ?? "unavailable"] }), _jsxs(Text, { children: ["homepage: ", update.homepage ?? "unavailable"] })] }));
+    }
+    if (tab === "health") {
+        return (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["health: ", update.healthStatus ?? "healthy"] }), _jsxs(Text, { children: ["maintainers: ", update.maintainerCount ?? "unknown"] }), _jsxs(Text, { children: ["publish age days: ", update.publishAgeDays ?? "unknown"] }), _jsxs(Text, { children: ["maintainer churn: ", update.maintainerChurn ?? "unknown"] })] }));
+    }
+    if (tab === "changelog") {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: update.releaseNotesSummary?.title ?? "Release notes unavailable" }), _jsx(Text, { color: "gray", children: update.releaseNotesSummary?.excerpt ?? "Run review with changelog support or inspect the repository manually." })] }));
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { children: update.name }), _jsxs(Text, { color: "gray", children: ["package: ", update.packagePath] }), _jsxs(Text, { children: ["state: ", _jsx(Text, { color: decisionColor(update.decisionState ?? deriveDecision(item)), children: update.decisionState ?? deriveDecision(item) })] }), _jsxs(Text, { children: ["diff: ", _jsx(Text, { color: diffColor(update.diffType), children: update.diffType })] }), _jsxs(Text, { children: ["risk: ", _jsx(Text, { color: riskColor(update.riskLevel), children: update.riskLevel ?? "low" })] }), _jsxs(Text, { children: ["policy: ", update.policyAction ?? "allow"] }), _jsxs(Text, { children: ["workspace: ", update.workspaceGroup ?? "root"] }), _jsxs(Text, { children: ["group: ", update.groupKey ?? "none"] }), _jsxs(Text, { children: ["action: ", update.recommendedAction ?? "Safe to keep in the selected set."] })] }));
+}
+function buildVisibleRows(items, config) {
+    const filtered = items
+        .map((item, index) => ({ item, index }))
+        .filter(({ item }) => matchesFilter(item, config.filter))
+        .filter(({ item }) => matchesSearch(item, config.search))
+        .sort((left, right) => compareItems(left.item, right.item, config.sort));
+    if (config.group === "none") {
+        return filtered.map(({ item, index }) => ({ kind: "item", label: item.update.name, index }));
+    }
+    const rows = [];
+    let currentGroup = "";
+    for (const entry of filtered) {
+        const nextGroup = groupLabel(entry.item, config.group);
+        if (nextGroup !== currentGroup) {
+            currentGroup = nextGroup;
+            rows.push({ kind: "group", label: nextGroup });
+        }
+        rows.push({ kind: "item", label: entry.item.update.name, index: entry.index });
+    }
+    return rows;
+}
+function matchesFilter(item, filter) {
+    if (filter === "security")
+        return item.advisories.length > 0;
+    if (filter === "risky")
+        return item.update.riskLevel === "critical" || item.update.riskLevel === "high";
+    if (filter === "major")
+        return item.update.diffType === "major";
+    if (filter === "peer-conflict")
+        return item.peerConflicts.length > 0;
+    if (filter === "license")
+        return item.update.licenseStatus === "denied";
+    if (filter === "unused")
+        return item.unusedIssues.length > 0;
+    if (filter === "blocked")
+        return (item.update.decisionState ?? deriveDecision(item)) === "blocked";
+    return true;
+}
+function matchesSearch(item, search) {
+    if (!search.trim())
+        return true;
+    const query = search.toLowerCase();
+    return (item.update.name.toLowerCase().includes(query) ||
+        item.update.packagePath.toLowerCase().includes(query));
+}
+function compareItems(left, right, sort) {
+    if (sort === "advisories") {
+        const byAdvisories = (right.advisories.length ?? 0) - (left.advisories.length ?? 0);
+        if (byAdvisories !== 0)
+            return byAdvisories;
+    }
+    if (sort === "diff") {
+        const byDiff = diffWeight(right.update.diffType) - diffWeight(left.update.diffType);
+        if (byDiff !== 0)
+            return byDiff;
+    }
+    if (sort === "workspace") {
+        const byWorkspace = (left.update.workspaceGroup ?? left.update.packagePath).localeCompare(right.update.workspaceGroup ?? right.update.packagePath);
+        if (byWorkspace !== 0)
+            return byWorkspace;
+    }
+    if (sort === "name") {
+        const byName = left.update.name.localeCompare(right.update.name);
+        if (byName !== 0)
+            return byName;
+    }
+    const byRisk = (right.update.riskScore ?? 0) - (left.update.riskScore ?? 0);
+    if (byRisk !== 0)
+        return byRisk;
+    return left.update.name.localeCompare(right.update.name);
+}
+function groupLabel(item, group) {
+    if (group === "workspace")
+        return item.update.workspaceGroup ?? "root";
+    if (group === "scope") {
+        if (item.update.name.startsWith("@")) {
+            return item.update.name.split("/")[0] ?? "unscoped";
+        }
+        return "unscoped";
+    }
+    if (group === "risk")
+        return item.update.riskLevel ?? "low";
+    if (group === "decision")
+        return item.update.decisionState ?? deriveDecision(item);
+    return "all";
+}
+function addVisible(selected, rows) {
+    const next = new Set(selected);
+    for (const row of rows)
+        next.add(row.index);
+    return next;
+}
+function removeVisible(selected, rows) {
+    const next = new Set(selected);
+    for (const row of rows)
+        next.delete(row.index);
+    return next;
+}
+function selectSafe(selected, rows, items) {
+    const next = new Set(selected);
+    for (const row of rows) {
+        if ((items[row.index]?.update.decisionState ?? deriveDecision(items[row.index])) === "safe") {
+            next.add(row.index);
+        }
+    }
+    return next;
+}
+function clearBlocked(selected, rows, items) {
+    const next = new Set(selected);
+    for (const row of rows) {
+        if ((items[row.index]?.update.decisionState ?? deriveDecision(items[row.index])) === "blocked") {
+            next.delete(row.index);
+        }
+    }
+    return next;
+}
+function deriveDecision(item) {
+    if (item.update.peerConflictSeverity === "error" || item.update.licenseStatus === "denied") {
+        return "blocked";
+    }
+    if ((item.update.advisoryCount ?? 0) > 0 || item.update.riskLevel === "critical") {
+        return "actionable";
+    }
+    if (item.update.riskLevel === "high" || item.update.diffType === "major") {
+        return "review";
+    }
+    return "safe";
+}
+function policyToDecision(value) {
+    if (value === "block")
+        return "blocked";
+    if (value === "review")
+        return "review";
+    return "safe";
 }
 function riskColor(level) {
     switch (level) {
@@ -34,17 +332,14 @@ function diffColor(level) {
             return "cyan";
     }
 }
-function decisionLabel(update) {
-    if (update.peerConflictSeverity === "error" || update.licenseStatus === "denied") {
-        return "blocked";
-    }
-    if (update.advisoryCount && update.advisoryCount > 0) {
-        return "actionable";
-    }
-    if (update.riskLevel === "critical" || update.riskLevel === "high") {
-        return "review";
-    }
-    return "safe";
+function diffWeight(level) {
+    if (level === "major")
+        return 4;
+    if (level === "minor")
+        return 3;
+    if (level === "patch")
+        return 2;
+    return 1;
 }
 function decisionColor(label) {
     switch (label) {
@@ -58,73 +353,9 @@ function decisionColor(label) {
             return "green";
     }
 }
-function TuiApp({ updates, onComplete }) {
-    const [cursorIndex, setCursorIndex] = useState(0);
-    const [filterIndex, setFilterIndex] = useState(0);
-    const [selectedIndices, setSelectedIndices] = useState(new Set(updates.map((_, index) => index)));
-    const activeFilter = FILTER_ORDER[filterIndex] ?? "all";
-    const filteredIndices = updates
-        .map((update, index) => ({ update, index }))
-        .filter(({ update }) => {
-        if (activeFilter === "security")
-            return (update.advisoryCount ?? 0) > 0;
-        if (activeFilter === "risky") {
-            return update.riskLevel === "critical" || update.riskLevel === "high";
-        }
-        if (activeFilter === "major")
-            return update.diffType === "major";
-        return true;
-    })
-        .map(({ index }) => index);
-    const boundedCursor = Math.min(cursorIndex, Math.max(0, filteredIndices.length - 1));
-    const focusedIndex = filteredIndices[boundedCursor] ?? 0;
-    const focusedUpdate = updates[focusedIndex];
-    useInput((input, key) => {
-        if (key.leftArrow) {
-            setFilterIndex((prev) => Math.max(0, prev - 1));
-            setCursorIndex(0);
-        }
-        if (key.rightArrow) {
-            setFilterIndex((prev) => Math.min(FILTER_ORDER.length - 1, prev + 1));
-            setCursorIndex(0);
-        }
-        if (key.upArrow) {
-            setCursorIndex((prev) => Math.max(0, prev - 1));
-        }
-        if (key.downArrow) {
-            setCursorIndex((prev) => Math.min(filteredIndices.length - 1, Math.max(0, prev + 1)));
-        }
-        if (input === "a") {
-            setSelectedIndices(new Set(filteredIndices));
-        }
-        if (input === "n") {
-            setSelectedIndices(new Set());
-        }
-        if (input === " ") {
-            setSelectedIndices((prev) => {
-                const next = new Set(prev);
-                if (next.has(focusedIndex))
-                    next.delete(focusedIndex);
-                else
-                    next.add(focusedIndex);
-                return next;
-            });
-        }
-        if (key.return) {
-            onComplete(updates.filter((_, index) => selectedIndices.has(index)));
-        }
-    });
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Rainy Review Queue" }), _jsx(Text, { color: "gray", children: "Detect with check, summarize with doctor, decide here in review, then apply with upgrade." }), _jsx(Text, { color: "gray", children: "Left/Right filter  Up/Down move  Space toggle  A select visible  N clear  Enter confirm" }), _jsx(Box, { marginTop: 1, children: FILTER_ORDER.map((filter, index) => (_jsx(Box, { marginRight: 2, children: _jsxs(Text, { color: index === filterIndex ? "cyan" : "gray", children: ["[", filter, "]"] }) }, filter))) }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsxs(Box, { width: 72, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Review Queue" }), filteredIndices.length === 0 ? (_jsx(Text, { color: "gray", children: "No review candidates match this filter." })) : (filteredIndices.map((index, visibleIndex) => {
-                                const update = updates[index];
-                                const isFocused = visibleIndex === boundedCursor;
-                                const isSelected = selectedIndices.has(index);
-                                const decision = decisionLabel(update);
-                                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: isFocused ? "cyan" : "gray", children: [isFocused ? ">" : " ", " ", isSelected ? "[x]" : "[ ]", " "] }), _jsx(Box, { width: 22, children: _jsx(Text, { bold: isFocused, children: update.name }) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: diffColor(update.diffType), children: update.diffType }) }), _jsx(Box, { width: 18, children: _jsx(Text, { color: riskColor(update.riskLevel), children: update.riskLevel ?? update.impactScore?.rank ?? "low" }) }), _jsx(Box, { width: 12, children: _jsx(Text, { color: decisionColor(decision), children: decision }) }), _jsx(Box, { width: 10, children: _jsx(Text, { color: decisionColor(decision), children: typeof update.riskScore === "number" ? update.riskScore : "--" }) }), _jsx(VersionDiff, { from: update.fromRange, to: update.toVersionResolved })] }, `${update.packagePath}:${update.name}`));
-                            }))] }), _jsxs(Box, { marginLeft: 1, width: 46, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Decision Panel" }), focusedUpdate ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: focusedUpdate.name }), _jsxs(Text, { color: "gray", children: ["package: ", focusedUpdate.packagePath] }), _jsxs(Text, { children: ["state:", " ", _jsx(Text, { color: decisionColor(decisionLabel(focusedUpdate)), children: decisionLabel(focusedUpdate) })] }), _jsxs(Text, { children: ["diff: ", _jsx(Text, { color: diffColor(focusedUpdate.diffType), children: focusedUpdate.diffType })] }), _jsxs(Text, { children: ["risk: ", _jsx(Text, { color: riskColor(focusedUpdate.riskLevel), children: focusedUpdate.riskLevel ?? focusedUpdate.impactScore?.rank ?? "low" })] }), _jsxs(Text, { children: ["risk score: ", focusedUpdate.riskScore ?? 0] }), _jsxs(Text, { children: ["impact score: ", focusedUpdate.impactScore?.score ?? 0] }), _jsxs(Text, { children: ["advisories: ", focusedUpdate.advisoryCount ?? 0] }), _jsxs(Text, { children: ["peer: ", focusedUpdate.peerConflictSeverity ?? "none"] }), _jsxs(Text, { children: ["license: ", focusedUpdate.licenseStatus ?? "allowed"] }), _jsxs(Text, { children: ["health: ", focusedUpdate.healthStatus ?? "healthy"] }), _jsxs(Text, { children: ["action:", " ", _jsx(Text, { color: decisionColor(decisionLabel(focusedUpdate)), children: focusedUpdate.recommendedAction ?? "Safe to keep in the review queue." })] }), focusedUpdate.homepage ? (_jsxs(Text, { color: "blue", children: ["homepage: ", focusedUpdate.homepage] })) : (_jsx(Text, { color: "gray", children: "homepage: unavailable" })), focusedUpdate.riskReasons && focusedUpdate.riskReasons.length > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Reasons" }), focusedUpdate.riskReasons.slice(0, 4).map((reason) => (_jsxs(Text, { color: "gray", children: ["- ", reason] }, reason)))] })) : (_jsx(Text, { color: "gray", children: "No elevated risk reasons." }))] })) : (_jsx(Text, { color: "gray", children: "No review candidate selected." }))] })] }), _jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsxs(Text, { color: "gray", children: [selectedIndices.size, " selected for apply of ", updates.length, ". Filter: ", activeFilter, ". Enter confirms the review decision set."] }) })] }));
-}
-export async function runTui(updates) {
+export async function runTui(items) {
     return new Promise((resolve) => {
-        const { unmount } = render(_jsx(TuiApp, { updates: updates, onComplete: (selected) => {
+        const { unmount } = render(_jsx(TuiApp, { items: items, onComplete: (selected) => {
                 unmount();
                 resolve(selected);
             } }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainy-updates/cli",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "The fastest DevOps-first dependency CLI. Checks, audits, upgrades, bisects, and automates npm/pnpm dependencies in CI.",
   "type": "module",
   "private": false,