ripencli 0.1.0

package/dist/cli.js

@@ -0,0 +1,2089 @@
+#!/usr/bin/env node
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, render, useApp, useInput, useStdout } from "ink";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { execa } from "execa";
+import { homedir } from "os";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { exec } from "child_process";
+import { ScrollView } from "ink-scroll-view";
+//#region src/detector.ts
+function detectPackageManager(cwd) {
+	if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(cwd, "pnpm-workspace.yaml"))) return "pnpm";
+	if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+	if (existsSync(join(cwd, "package-lock.json"))) return "npm";
+	return "npm";
+}
+function hasPackageJson(cwd) {
+	return existsSync(join(cwd, "package.json"));
+}
+function getProjectInfo(cwd) {
+	const manager = detectPackageManager(cwd);
+	let name = cwd.split("/").pop() ?? "project";
+	try {
+		const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+		if (pkg.name) name = pkg.name;
+	} catch {}
+	return {
+		manager,
+		cwd,
+		name
+	};
+}
+//#endregion
+//#region src/fetcher.ts
+async function getOutdatedPackages(manager, cwd, global = false, onLine) {
+	const args = global ? [
+		"outdated",
+		"--global",
+		"--json"
+	] : ["outdated", "--json"];
+	let stdout = "";
+	let stderr = "";
+	let exitCode = 0;
+	try {
+		const proc = execa(manager, args, {
+			cwd,
+			reject: false
+		});
+		if (onLine) {
+			const forwardWarnings = (chunk) => {
+				const lines = chunk.toString().split("\n");
+				for (const line of lines) {
+					const trimmed = line.trim();
+					if (trimmed && /^\s*(WARN|ERR!|npm warn|npm error)/i.test(trimmed)) onLine(trimmed);
+				}
+			};
+			proc.stderr?.on("data", forwardWarnings);
+			proc.stdout?.on("data", forwardWarnings);
+		}
+		const result = await proc;
+		stdout = result.stdout;
+		stderr = result.stderr;
+		exitCode = result.exitCode;
+	} catch (err) {
+		return {
+			ok: false,
+			error: `Could not run ${manager}: ${err.message ?? err}`
+		};
+	}
+	if (!(exitCode === 0 || exitCode === 1)) return {
+		ok: false,
+		error: stderr.trim() || `${manager} outdated exited with code ${exitCode}`
+	};
+	const raw = stdout.trim();
+	if (!raw) return {
+		ok: true,
+		packages: []
+	};
+	if (manager === "yarn") try {
+		return {
+			ok: true,
+			packages: parseYarnOutdated(raw, global)
+		};
+	} catch {
+		return {
+			ok: false,
+			error: "Failed to parse yarn outdated output. Try again."
+		};
+	}
+	const jsonStr = extractJson(raw);
+	if (!jsonStr) return {
+		ok: false,
+		error: stderr.trim() || raw.slice(0, 120)
+	};
+	try {
+		const data = JSON.parse(jsonStr);
+		return {
+			ok: true,
+			packages: manager === "pnpm" ? parsePnpmOutdated(data, global) : parseNpmOutdated(data, global)
+		};
+	} catch {
+		return {
+			ok: false,
+			error: "Failed to parse outdated output. Try again."
+		};
+	}
+}
+/**
+* Extract the first top-level JSON object from a string that may contain
+* non-JSON lines (e.g. pnpm WARN messages) before or after the JSON.
+*/
+function extractJson(raw) {
+	const start = raw.indexOf("{");
+	if (start === -1) return null;
+	let depth = 0;
+	for (let i = start; i < raw.length; i++) {
+		if (raw[i] === "{") depth++;
+		else if (raw[i] === "}") depth--;
+		if (depth === 0) return raw.slice(start, i + 1);
+	}
+	return null;
+}
+function parsePnpmOutdated(data, global) {
+	if (Array.isArray(data) || typeof data !== "object") return [];
+	return Object.entries(data).map(([name, info]) => ({
+		name,
+		current: info.current ?? "N/A",
+		wanted: info.wanted ?? info.latest,
+		latest: info.latest,
+		dependent: "",
+		type: global ? "global" : info.dependencyType === "devDependencies" ? "devDependencies" : "dependencies",
+		selected: false,
+		targetVersion: info.latest
+	}));
+}
+function parseNpmOutdated(data, global) {
+	return Object.entries(data).map(([name, info]) => ({
+		name,
+		current: info.current ?? "N/A",
+		wanted: info.wanted ?? info.latest,
+		latest: info.latest,
+		dependent: info.dependent ?? "",
+		type: global ? "global" : info.type === "devDependencies" ? "devDependencies" : "dependencies",
+		selected: false,
+		targetVersion: info.latest
+	}));
+}
+async function isManagerAvailable(manager) {
+	try {
+		await execa(manager, ["--version"], { reject: false });
+		return true;
+	} catch {
+		return false;
+	}
+}
+const ALL_MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn"
+];
+/**
+* Check all available package managers for global outdated packages in parallel.
+* Each returned package is tagged with its owning manager.
+*/
+async function getAllGlobalOutdated(cwd, onLine) {
+	const managers = (await Promise.all(ALL_MANAGERS.map(async (m) => ({
+		manager: m,
+		ok: await isManagerAvailable(m)
+	})))).filter((a) => a.ok).map((a) => a.manager);
+	const results = await Promise.all(managers.map((m) => getOutdatedPackages(m, cwd, true, onLine)));
+	const allPackages = [];
+	for (let i = 0; i < managers.length; i++) {
+		const result = results[i];
+		if (result.ok) for (const pkg of result.packages) {
+			pkg.manager = managers[i];
+			allPackages.push(pkg);
+		}
+	}
+	return {
+		ok: true,
+		packages: allPackages
+	};
+}
+/**
+* Yarn classic outputs ndjson — one JSON object per line.
+* The table data is in a line like: {"type":"table","data":{"head":...,"body":[[name, current, wanted, latest, workspace, type],...]}}
+*/
+function parseYarnOutdated(raw, global) {
+	const lines = raw.split("\n");
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const obj = JSON.parse(trimmed);
+			if (obj.type === "table" && obj.data?.body) return obj.data.body.map((row) => ({
+				name: row[0],
+				current: row[1] ?? "N/A",
+				wanted: row[2] ?? row[3],
+				latest: row[3],
+				dependent: row[4] ?? "",
+				type: global ? "global" : row[5] === "devDependencies" ? "devDependencies" : "dependencies",
+				selected: false,
+				targetVersion: row[3]
+			}));
+		} catch {}
+	}
+	return [];
+}
+//#endregion
+//#region src/executor.ts
+async function updatePackages(manager, packages, cwd, global = false, onLine) {
+	const results = [];
+	const deps = packages.filter((p) => !global && p.type === "dependencies");
+	const devDeps = packages.filter((p) => !global && p.type === "devDependencies");
+	const globalPkgs = packages.filter((p) => global);
+	const batches = [];
+	if (deps.length > 0) batches.push({
+		mgr: manager,
+		pkgs: deps,
+		flags: []
+	});
+	if (devDeps.length > 0) batches.push({
+		mgr: manager,
+		pkgs: devDeps,
+		flags: ["-D"]
+	});
+	if (globalPkgs.length > 0) {
+		const byManager = /* @__PURE__ */ new Map();
+		for (const pkg of globalPkgs) {
+			const mgr = pkg.manager ?? manager;
+			if (!byManager.has(mgr)) byManager.set(mgr, []);
+			byManager.get(mgr).push(pkg);
+		}
+		for (const [mgr, pkgs] of byManager) {
+			const globalFlags = mgr === "yarn" ? [] : ["--global"];
+			batches.push({
+				mgr,
+				pkgs,
+				flags: globalFlags
+			});
+		}
+	}
+	for (const batch of batches) {
+		const pkgArgs = batch.pkgs.map((pkg) => `${pkg.name}@${pkg.targetVersion ?? pkg.latest}`);
+		const args = batch.mgr === "yarn" && global ? [
+			"global",
+			"add",
+			...pkgArgs
+		] : [
+			"add",
+			...batch.flags,
+			...pkgArgs
+		];
+		onLine?.(`$ ${batch.mgr} ${args.join(" ")}`);
+		try {
+			const proc = execa(batch.mgr, args, {
+				cwd,
+				reject: false
+			});
+			if (onLine) {
+				const forward = (chunk) => {
+					const lines = chunk.toString().split("\n");
+					for (const line of lines) {
+						const trimmed = line.trim();
+						if (trimmed) onLine(trimmed);
+					}
+				};
+				proc.stderr?.on("data", forward);
+				proc.stdout?.on("data", forward);
+			}
+			const result = await proc;
+			if (result.exitCode !== 0) {
+				const errMsg = result.stderr?.trim() || `exited with code ${result.exitCode}`;
+				for (const pkg of batch.pkgs) results.push({
+					name: pkg.name,
+					fromVersion: pkg.current,
+					version: pkg.targetVersion ?? pkg.latest,
+					success: false,
+					error: errMsg
+				});
+			} else for (const pkg of batch.pkgs) results.push({
+				name: pkg.name,
+				fromVersion: pkg.current,
+				version: pkg.targetVersion ?? pkg.latest,
+				success: true
+			});
+		} catch (err) {
+			for (const pkg of batch.pkgs) results.push({
+				name: pkg.name,
+				fromVersion: pkg.current,
+				version: pkg.targetVersion ?? pkg.latest,
+				success: false,
+				error: err.message ?? "Unknown error"
+			});
+		}
+	}
+	return results;
+}
+//#endregion
+//#region src/config.ts
+const DEFAULT_CONFIG = { groupByScope: true };
+const CONFIG_DIR = join(homedir(), ".config", "ripen");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+	try {
+		const raw = readFileSync(CONFIG_PATH, "utf-8");
+		const parsed = JSON.parse(raw);
+		return {
+			...DEFAULT_CONFIG,
+			...parsed
+		};
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}
+function saveConfig(config) {
+	try {
+		mkdirSync(CONFIG_DIR, { recursive: true });
+		writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+	} catch {}
+}
+//#endregion
+//#region src/registry.ts
+async function fetchVersions(packageName) {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`);
+		if (!res.ok) return [];
+		const data = await res.json();
+		const times = data.time ?? {};
+		const distTags = data["dist-tags"] ?? {};
+		const tagByVersion = {};
+		for (const [tag, ver] of Object.entries(distTags)) tagByVersion[ver] = tag;
+		return Object.keys(data.versions ?? {}).filter((v) => !v.includes("-") || tagByVersion[v]).map((v) => ({
+			version: v,
+			date: times[v] ? new Date(times[v]).toISOString().split("T")[0] : "",
+			tag: tagByVersion[v]
+		})).sort((a, b) => {
+			const pa = a.version.split(".").map(Number);
+			const pb = b.version.split(".").map(Number);
+			for (let i = 0; i < 3; i++) if ((pb[i] ?? 0) !== (pa[i] ?? 0)) return (pb[i] ?? 0) - (pa[i] ?? 0);
+			return 0;
+		});
+	} catch {
+		return [];
+	}
+}
+async function fetchChangelog(packageName, fromVersion, toVersion) {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`);
+		if (!res.ok) return [];
+		const data = await res.json();
+		const match = (typeof data.repository === "string" ? data.repository : data.repository?.url ?? "").match(/github\.com[/:]([^/]+\/[^/]+)/);
+		if (!match) return [];
+		const repo = match[1].replace(/\.git$/, "");
+		const ghRes = await fetch(`https://api.github.com/repos/${repo}/releases?per_page=30`, { headers: { Accept: "application/vnd.github+json" } });
+		if (!ghRes.ok) return [];
+		const releases = await ghRes.json();
+		const parseVer = (v) => v.replace(/^[^0-9]*/, "").split(".").map(Number);
+		const cmpVer = (a, b) => {
+			for (let i = 0; i < 3; i++) {
+				const diff = (a[i] ?? 0) - (b[i] ?? 0);
+				if (diff !== 0) return diff;
+			}
+			return 0;
+		};
+		const from = parseVer(fromVersion);
+		const to = parseVer(toVersion);
+		const filtered = releases.filter((r) => {
+			if (r.draft || r.prerelease) return false;
+			const ver = parseVer(r.tag_name);
+			return cmpVer(ver, from) > 0 && cmpVer(ver, to) <= 0;
+		}).map((r) => ({
+			version: r.tag_name,
+			body: r.body?.trim() ?? "No release notes.",
+			url: r.html_url
+		}));
+		if (filtered.length === 0 && releases.length > 0) {
+			const latest = releases[0];
+			return [{
+				version: latest.tag_name,
+				body: latest.body?.trim() ?? "No release notes.",
+				url: latest.html_url
+			}];
+		}
+		return filtered;
+	} catch {
+		return [];
+	}
+}
+async function fetchLatestVersion(packageName) {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`);
+		if (!res.ok) return null;
+		return (await res.json()).version ?? null;
+	} catch {
+		return null;
+	}
+}
+function isNewerVersion(current, latest) {
+	const a = current.split(".").map(Number);
+	const b = latest.split(".").map(Number);
+	for (let i = 0; i < 3; i++) {
+		if ((b[i] ?? 0) > (a[i] ?? 0)) return true;
+		if ((b[i] ?? 0) < (a[i] ?? 0)) return false;
+	}
+	return false;
+}
+async function fetchRepoUrl(packageName) {
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`);
+		if (!res.ok) return "";
+		const data = await res.json();
+		const match = (typeof data.repository === "string" ? data.repository : data.repository?.url ?? "").match(/github\.com[/:]([^/]+\/[^/]+)/);
+		if (!match) return "";
+		return `https://github.com/${match[1].replace(/\.git$/, "")}`;
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/ui/PackageList.tsx
+const TYPE_COLORS = {
+	dependencies: "cyan",
+	devDependencies: "magenta",
+	global: "yellow"
+};
+const GROUP_LABELS = {
+	dependencies: "Dependencies",
+	devDependencies: "Dev Dependencies",
+	global: "Global Packages"
+};
+const GROUP_ORDER = [
+	"dependencies",
+	"devDependencies",
+	"global"
+];
+const CHROME_LINES = 8;
+const GROUP_CHROME = 5;
+function getScope(name) {
+	return name.match(/^(@[^/]+)\//)?.[1] ?? null;
+}
+function buildDisplayRows(packages, groupByScope) {
+	const grouped = /* @__PURE__ */ new Map();
+	packages.forEach((pkg, i) => {
+		if (!grouped.has(pkg.type)) grouped.set(pkg.type, []);
+		grouped.get(pkg.type).push({
+			pkg,
+			index: i
+		});
+	});
+	const rows = [];
+	for (const type of GROUP_ORDER) {
+		const items = grouped.get(type);
+		if (!items || items.length === 0) continue;
+		const allPkgs = items.map((i) => i.pkg);
+		rows.push({
+			kind: "header",
+			groupType: type,
+			label: GROUP_LABELS[type] ?? type,
+			packages: allPkgs
+		});
+		if (groupByScope) {
+			const scopeMap = /* @__PURE__ */ new Map();
+			const unscoped = [];
+			for (const item of items) {
+				const scope = getScope(item.pkg.name);
+				if (scope) {
+					if (!scopeMap.has(scope)) scopeMap.set(scope, []);
+					scopeMap.get(scope).push(item);
+				} else unscoped.push(item);
+			}
+			const emittedScopes = /* @__PURE__ */ new Set();
+			for (const item of items) {
+				const scope = getScope(item.pkg.name);
+				if (scope && scopeMap.get(scope).length >= 2) {
+					if (!emittedScopes.has(scope)) {
+						emittedScopes.add(scope);
+						const scopeItems = scopeMap.get(scope);
+						const scopeKey = `${type}::${scope}`;
+						rows.push({
+							kind: "scope-header",
+							groupType: type,
+							scope,
+							packageIndices: scopeItems.map((si) => si.index),
+							packages: scopeItems.map((si) => si.pkg)
+						});
+						for (const si of scopeItems) rows.push({
+							kind: "package",
+							pkg: si.pkg,
+							packageIndex: si.index,
+							indented: true,
+							scopeKey
+						});
+					}
+				} else rows.push({
+					kind: "package",
+					pkg: item.pkg,
+					packageIndex: item.index,
+					indented: false,
+					scopeKey: null
+				});
+			}
+		} else for (const item of items) rows.push({
+			kind: "package",
+			pkg: item.pkg,
+			packageIndex: item.index,
+			indented: false,
+			scopeKey: null
+		});
+	}
+	return rows;
+}
+function filterCollapsed(rows, collapsed) {
+	return rows.filter((row) => {
+		if (row.kind === "package" && row.scopeKey && collapsed.has(row.scopeKey)) return false;
+		return true;
+	});
+}
+function buildGroups(visibleRows) {
+	const groups = [];
+	let current = null;
+	visibleRows.forEach((row, i) => {
+		if (row.kind === "header") {
+			current = {
+				type: row.groupType,
+				label: row.label,
+				allPackages: row.packages,
+				items: [],
+				headerVisibleIndex: i
+			};
+			groups.push(current);
+		} else if (current) current.items.push({
+			row,
+			visibleIndex: i
+		});
+	});
+	return groups;
+}
+function groupCheckbox(packages) {
+	const selectedCount = packages.filter((p) => p.selected).length;
+	if (selectedCount === 0) return {
+		symbol: "□",
+		color: "gray"
+	};
+	if (selectedCount === packages.length) return {
+		symbol: "■",
+		color: "greenBright"
+	};
+	return {
+		symbol: "◧",
+		color: "yellow"
+	};
+}
+function computeMaxPerGroup(terminalRows, groupCount) {
+	const available = terminalRows - CHROME_LINES - groupCount * (GROUP_CHROME + 1);
+	const perGroup = Math.floor(available / groupCount);
+	return Math.max(3, perGroup);
+}
+function PackageList({ packages, onToggle, onToggleGroup, onToggleMany, onSelectVersion, onViewChangelog, onConfirm, onOpenSettings, focusedIndex, onFocusChange, groupByScope, isActive = true }) {
+	const allRows = useMemo(() => buildDisplayRows(packages, groupByScope), [packages, groupByScope]);
+	const allScopeKeys = useMemo(() => {
+		const keys = /* @__PURE__ */ new Set();
+		for (const row of allRows) if (row.kind === "scope-header") keys.add(`${row.groupType}::${row.scope}`);
+		return keys;
+	}, [allRows]);
+	const [collapsedScopes, setCollapsedScopes] = useState(/* @__PURE__ */ new Set());
+	const [initialized, setInitialized] = useState(false);
+	useEffect(() => {
+		if (!initialized && allScopeKeys.size > 0) {
+			setCollapsedScopes(new Set(allScopeKeys));
+			setInitialized(true);
+		}
+	}, [allScopeKeys, initialized]);
+	const visibleRows = useMemo(() => filterCollapsed(allRows, collapsedScopes), [allRows, collapsedScopes]);
+	const groups = useMemo(() => buildGroups(visibleRows), [visibleRows]);
+	const { stdout } = useStdout();
+	const terminalRows = stdout?.rows ?? 24;
+	const maxVisible = useMemo(() => computeMaxPerGroup(terminalRows, groups.length), [terminalRows, groups.length]);
+	const [scrollOffsets, setScrollOffsets] = useState({});
+	useEffect(() => {
+		for (const group of groups) {
+			const localIndex = group.items.findIndex((item) => item.visibleIndex === focusedIndex);
+			if (localIndex === -1) continue;
+			setScrollOffsets((prev) => {
+				const offset = prev[group.type] ?? 0;
+				let next = offset;
+				if (localIndex < offset) next = localIndex;
+				else if (localIndex >= offset + maxVisible) next = localIndex - maxVisible + 1;
+				if (next === offset) return prev;
+				return {
+					...prev,
+					[group.type]: next
+				};
+			});
+		}
+	}, [
+		focusedIndex,
+		groups,
+		maxVisible
+	]);
+	useEffect(() => {
+		if (focusedIndex >= visibleRows.length) onFocusChange(Math.max(0, visibleRows.length - 1));
+	}, [
+		visibleRows.length,
+		focusedIndex,
+		onFocusChange
+	]);
+	const toggleCollapse = (scopeKey) => {
+		setCollapsedScopes((prev) => {
+			const next = new Set(prev);
+			if (next.has(scopeKey)) next.delete(scopeKey);
+			else next.add(scopeKey);
+			return next;
+		});
+	};
+	useInput((input, key) => {
+		if (key.upArrow) onFocusChange(Math.max(0, focusedIndex - 1));
+		if (key.downArrow) onFocusChange(Math.min(visibleRows.length - 1, focusedIndex + 1));
+		if (key.tab) {
+			const headerIndices = groups.map((g) => g.headerVisibleIndex);
+			onFocusChange(headerIndices[(headerIndices.findIndex((h, i) => {
+				const nextHeader = headerIndices[i + 1] ?? visibleRows.length;
+				return focusedIndex >= h && focusedIndex < nextHeader;
+			}) + 1) % headerIndices.length]);
+			return;
+		}
+		const focused = visibleRows[focusedIndex];
+		if (!focused) return;
+		if (focused.kind === "scope-header") {
+			const scopeKey = `${focused.groupType}::${focused.scope}`;
+			if (key.leftArrow && !collapsedScopes.has(scopeKey)) {
+				toggleCollapse(scopeKey);
+				return;
+			}
+			if (key.rightArrow && collapsedScopes.has(scopeKey)) {
+				toggleCollapse(scopeKey);
+				return;
+			}
+		}
+		if (input === " ") if (focused.kind === "header") onToggleGroup(focused.groupType);
+		else if (focused.kind === "scope-header") onToggleMany(focused.packageIndices);
+		else onToggle(focused.packageIndex);
+		if (input === "v" && focused.kind === "package") onSelectVersion(focused.packageIndex);
+		if (input === "c" && focused.kind === "package") onViewChangelog(focused.packageIndex);
+		if (input === "s") onOpenSettings?.();
+		if (key.return) onConfirm();
+	}, { isActive });
+	const selectedCount = packages.filter((p) => p.selected).length;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				marginBottom: 1,
+				flexDirection: "column",
+				children: [/* @__PURE__ */ jsxs(Text, {
+					bold: true,
+					color: "greenBright",
+					children: [
+						" ",
+						"ripen ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: "-- interactive dependency updater"
+						})
+					]
+				}), /* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsxs(Text, {
+						color: "gray",
+						children: [
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "↑↓"
+							}),
+							" navigate",
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "space"
+							}),
+							" select",
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "tab"
+							}),
+							" groups",
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "←→"
+							}),
+							" collapse",
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "v"
+							}),
+							" version",
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "c"
+							}),
+							" changelog",
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "s"
+							}),
+							" settings",
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "white",
+								children: "enter"
+							}),
+							" update"
+						]
+					})
+				})]
+			}),
+			groups.map((group) => {
+				const check = groupCheckbox(group.allPackages);
+				const headerFocused = focusedIndex === group.headerVisibleIndex;
+				const typeColor = TYPE_COLORS[group.type] ?? "white";
+				const offset = scrollOffsets[group.type] ?? 0;
+				const visibleItems = group.items.slice(offset, offset + maxVisible);
+				const totalItems = group.items.length;
+				const needsScroll = totalItems > maxVisible;
+				const focusedLocalIndex = group.items.findIndex((item) => item.visibleIndex === focusedIndex);
+				return /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					marginBottom: 1,
+					children: [/* @__PURE__ */ jsxs(Box, {
+						gap: 1,
+						children: [
+							/* @__PURE__ */ jsx(Text, {
+								color: "greenBright",
+								children: headerFocused ? "❯" : " "
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								color: check.color,
+								children: check.symbol
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								bold: headerFocused,
+								color: typeColor,
+								children: group.label
+							}),
+							/* @__PURE__ */ jsxs(Text, {
+								dimColor: true,
+								color: "gray",
+								children: [
+									"(",
+									group.allPackages.length,
+									")"
+								]
+							}),
+							needsScroll && focusedLocalIndex >= 0 && /* @__PURE__ */ jsxs(Text, {
+								dimColor: true,
+								color: "gray",
+								children: [
+									focusedLocalIndex + 1,
+									"/",
+									totalItems
+								]
+							})
+						]
+					}), /* @__PURE__ */ jsxs(Box, {
+						flexDirection: "column",
+						borderStyle: "round",
+						borderColor: headerFocused ? typeColor : "gray",
+						paddingX: 1,
+						children: [
+							/* @__PURE__ */ jsxs(Box, {
+								gap: 2,
+								marginBottom: 0,
+								children: [
+									/* @__PURE__ */ jsx(Text, {
+										dimColor: true,
+										color: "gray",
+										children: "  "
+									}),
+									/* @__PURE__ */ jsx(Box, {
+										width: 28,
+										children: /* @__PURE__ */ jsx(Text, {
+											dimColor: true,
+											color: "gray",
+											children: "package"
+										})
+									}),
+									/* @__PURE__ */ jsx(Box, {
+										width: 10,
+										children: /* @__PURE__ */ jsx(Text, {
+											dimColor: true,
+											color: "gray",
+											children: "current"
+										})
+									}),
+									/* @__PURE__ */ jsx(Box, {
+										width: 10,
+										children: /* @__PURE__ */ jsx(Text, {
+											dimColor: true,
+											color: "gray",
+											children: "target"
+										})
+									}),
+									/* @__PURE__ */ jsx(Box, {
+										width: 10,
+										children: /* @__PURE__ */ jsx(Text, {
+											dimColor: true,
+											color: "gray",
+											children: "latest"
+										})
+									})
+								]
+							}),
+							needsScroll && /* @__PURE__ */ jsx(Text, {
+								dimColor: true,
+								color: "gray",
+								children: offset > 0 ? `  ↑ ${offset} more above` : " "
+							}),
+							visibleItems.map((item) => {
+								const { row } = item;
+								const isFocused = item.visibleIndex === focusedIndex;
+								if (row.kind === "scope-header") {
+									const scopeKey = `${row.groupType}::${row.scope}`;
+									const isCollapsed = collapsedScopes.has(scopeKey);
+									const scopeCheck = groupCheckbox(row.packages);
+									return /* @__PURE__ */ jsxs(Box, {
+										gap: 2,
+										children: [
+											/* @__PURE__ */ jsx(Text, {
+												color: "greenBright",
+												children: isFocused ? "❯" : " "
+											}),
+											/* @__PURE__ */ jsx(Text, {
+												color: "gray",
+												children: isCollapsed ? "▶" : "▼"
+											}),
+											/* @__PURE__ */ jsx(Text, {
+												color: scopeCheck.color,
+												children: scopeCheck.symbol
+											}),
+											/* @__PURE__ */ jsxs(Text, {
+												bold: isFocused,
+												color: isFocused ? "whiteBright" : "white",
+												children: [
+													row.scope,
+													" (",
+													row.packages.length,
+													")"
+												]
+											})
+										]
+									}, scopeKey);
+								}
+								if (row.kind !== "package") return null;
+								const pkg = row.pkg;
+								const isMajorBump = parseInt(pkg.latest) > parseInt(pkg.current);
+								return /* @__PURE__ */ jsxs(Box, {
+									gap: 2,
+									children: [
+										/* @__PURE__ */ jsx(Text, {
+											color: "greenBright",
+											children: isFocused ? "❯" : " "
+										}),
+										row.indented && /* @__PURE__ */ jsx(Text, { children: "  " }),
+										/* @__PURE__ */ jsx(Text, {
+											color: pkg.selected ? "greenBright" : "gray",
+											children: pkg.selected ? "◉" : "○"
+										}),
+										/* @__PURE__ */ jsx(Box, {
+											width: row.indented ? 24 : 26,
+											children: /* @__PURE__ */ jsx(Text, {
+												bold: isFocused,
+												color: isFocused ? "whiteBright" : "white",
+												children: (() => {
+													const maxLen = row.indented ? 24 : 26;
+													return pkg.name.length > maxLen ? pkg.name.slice(0, maxLen - 2) + "…" : pkg.name;
+												})()
+											})
+										}),
+										/* @__PURE__ */ jsx(Box, {
+											width: 10,
+											children: /* @__PURE__ */ jsx(Text, {
+												color: "red",
+												dimColor: true,
+												children: pkg.current
+											})
+										}),
+										/* @__PURE__ */ jsx(Box, {
+											width: 10,
+											children: /* @__PURE__ */ jsx(Text, {
+												color: "greenBright",
+												children: pkg.targetVersion ?? pkg.latest
+											})
+										}),
+										/* @__PURE__ */ jsx(Box, {
+											width: 10,
+											children: /* @__PURE__ */ jsx(Text, {
+												color: "gray",
+												children: pkg.latest
+											})
+										}),
+										/* @__PURE__ */ jsx(Box, {
+											width: 9,
+											children: isMajorBump ? /* @__PURE__ */ jsx(Text, {
+												color: "yellow",
+												children: "⚠ major"
+											}) : /* @__PURE__ */ jsx(Text, { children: " " })
+										})
+									]
+								}, pkg.name);
+							}),
+							needsScroll && /* @__PURE__ */ jsx(Text, {
+								dimColor: true,
+								color: "gray",
+								children: offset + maxVisible < totalItems ? `  ↓ ${totalItems - offset - maxVisible} more below` : " "
+							})
+						]
+					})]
+				}, group.type);
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				flexDirection: "column",
+				children: /* @__PURE__ */ jsxs(Box, {
+					gap: 2,
+					children: [/* @__PURE__ */ jsxs(Text, { children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "greenBright",
+							bold: true,
+							children: selectedCount
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: " selected"
+						}),
+						"  ",
+						/* @__PURE__ */ jsxs(Text, {
+							color: "gray",
+							children: [packages.length, " outdated"]
+						})
+					] }), selectedCount > 0 && /* @__PURE__ */ jsx(Text, {
+						color: "greenBright",
+						children: " Press enter to update →"
+					})]
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/ui/VersionPicker.tsx
+function VersionPicker({ pkg, onSelect, onCancel }) {
+	const [versions, setVersions] = useState([]);
+	const [loading, setLoading] = useState(true);
+	const [cursor, setCursor] = useState(0);
+	const [scroll, setScroll] = useState(0);
+	const PAGE = 12;
+	useEffect(() => {
+		fetchVersions(pkg.name).then((v) => {
+			setVersions(v);
+			const idx = v.findIndex((x) => x.version === (pkg.targetVersion ?? pkg.latest));
+			if (idx >= 0) {
+				setCursor(idx);
+				setScroll(Math.max(0, idx - Math.floor(PAGE / 2)));
+			}
+			setLoading(false);
+		});
+	}, [pkg.name]);
+	useInput((input, key) => {
+		if (key.escape || input === "q") {
+			onCancel();
+			return;
+		}
+		if (key.upArrow) {
+			const next = Math.max(0, cursor - 1);
+			setCursor(next);
+			if (next < scroll) setScroll(next);
+		}
+		if (key.downArrow) {
+			const next = Math.min(versions.length - 1, cursor + 1);
+			setCursor(next);
+			if (next >= scroll + PAGE) setScroll(next - PAGE + 1);
+		}
+		if (key.return && versions[cursor]) onSelect(versions[cursor].version);
+	});
+	const visible = versions.slice(scroll, scroll + PAGE);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				marginBottom: 1,
+				flexDirection: "column",
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						bold: true,
+						color: "cyanBright",
+						children: [
+							" ",
+							"Pick version — ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "whiteBright",
+								children: pkg.name
+							})
+						]
+					}),
+					/* @__PURE__ */ jsxs(Text, {
+						color: "gray",
+						children: [
+							" ",
+							"current: ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "red",
+								children: pkg.current
+							})
+						]
+					}),
+					/* @__PURE__ */ jsx(Box, {
+						marginTop: 1,
+						children: /* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: "────────────────────────────────"
+						})
+					})
+				]
+			}),
+			loading ? /* @__PURE__ */ jsx(Text, {
+				color: "gray",
+				children: " fetching versions…"
+			}) : versions.length === 0 ? /* @__PURE__ */ jsx(Text, {
+				color: "red",
+				children: " Could not fetch versions."
+			}) : /* @__PURE__ */ jsxs(Fragment, { children: [visible.map((v, i) => {
+				const isFocused = scroll + i === cursor;
+				const isCurrent = v.version === pkg.current;
+				const isLatest = v.tag === "latest";
+				return /* @__PURE__ */ jsxs(Box, {
+					gap: 2,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "cyanBright",
+							children: isFocused ? "❯" : " "
+						}),
+						/* @__PURE__ */ jsx(Box, {
+							width: 16,
+							children: /* @__PURE__ */ jsx(Text, {
+								bold: isFocused,
+								color: isFocused ? "whiteBright" : isCurrent ? "red" : "white",
+								children: v.version
+							})
+						}),
+						/* @__PURE__ */ jsx(Box, {
+							width: 10,
+							children: /* @__PURE__ */ jsx(Text, {
+								color: "gray",
+								dimColor: true,
+								children: v.date
+							})
+						}),
+						isLatest && /* @__PURE__ */ jsx(Text, {
+							color: "greenBright",
+							children: "latest"
+						}),
+						isCurrent && /* @__PURE__ */ jsx(Text, {
+							color: "red",
+							children: "current"
+						})
+					]
+				}, v.version);
+			}), versions.length > PAGE && /* @__PURE__ */ jsxs(Text, {
+				color: "gray",
+				dimColor: true,
+				children: [
+					"  ",
+					"showing ",
+					scroll + 1,
+					"–",
+					Math.min(scroll + PAGE, versions.length),
+					" of ",
+					versions.length
+				]
+			})] }),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: "────────────────────────────────"
+				})
+			}),
+			/* @__PURE__ */ jsxs(Text, {
+				color: "gray",
+				children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: "white",
+						children: "↑↓"
+					}),
+					" navigate",
+					"  ",
+					/* @__PURE__ */ jsx(Text, {
+						color: "white",
+						children: "enter"
+					}),
+					" select",
+					"  ",
+					/* @__PURE__ */ jsx(Text, {
+						color: "white",
+						children: "esc"
+					}),
+					" cancel"
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/ui/MarkdownLine.tsx
+function parseInline(raw) {
+	const segments = [];
+	const re = /(\*\*(.+?)\*\*|`([^`]+)`|\[([^\]]+)\]\(([^)]+)\))/g;
+	let last = 0;
+	let m;
+	while ((m = re.exec(raw)) !== null) {
+		if (m.index > last) segments.push({ text: raw.slice(last, m.index) });
+		if (m[2] !== void 0) segments.push({
+			text: m[2],
+			bold: true
+		});
+		else if (m[3] !== void 0) segments.push({
+			text: m[3],
+			code: true
+		});
+		else if (m[4] !== void 0) {
+			segments.push({ text: m[4] });
+			segments.push({
+				text: ` (${m[5]})`,
+				dim: true
+			});
+		}
+		last = m.index + m[0].length;
+	}
+	if (last < raw.length) segments.push({ text: raw.slice(last) });
+	return segments;
+}
+function MarkdownLine({ line, baseColor = "white", baseDim = false }) {
+	const raw = line;
+	const headingMatch = raw.match(/^(#{1,3})\s+(.*)/);
+	if (headingMatch) {
+		const level = headingMatch[1].length;
+		const text = headingMatch[2];
+		return /* @__PURE__ */ jsxs(Text, {
+			bold: true,
+			color: level === 1 ? "whiteBright" : level === 2 ? "white" : "gray",
+			children: ["  ", text]
+		});
+	}
+	if (raw.startsWith("> ")) return /* @__PURE__ */ jsxs(Text, {
+		color: "gray",
+		children: ["  │ ", raw.slice(2)]
+	});
+	const listMatch = raw.match(/^(\s*[-*+]|\s*\d+\.)\s+(.*)/);
+	if (listMatch) {
+		const indent = listMatch[1].match(/^\s*/)?.[0].length ?? 0;
+		const content = listMatch[2];
+		const segments = parseInline(content);
+		return /* @__PURE__ */ jsxs(Text, { children: ["  " + " ".repeat(indent) + "• ", segments.map((s, i) => /* @__PURE__ */ jsx(Text, {
+			bold: s.bold,
+			color: s.code ? "cyan" : s.dim ? "gray" : baseColor,
+			dimColor: s.dim || baseDim,
+			children: s.text
+		}, i))] });
+	}
+	if (/^[-*_]{3,}$/.test(raw.trim())) return /* @__PURE__ */ jsx(Text, {
+		color: "gray",
+		dimColor: true,
+		children: "  ────────────────────"
+	});
+	if (!raw.trim()) return /* @__PURE__ */ jsx(Text, { children: " " });
+	return /* @__PURE__ */ jsxs(Text, { children: ["  ", parseInline(raw).map((s, i) => /* @__PURE__ */ jsx(Text, {
+		bold: s.bold,
+		color: s.code ? "cyan" : s.dim ? "gray" : baseColor,
+		dimColor: s.dim || baseDim,
+		children: s.text
+	}, i))] });
+}
+//#endregion
+//#region src/ui/ChangelogPanel.tsx
+function openInBrowser(url) {
+	exec(process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`);
+}
+function ChangelogPanel({ pkg, onClose }) {
+	const [entries, setEntries] = useState([]);
+	const [repoUrl, setRepoUrl] = useState("");
+	const [loading, setLoading] = useState(true);
+	const [opened, setOpened] = useState(false);
+	const [activeEntry, setActiveEntry] = useState(0);
+	const scrollRef = useRef(null);
+	const { stdout } = useStdout();
+	useEffect(() => {
+		Promise.all([fetchChangelog(pkg.name, pkg.current, pkg.targetVersion ?? pkg.latest), fetchRepoUrl(pkg.name)]).then(([e, repo]) => {
+			setEntries(e);
+			setActiveEntry(0);
+			setRepoUrl(repo);
+			setLoading(false);
+		});
+	}, [pkg.name]);
+	useEffect(() => {
+		const handleResize = () => scrollRef.current?.remeasure();
+		stdout?.on("resize", handleResize);
+		return () => {
+			stdout?.off("resize", handleResize);
+		};
+	}, [stdout]);
+	const releasesPageUrl = repoUrl ? `${repoUrl}/releases` : "";
+	const triggerOpen = (url) => {
+		openInBrowser(url);
+		setOpened(true);
+		setTimeout(() => setOpened(false), 2e3);
+	};
+	const currentEntry = entries[activeEntry];
+	useInput((input, key) => {
+		if (key.escape || input === "q" || input === "c") {
+			onClose();
+			return;
+		}
+		if (key.leftArrow && entries.length > 1) {
+			scrollRef.current?.scrollTo(0);
+			setActiveEntry((prev) => Math.max(0, prev - 1));
+			return;
+		}
+		if (key.rightArrow && entries.length > 1) {
+			scrollRef.current?.scrollTo(0);
+			setActiveEntry((prev) => Math.min(entries.length - 1, prev + 1));
+			return;
+		}
+		if (key.upArrow) scrollRef.current?.scrollBy(-1);
+		if (key.downArrow) scrollRef.current?.scrollBy(1);
+		if (key.pageUp) {
+			const h = scrollRef.current?.getViewportHeight() ?? 10;
+			scrollRef.current?.scrollBy(-h);
+		}
+		if (key.pageDown) {
+			const h = scrollRef.current?.getViewportHeight() ?? 10;
+			scrollRef.current?.scrollBy(h);
+		}
+		if (input === "r" && releasesPageUrl) triggerOpen(releasesPageUrl);
+		if (input === "o" && currentEntry?.url) triggerOpen(currentEntry.url);
+	});
+	const targetVer = pkg.targetVersion ?? pkg.latest;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginBottom: 1,
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						bold: true,
+						color: "magentaBright",
+						children: [
+							" ",
+							"Changelog — ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "whiteBright",
+								children: pkg.name
+							})
+						]
+					}),
+					/* @__PURE__ */ jsxs(Text, {
+						color: "gray",
+						children: [
+							"  ",
+							/* @__PURE__ */ jsx(Text, {
+								color: "red",
+								children: pkg.current
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								color: "gray",
+								children: " → "
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								color: "greenBright",
+								children: targetVer
+							})
+						]
+					}),
+					repoUrl && /* @__PURE__ */ jsxs(Text, {
+						color: "gray",
+						dimColor: true,
+						children: [
+							" ",
+							repoUrl,
+							"/releases"
+						]
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: "────────────────────────────────────────────────────"
+					})
+				]
+			}),
+			entries.length > 1 && !loading && /* @__PURE__ */ jsx(Box, {
+				marginBottom: 1,
+				gap: 1,
+				children: /* @__PURE__ */ jsxs(Text, {
+					color: "gray",
+					children: [
+						"  ",
+						activeEntry > 0 ? /* @__PURE__ */ jsx(Text, {
+							color: "white",
+							children: "←"
+						}) : /* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: "←"
+						}),
+						" ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "cyanBright",
+							bold: true,
+							children: currentEntry?.version ?? ""
+						}),
+						" ",
+						/* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							children: [
+								"(",
+								activeEntry + 1,
+								"/",
+								entries.length,
+								")"
+							]
+						}),
+						" ",
+						activeEntry < entries.length - 1 ? /* @__PURE__ */ jsx(Text, {
+							color: "white",
+							children: "→"
+						}) : /* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: "→"
+						})
+					]
+				})
+			}),
+			loading ? /* @__PURE__ */ jsx(Text, {
+				color: "gray",
+				children: " fetching release notes…"
+			}) : entries.length === 0 ? /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [/* @__PURE__ */ jsxs(Text, {
+					color: "gray",
+					children: [" ", "No GitHub release notes found between these versions."]
+				}), releasesPageUrl ? /* @__PURE__ */ jsxs(Text, {
+					color: "gray",
+					children: [
+						" ",
+						"Press ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "white",
+							children: "r"
+						}),
+						" to open releases page in browser."
+					]
+				}) : /* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: " Check the package repository manually."
+				})]
+			}) : currentEntry ? /* @__PURE__ */ jsx(Box, {
+				height: 18,
+				flexDirection: "column",
+				children: /* @__PURE__ */ jsx(ScrollView, {
+					ref: scrollRef,
+					children: /* @__PURE__ */ jsx(Box, {
+						flexDirection: "column",
+						children: currentEntry.body.split("\n").map((line, j) => /* @__PURE__ */ jsx(MarkdownLine, { line }, j))
+					})
+				})
+			}) : null,
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginTop: 1,
+				children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: "────────────────────────────────────────────────────"
+					}),
+					/* @__PURE__ */ jsxs(Box, {
+						gap: 3,
+						children: [
+							/* @__PURE__ */ jsxs(Text, {
+								color: "gray",
+								children: [/* @__PURE__ */ jsx(Text, {
+									color: "white",
+									children: "↑↓"
+								}), " scroll"]
+							}),
+							entries.length > 1 && /* @__PURE__ */ jsxs(Text, {
+								color: "gray",
+								children: [/* @__PURE__ */ jsx(Text, {
+									color: "white",
+									children: "←→"
+								}), " releases"]
+							}),
+							/* @__PURE__ */ jsxs(Text, {
+								color: "gray",
+								children: [/* @__PURE__ */ jsx(Text, {
+									color: "white",
+									children: "PgUp/Dn"
+								}), " fast"]
+							}),
+							currentEntry?.url && /* @__PURE__ */ jsxs(Text, {
+								color: "gray",
+								children: [/* @__PURE__ */ jsx(Text, {
+									color: "white",
+									children: "o"
+								}), " open release"]
+							}),
+							releasesPageUrl && /* @__PURE__ */ jsxs(Text, {
+								color: "gray",
+								children: [/* @__PURE__ */ jsx(Text, {
+									color: "white",
+									children: "r"
+								}), " all releases"]
+							}),
+							/* @__PURE__ */ jsxs(Text, {
+								color: "gray",
+								children: [/* @__PURE__ */ jsx(Text, {
+									color: "white",
+									children: "esc"
+								}), " close"]
+							})
+						]
+					}),
+					opened && /* @__PURE__ */ jsx(Text, {
+						color: "greenBright",
+						children: " ✓ opened in browser"
+					})
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/ui/UpdateResults.tsx
+function UpdateResults({ results, onDone }) {
+	useEffect(() => {
+		const timer = setTimeout(onDone, 1e3);
+		return () => clearTimeout(timer);
+	}, []);
+	const success = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Box, {
+				marginBottom: 1,
+				children: /* @__PURE__ */ jsxs(Text, {
+					bold: true,
+					color: "greenBright",
+					children: [" ", "Update complete"]
+				})
+			}),
+			success.map((r) => /* @__PURE__ */ jsxs(Box, {
+				gap: 2,
+				children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: "greenBright",
+						children: "✓"
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: "white",
+						children: r.name
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						color: "gray",
+						children: r.fromVersion
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: "→"
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: "greenBright",
+						children: r.version
+					})
+				]
+			}, r.name)),
+			failed.map((r) => /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [/* @__PURE__ */ jsxs(Box, {
+					gap: 2,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "red",
+							children: "✗"
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							color: "white",
+							children: r.name
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							color: "gray",
+							children: r.fromVersion
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: "→"
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							color: "red",
+							children: r.version
+						})
+					]
+				}), r.error && /* @__PURE__ */ jsxs(Text, {
+					color: "red",
+					dimColor: true,
+					children: [" ", r.error.slice(0, 80)]
+				})]
+			}, r.name))
+		]
+	});
+}
+//#endregion
+//#region src/ui/Settings.tsx
+const SETTINGS = [{
+	key: "groupByScope",
+	label: "Group packages by scope",
+	description: "Sub-group scoped packages (@org/pkg) under their scope prefix"
+}];
+function Settings({ config, onConfigChange, onClose }) {
+	const [cursor, setCursor] = useState(0);
+	useInput((input, key) => {
+		if (key.upArrow) setCursor((c) => Math.max(0, c - 1));
+		if (key.downArrow) setCursor((c) => Math.min(SETTINGS.length - 1, c + 1));
+		if (input === " " || key.return) {
+			const setting = SETTINGS[cursor];
+			onConfigChange({
+				...config,
+				[setting.key]: !config[setting.key]
+			});
+		}
+		if (key.escape || input === "s") onClose();
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Box, {
+				marginBottom: 1,
+				flexDirection: "column",
+				children: /* @__PURE__ */ jsxs(Text, {
+					bold: true,
+					color: "greenBright",
+					children: [
+						" ",
+						"ripen ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: "-- settings"
+						})
+					]
+				})
+			}),
+			SETTINGS.map((setting, i) => {
+				const isFocused = cursor === i;
+				const isEnabled = config[setting.key];
+				return /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					marginBottom: 1,
+					children: [/* @__PURE__ */ jsxs(Box, {
+						gap: 1,
+						children: [
+							/* @__PURE__ */ jsx(Text, {
+								color: "greenBright",
+								children: isFocused ? "❯" : " "
+							}),
+							/* @__PURE__ */ jsxs(Text, {
+								color: isEnabled ? "greenBright" : "gray",
+								children: [
+									"[",
+									isEnabled ? "✓" : " ",
+									"]"
+								]
+							}),
+							/* @__PURE__ */ jsx(Text, {
+								bold: isFocused,
+								color: isFocused ? "whiteBright" : "white",
+								children: setting.label
+							})
+						]
+					}), /* @__PURE__ */ jsx(Box, {
+						marginLeft: 6,
+						children: /* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							color: "gray",
+							children: setting.description
+						})
+					})]
+				}, setting.key);
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsxs(Text, {
+					color: "gray",
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "white",
+							children: "↑↓"
+						}),
+						" navigate",
+						"  ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "white",
+							children: "space"
+						}),
+						" toggle",
+						"  ",
+						/* @__PURE__ */ jsx(Text, {
+							color: "white",
+							children: "esc"
+						}),
+						" back"
+					]
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region src/ui/SelfUpdatePrompt.tsx
+function SelfUpdatePrompt({ currentVersion, latestVersion, updating, error, onUpdate, onSkip }) {
+	const [selected, setSelected] = useState(0);
+	useInput((input, key) => {
+		if (updating) return;
+		if (key.upArrow) setSelected(0);
+		if (key.downArrow) setSelected(1);
+		if (key.return) if (selected === 0) onUpdate();
+		else onSkip();
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				color: "greenBright",
+				bold: true,
+				children: [" ", "ripen"]
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				children: /* @__PURE__ */ jsxs(Text, { children: [
+					"A new version is available!",
+					" ",
+					/* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: currentVersion
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: " → "
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: "greenBright",
+						children: latestVersion
+					})
+				] })
+			}),
+			error && /* @__PURE__ */ jsxs(Box, {
+				marginTop: 1,
+				children: [/* @__PURE__ */ jsxs(Text, {
+					color: "red",
+					children: ["✗ Update failed: ", error]
+				}), /* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: " Continuing…"
+				})]
+			}),
+			updating ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: "Updating ripen…"
+				})
+			}) : /* @__PURE__ */ jsxs(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				children: [/* @__PURE__ */ jsxs(Text, { children: [selected === 0 ? /* @__PURE__ */ jsx(Text, {
+					color: "greenBright",
+					children: "❯ "
+				}) : /* @__PURE__ */ jsx(Text, { children: "  " }), /* @__PURE__ */ jsx(Text, {
+					color: selected === 0 ? "white" : "gray",
+					children: "Update and continue"
+				})] }), /* @__PURE__ */ jsxs(Text, { children: [selected === 1 ? /* @__PURE__ */ jsx(Text, {
+					color: "greenBright",
+					children: "❯ "
+				}) : /* @__PURE__ */ jsx(Text, { children: "  " }), /* @__PURE__ */ jsx(Text, {
+					color: selected === 1 ? "white" : "gray",
+					children: "Just continue"
+				})] })]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/ui/App.tsx
+function App({ project, global, version }) {
+	const { exit } = useApp();
+	const [screen, setScreen] = useState("self-update-check");
+	const [latestVersion, setLatestVersion] = useState(null);
+	const [selfUpdateError, setSelfUpdateError] = useState(null);
+	const [selfUpdating, setSelfUpdating] = useState(false);
+	const [config, setConfig] = useState(() => loadConfig());
+	const [packages, setPackages] = useState([]);
+	const [focusedIndex, setFocusedIndex] = useState(0);
+	const [activeIndex, setActiveIndex] = useState(0);
+	const [results, setResults] = useState([]);
+	const [errorMsg, setErrorMsg] = useState("");
+	const [loadingMsg, setLoadingMsg] = useState("Checking for outdated packages…");
+	const MAX_TERMINAL_LINES = 3;
+	const [outputLines, setOutputLines] = useState([]);
+	const [terminalCmd, setTerminalCmd] = useState(global ? "Checking all package managers…" : `${project.manager} outdated --json`);
+	useEffect(() => {
+		let cancelled = false;
+		fetchLatestVersion("ripencli").then((latest) => {
+			if (cancelled) return;
+			if (latest && isNewerVersion(version, latest)) {
+				setLatestVersion(latest);
+				setScreen("self-update");
+			} else setScreen("loading");
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+	const [fetchStarted, setFetchStarted] = useState(false);
+	useEffect(() => {
+		if (screen !== "loading" || fetchStarted) return;
+		setFetchStarted(true);
+		const onLine = (line) => {
+			setOutputLines((prev) => [...prev.slice(-(MAX_TERMINAL_LINES - 1)), line]);
+		};
+		(global ? getAllGlobalOutdated(project.cwd, onLine) : getOutdatedPackages(project.manager, project.cwd, false, onLine)).then((result) => {
+			if (!result.ok) {
+				setErrorMsg(result.error);
+				setScreen("error");
+				return;
+			}
+			setOutputLines([]);
+			if (result.packages.length === 0) setScreen("empty");
+			else {
+				setPackages(result.packages);
+				setScreen("list");
+			}
+		});
+	}, [screen]);
+	const handleToggle = (index) => {
+		setPackages((prev) => prev.map((p, i) => i === index ? {
+			...p,
+			selected: !p.selected
+		} : p));
+	};
+	const handleToggleGroup = (groupType) => {
+		setPackages((prev) => {
+			const allSelected = prev.filter((p) => p.type === groupType).every((p) => p.selected);
+			return prev.map((p) => p.type === groupType ? {
+				...p,
+				selected: !allSelected
+			} : p);
+		});
+	};
+	const handleToggleMany = (indices) => {
+		setPackages((prev) => {
+			const allSelected = indices.every((i) => prev[i]?.selected);
+			return prev.map((p, i) => indices.includes(i) ? {
+				...p,
+				selected: !allSelected
+			} : p);
+		});
+	};
+	const handleConfigChange = (newConfig) => {
+		setConfig(newConfig);
+		saveConfig(newConfig);
+	};
+	const handleSelectVersion = (index) => {
+		setActiveIndex(index);
+		setScreen("version-picker");
+	};
+	const handleViewChangelog = (index) => {
+		setActiveIndex(index);
+		setScreen("changelog");
+	};
+	const handleVersionChosen = (version) => {
+		setPackages((prev) => prev.map((p, i) => i === activeIndex ? {
+			...p,
+			targetVersion: version,
+			selected: true
+		} : p));
+		setScreen("list");
+	};
+	const handleSelfUpdate = async () => {
+		setSelfUpdating(true);
+		try {
+			await execa("npm", [
+				"install",
+				"--global",
+				`ripencli@${latestVersion}`
+			]);
+			setSelfUpdating(false);
+			setScreen("loading");
+		} catch (err) {
+			setSelfUpdateError(err.message ?? "Unknown error");
+			setSelfUpdating(false);
+			setTimeout(() => setScreen("loading"), 2e3);
+		}
+	};
+	const handleConfirm = async () => {
+		const selected = packages.filter((p) => p.selected);
+		if (selected.length === 0) return;
+		setLoadingMsg(`Updating ${selected.length} package${selected.length > 1 ? "s" : ""}…`);
+		setTerminalCmd("");
+		setOutputLines([]);
+		setScreen("updating");
+		const onLine = (line) => {
+			setOutputLines((prev) => [...prev.slice(-(MAX_TERMINAL_LINES - 1)), line]);
+		};
+		setResults(await updatePackages(project.manager, selected, project.cwd, global, onLine));
+		setScreen("results");
+	};
+	if (screen === "self-update-check") return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [/* @__PURE__ */ jsxs(Text, {
+			color: "greenBright",
+			bold: true,
+			children: [" ", "ripen"]
+		}), /* @__PURE__ */ jsx(Box, {
+			marginTop: 1,
+			children: /* @__PURE__ */ jsx(Text, {
+				color: "gray",
+				children: "Checking for updates…"
+			})
+		})]
+	});
+	if (screen === "self-update") return /* @__PURE__ */ jsx(SelfUpdatePrompt, {
+		currentVersion: version,
+		latestVersion,
+		updating: selfUpdating,
+		error: selfUpdateError,
+		onUpdate: handleSelfUpdate,
+		onSkip: () => setScreen("loading")
+	});
+	if (screen === "loading") return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Text, {
+				color: "greenBright",
+				bold: true,
+				children: [" ", "ripen"]
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: loadingMsg
+				})
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginTop: 1,
+				borderStyle: "round",
+				borderColor: "gray",
+				paddingX: 1,
+				width: 64,
+				height: MAX_TERMINAL_LINES + 3,
+				overflow: "hidden",
+				children: [terminalCmd !== "" && /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: "$ "
+				}), /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					color: "gray",
+					children: terminalCmd
+				})] }), outputLines.map((line, i) => /* @__PURE__ */ jsx(Text, {
+					color: line.includes("WARN") || line.includes("ERR") ? "yellow" : "gray",
+					dimColor: true,
+					wrap: "truncate",
+					children: line
+				}, i))]
+			})
+		]
+	});
+	if (screen === "error") return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [/* @__PURE__ */ jsxs(Text, {
+			color: "greenBright",
+			bold: true,
+			children: [" ", "ripen"]
+		}), /* @__PURE__ */ jsxs(Box, {
+			marginTop: 1,
+			flexDirection: "column",
+			gap: 1,
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					color: "red",
+					children: "✗ Could not fetch outdated packages"
+				}),
+				/* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					dimColor: true,
+					children: errorMsg
+				}),
+				/* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: "This usually means a network issue. Check your connection and try again."
+					})
+				})
+			]
+		})]
+	});
+	if (screen === "empty") return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [/* @__PURE__ */ jsxs(Text, {
+			color: "greenBright",
+			bold: true,
+			children: [" ", "ripen"]
+		}), /* @__PURE__ */ jsx(Box, {
+			marginTop: 1,
+			children: /* @__PURE__ */ jsxs(Text, {
+				color: "gray",
+				children: [
+					"✓ All packages are up to date in",
+					" ",
+					/* @__PURE__ */ jsx(Text, {
+						color: "white",
+						children: global ? "global" : project.name
+					})
+				]
+			})
+		})]
+	});
+	const isListActive = screen === "list";
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		screen === "updating" && /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			padding: 1,
+			children: [
+				/* @__PURE__ */ jsxs(Text, {
+					color: "greenBright",
+					bold: true,
+					children: [" ", "ripen"]
+				}),
+				/* @__PURE__ */ jsx(Box, {
+					marginTop: 1,
+					children: /* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: loadingMsg
+					})
+				}),
+				/* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					marginTop: 1,
+					borderStyle: "round",
+					borderColor: "gray",
+					paddingX: 1,
+					width: 64,
+					height: MAX_TERMINAL_LINES + 3,
+					overflow: "hidden",
+					children: [terminalCmd !== "" && /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: "$ "
+					}), /* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						color: "gray",
+						children: terminalCmd
+					})] }), outputLines.map((line, i) => /* @__PURE__ */ jsx(Text, {
+						color: line.includes("WARN") || line.includes("ERR") ? "yellow" : "gray",
+						dimColor: true,
+						wrap: "truncate",
+						children: line
+					}, i))]
+				})
+			]
+		}),
+		screen === "results" && /* @__PURE__ */ jsx(Box, {
+			padding: 1,
+			children: /* @__PURE__ */ jsx(UpdateResults, {
+				results,
+				onDone: () => {
+					exit();
+					process.exit(0);
+				}
+			})
+		}),
+		screen === "settings" && /* @__PURE__ */ jsx(Box, {
+			padding: 1,
+			children: /* @__PURE__ */ jsx(Settings, {
+				config,
+				onConfigChange: handleConfigChange,
+				onClose: () => setScreen("list")
+			})
+		}),
+		screen === "version-picker" && packages[activeIndex] && /* @__PURE__ */ jsx(Box, {
+			padding: 1,
+			children: /* @__PURE__ */ jsx(VersionPicker, {
+				pkg: packages[activeIndex],
+				onSelect: handleVersionChosen,
+				onCancel: () => setScreen("list")
+			})
+		}),
+		screen === "changelog" && packages[activeIndex] && /* @__PURE__ */ jsx(Box, {
+			padding: 1,
+			children: /* @__PURE__ */ jsx(ChangelogPanel, {
+				pkg: packages[activeIndex],
+				onClose: () => setScreen("list")
+			})
+		}),
+		/* @__PURE__ */ jsx(Box, {
+			padding: 1,
+			display: isListActive ? "flex" : "none",
+			children: /* @__PURE__ */ jsx(PackageList, {
+				packages,
+				onToggle: handleToggle,
+				onToggleGroup: handleToggleGroup,
+				onToggleMany: handleToggleMany,
+				onSelectVersion: handleSelectVersion,
+				onViewChangelog: handleViewChangelog,
+				onConfirm: handleConfirm,
+				onOpenSettings: () => setScreen("settings"),
+				focusedIndex,
+				onFocusChange: setFocusedIndex,
+				groupByScope: config.groupByScope,
+				isActive: isListActive
+			})
+		})
+	] });
+}
+//#endregion
+//#region src/cli.tsx
+const VERSION = "0.1.0";
+const args = process.argv.slice(2);
+const isGlobal = args.includes("--global") || args.includes("-g");
+const showHelp = args.includes("--help") || args.includes("-h");
+if (args.includes("--version") || args.includes("-V")) {
+	console.log(VERSION);
+	process.exit(0);
+}
+if (showHelp) {
+	console.log(`
+  ripen — interactive dependency updater
+
+  Usage:
+    ripen           check current project
+    ripen -g        check global packages
+    ripen --help    show this help
+    ripen --version show version
+
+  Controls (inside TUI):
+    ↑ ↓       navigate packages
+    space     toggle select
+    v         pick specific version
+    c         view changelog / release notes
+    enter     update selected packages
+    esc       cancel / go back
+`);
+	process.exit(0);
+}
+const cwd = process.cwd();
+if (!isGlobal && !hasPackageJson(cwd)) {
+	console.log("\n  No package.json found in this directory.\n");
+	console.log("  Run ripen inside a Node.js project, or use ripen -g for global packages.\n");
+	process.exit(1);
+}
+const { waitUntilExit } = render(/* @__PURE__ */ jsx(App, {
+	project: getProjectInfo(cwd),
+	global: isGlobal,
+	version: VERSION
+}));
+await waitUntilExit();
+//#endregion
+export {};