@rainy-updates/cli 0.5.4 → 0.5.7

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

@@ -0,0 +1,6 @@
+import type { DashboardOptions, CheckResult } from "../../types/index.js";
+export interface DashboardTUIProps {
+    options: DashboardOptions;
+    initialResult: CheckResult;
+}
+export declare function DashboardTUI({ options, initialResult }: DashboardTUIProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/dashboard/DashboardTUI.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, useInput, useApp } from "ink";
+import { initStore, dashboardActions } from "./store.js";
+import { Header } from "./components/Header.js";
+import { Sidebar } from "./components/Sidebar.js";
+import { DetailPanel } from "./components/DetailPanel.js";
+import { Footer } from "./components/Footer.js";
+export function DashboardTUI({ options, initialResult }) {
+    const { exit } = useApp();
+    // Initialize the singleton store synchronously before rendering children
+    // so that components can access it on the first render pass natively.
+    initStore(options, initialResult);
+    // Handle global keyboard input (doesn't trigger React re-renders unless store state affects this component)
+    // Our static layout theoretically will not re-render off this hook alone.
+    useInput((input, key) => {
+        if (key.upArrow) {
+            dashboardActions.moveCursorUp();
+        }
+        if (key.downArrow) {
+            dashboardActions.moveCursorDown();
+        }
+        if (key.return) {
+            dashboardActions.setShouldApply(true);
+            exit();
+        }
+        if (input === "r") {
+            void dashboardActions.runResolveAction();
+        }
+        if (input === "a") {
+            void dashboardActions.runAuditAction();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", minHeight: 25, children: [_jsx(Header, {}), _jsxs(Box, { flexDirection: "row", width: "100%", children: [_jsx(Sidebar, {}), _jsx(DetailPanel, {})] }), _jsx(Footer, {})] }));
+}

package/dist/ui/dashboard/components/DetailPanel.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+declare function DetailPanelComponent(): import("react/jsx-runtime").JSX.Element;
+export declare const DetailPanel: React.MemoExoticComponent<typeof DetailPanelComponent>;
+export {};

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

@@ -0,0 +1,30 @@
+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";
+function getRiskColor(risk) {
+    switch (risk) {
+        case "critical":
+            return "red";
+        case "high":
+            return "red";
+        case "medium":
+            return "yellow";
+        case "low":
+            return "blue";
+        default:
+            return "gray";
+    }
+}
+function DetailPanelComponent() {
+    const selectedIndex = useDashboardStore((s) => s.selectedIndex);
+    const updates = useDashboardStore((s) => s.updates);
+    // Fallback if list is empty
+    const update = updates[selectedIndex];
+    if (!update) {
+        return (_jsx(Box, { width: "50%", height: 22, padding: 1, borderStyle: "single", borderColor: "gray", children: _jsx(Text, { dimColor: true, children: "No package selected." }) }));
+    }
+    const { name, publishedAt, publishAgeDays, riskLevel, homepage, advisoryCount, peerConflictSeverity, } = update;
+    return (_jsxs(Box, { width: "50%", height: 22, flexDirection: "column", paddingX: 2, borderStyle: "single", borderColor: "gray", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: name }) }), _jsxs(Box, { marginBottom: 2, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Risk: " }), _jsx(Text, { color: getRiskColor(riskLevel), children: riskLevel || "unknown" })] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Advisories: " }), _jsx(Text, { color: advisoryCount ? "red" : "green", children: advisoryCount || 0 })] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Peer Conflicts: " }), _jsx(Text, { color: peerConflictSeverity ? "red" : "green", children: peerConflictSeverity || "none" })] })] }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(Text, { color: "gray", children: homepage || "No homepage provided" }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Published ", publishAgeDays, " days ago", " ", publishedAt ? `(${publishedAt})` : ""] }) })] }));
+}
+export const DetailPanel = React.memo(DetailPanelComponent);

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

@@ -0,0 +1,4 @@
+import React from "react";
+declare function FooterComponent(): import("react/jsx-runtime").JSX.Element;
+export declare const Footer: React.MemoExoticComponent<typeof FooterComponent>;
+export {};

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

@@ -0,0 +1,9 @@
+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";
+function FooterComponent() {
+    const modal = useDashboardStore((s) => s.modal);
+    return (_jsxs(Box, { width: "100%", paddingX: 1, flexDirection: "row", justifyContent: "space-between", children: [_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: [_jsx(Text, { bold: true, color: "white", children: "\u2191\u2193" }), " ", "Navigate |", _jsxs(Text, { bold: true, color: "white", children: [" ", "Enter"] }), " ", "Apply |", _jsxs(Text, { bold: true, color: "white", children: [" ", "r"] }), "esolve |", _jsxs(Text, { bold: true, color: "white", children: [" ", "a"] }), "udit |", _jsxs(Text, { bold: true, color: "white", children: [" ", "i"] }), "gnore"] }) }), _jsx(Box, { children: _jsx(Text, { color: "yellow", children: modal !== "none" ? `Status: ${modal}...` : "Status: Idle" }) })] }));
+}
+export const Footer = React.memo(FooterComponent);

package/dist/ui/dashboard/components/Header.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+declare function HeaderComponent(): import("react/jsx-runtime").JSX.Element;
+export declare const Header: React.MemoExoticComponent<typeof HeaderComponent>;
+export {};

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

@@ -0,0 +1,12 @@
+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";
+function HeaderComponent() {
+    const scanned = useDashboardStore((s) => s.summary.scannedPackages);
+    const totalUpdates = useDashboardStore((s) => s.updates.length);
+    const view = useDashboardStore((s) => s.view);
+    return (_jsxs(Box, { width: "100%", paddingX: 1, borderStyle: "single", borderColor: "blue", flexDirection: "row", justifyContent: "space-between", children: [_jsx(Box, { children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83C\uDF27\uFE0F Rainy Updates Dashboard" }) }), _jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: view === "dependencies" ? "green" : "gray", children: "[Dependencies]" }), " ", _jsx(Text, { color: view === "security" ? "green" : "gray", children: "[Security]" }), " ", _jsx(Text, { color: view === "health" ? "green" : "gray", children: "[Health]" })] }) }), _jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["Packages: ", scanned, " | Found: ", totalUpdates] }) })] }));
+}
+// Memoize to ensure Header only renders when deeply affected (which is rare)
+export const Header = React.memo(HeaderComponent);

package/dist/ui/dashboard/components/Sidebar.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+declare function SidebarComponent(): import("react/jsx-runtime").JSX.Element;
+export declare const Sidebar: React.MemoExoticComponent<typeof SidebarComponent>;
+export {};

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[]>;