ripencli 0.2.5 → 0.2.7

package/README.md

@@ -14,6 +14,8 @@
 - **Global packages** — check and update global installs across all* package managers
 - **Self-update** — notifies you when a new version of ripen is available
 - **Major bump warnings** — highlights potentially breaking updates
+- **Scope grouping** — optionally group scoped packages (e.g. `@heroui/*`) together
+- **Frequency sorting** — packages you update often can be surfaced to the top
 
 ## Install
 
@@ -49,6 +51,7 @@ ripen --help
 | `v`     | Pick specific version          |
 | `c`     | View changelog / release notes |
 | `enter` | Update selected packages       |
+| `s`     | Open settings                  |
 | `esc`   | Cancel / go back               |
 
 ## How it works
@@ -60,6 +63,17 @@ ripen --help
 5. Press `c` to see GitHub release notes between your current and target version
 6. Select the ones you want and press enter — ripen runs the update commands for you
 
+## Settings
+
+Press `s` to open the settings screen. Settings are persisted at `~/.config/ripen/config.json`.
+
+| Setting                      | Default | Description                                                  |
+| ---------------------------- | ------- | ------------------------------------------------------------ |
+| Sort by update frequency     | Off     | Packages you update often appear at the top                  |
+| Enable scope grouping        | Off     | Group scoped packages under their scope prefix               |
+| Show grouped scopes on top   | Off     | Grouped scopes appear before ungrouped packages              |
+| Grouped scopes               | —       | List of scopes to group (e.g. `@heroui`, `@radix-ui`)       |
+
 When using `ripen -g`, all available package managers (npm, pnpm, yarn) are checked in parallel so you see every global package in one place. Bun is not included in global checking because it doesn't provide a JSON output for its outdated command.
 
 ## License

package/dist/cli.js

@@ -522,16 +522,12 @@ async function updatePackages(manager, packages, cwd, global = false, onLine) {
 }
 //#endregion
 //#region src/config.ts
-const DEFAULT_UNGROUP_SCOPES = ["@types", "@react-types"];
 const DEFAULT_CONFIG = {
-	groupByScope: true,
-	addedScopes: [],
-	removedDefaults: []
+	groupByScope: false,
+	groupScopes: [],
+	groupsOnTop: false,
+	frequencySort: false
 };
-/** Compute the effective ungroup scopes list: (defaults - removedDefaults) + addedScopes */
-function getEffectiveUngroupScopes(config) {
-	return [...DEFAULT_UNGROUP_SCOPES.filter((s) => !config.removedDefaults.includes(s)), ...config.addedScopes];
-}
 const CONFIG_DIR = join(homedir(), ".config", "ripen");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 function loadConfig() {
@@ -552,6 +548,23 @@ function saveConfig(config) {
 		writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
 	} catch {}
 }
+const FREQUENCY_PATH = join(CONFIG_DIR, "frequency.json");
+function loadFrequency() {
+	try {
+		const raw = readFileSync(FREQUENCY_PATH, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return {};
+	}
+}
+function incrementFrequency(packageNames) {
+	try {
+		const freq = loadFrequency();
+		for (const name of packageNames) freq[name] = (freq[name] ?? 0) + 1;
+		mkdirSync(CONFIG_DIR, { recursive: true });
+		writeFileSync(FREQUENCY_PATH, JSON.stringify(freq, null, 2) + "\n", "utf-8");
+	} catch {}
+}
 //#endregion
 //#region src/ui/PackageList.tsx
 const TYPE_COLORS = {
@@ -574,7 +587,7 @@ const GROUP_CHROME = 5;
 function getScope(name) {
 	return name.match(/^(@[^/]+)\//)?.[1] ?? null;
 }
-function buildDisplayRows(packages, groupByScope, ungroupScopes = []) {
+function buildDisplayRows(packages, groupByScope = false, groupScopes = [], groupsOnTop = false, frequencySort = false, frequency = {}) {
 	const grouped = /* @__PURE__ */ new Map();
 	packages.forEach((pkg, i) => {
 		if (!grouped.has(pkg.type)) grouped.set(pkg.type, []);
@@ -583,6 +596,12 @@ function buildDisplayRows(packages, groupByScope, ungroupScopes = []) {
 			index: i
 		});
 	});
+	const freqSort = (a, b) => {
+		const fa = frequency[a.pkg.name] ?? 0;
+		const fb = frequency[b.pkg.name] ?? 0;
+		if (fb !== fa) return fb - fa;
+		return a.pkg.name.localeCompare(b.pkg.name);
+	};
 	const rows = [];
 	for (const type of GROUP_ORDER) {
 		const items = grouped.get(type);
@@ -594,54 +613,105 @@ function buildDisplayRows(packages, groupByScope, ungroupScopes = []) {
 			label: GROUP_LABELS[type] ?? type,
 			packages: allPkgs
 		});
-		if (groupByScope) {
+		if (groupByScope && groupScopes.length > 0) {
 			const scopeMap = /* @__PURE__ */ new Map();
-			const unscoped = [];
+			const ungrouped = [];
 			for (const item of items) {
 				const scope = getScope(item.pkg.name);
-				if (scope && !ungroupScopes.includes(scope)) {
+				if (scope && groupScopes.includes(scope)) {
 					if (!scopeMap.has(scope)) scopeMap.set(scope, []);
 					scopeMap.get(scope).push(item);
-				} else unscoped.push(item);
+				} else ungrouped.push(item);
 			}
-			const emittedScopes = /* @__PURE__ */ new Set();
-			for (const item of items) {
-				const scope = getScope(item.pkg.name);
-				if (scope && scopeMap.has(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({
+			const scopeGroups = [];
+			for (const [scope, scopeItems] of scopeMap) if (scopeItems.length >= 2) scopeGroups.push({
+				scope,
+				items: scopeItems
+			});
+			else ungrouped.push(...scopeItems);
+			if (frequencySort) scopeGroups.sort((a, b) => {
+				const maxA = Math.max(...a.items.map((i) => frequency[i.pkg.name] ?? 0));
+				const maxB = Math.max(...b.items.map((i) => frequency[i.pkg.name] ?? 0));
+				if (maxB !== maxA) return maxB - maxA;
+				return a.scope.localeCompare(b.scope);
+			});
+			else scopeGroups.sort((a, b) => a.scope.localeCompare(b.scope));
+			const emitScopeGroups = () => {
+				for (const { scope, items: scopeItems } of scopeGroups) {
+					if (frequencySort) scopeItems.sort(freqSort);
+					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
+					});
+				}
+			};
+			const emitUngrouped = () => {
+				if (frequencySort) ungrouped.sort(freqSort);
+				for (const item of ungrouped) rows.push({
 					kind: "package",
 					pkg: item.pkg,
 					packageIndex: item.index,
 					indented: false,
 					scopeKey: null
 				});
+			};
+			if (groupsOnTop || frequencySort) {
+				emitScopeGroups();
+				emitUngrouped();
+			} else {
+				const emittedScopes = /* @__PURE__ */ new Set();
+				for (const item of items) {
+					const scope = getScope(item.pkg.name);
+					const group = scope ? scopeGroups.find((g) => g.scope === scope) : void 0;
+					if (group) {
+						if (!emittedScopes.has(scope)) {
+							emittedScopes.add(scope);
+							const scopeKey = `${type}::${scope}`;
+							rows.push({
+								kind: "scope-header",
+								groupType: type,
+								scope,
+								packageIndices: group.items.map((si) => si.index),
+								packages: group.items.map((si) => si.pkg)
+							});
+							for (const si of group.items) 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
-		});
+		} else {
+			const sorted = frequencySort ? [...items].sort(freqSort) : items;
+			for (const item of sorted) rows.push({
+				kind: "package",
+				pkg: item.pkg,
+				packageIndex: item.index,
+				indented: false,
+				scopeKey: null
+			});
+		}
 	}
 	return rows;
 }
@@ -691,12 +761,15 @@ function computeMaxPerGroup(terminalRows, groupCount) {
 	const perGroup = Math.floor(available / groupCount);
 	return Math.max(3, perGroup);
 }
-function PackageList({ packages, onToggle, onToggleGroup, onToggleMany, onSelectVersion, onViewChangelog, onConfirm, onOpenSettings, groupByScope, ungroupScopes, isActive = true }) {
+function PackageList({ packages, onToggle, onToggleGroup, onToggleMany, onSelectVersion, onViewChangelog, onConfirm, onOpenSettings, groupByScope = false, groupScopes, groupsOnTop = false, frequencySort = false, frequency = {}, isActive = true }) {
 	const [focusedIndex, setFocusedIndex] = useState(0);
-	const allRows = useMemo(() => buildDisplayRows(packages, groupByScope, ungroupScopes), [
+	const allRows = useMemo(() => buildDisplayRows(packages, groupByScope, groupScopes, groupsOnTop, frequencySort, frequency), [
 		packages,
 		groupByScope,
-		ungroupScopes
+		groupScopes,
+		groupsOnTop,
+		frequencySort,
+		frequency
 	]);
 	const allScopeKeys = useMemo(() => {
 		const keys = /* @__PURE__ */ new Set();
@@ -1625,11 +1698,13 @@ function UpdateResults({ results, onDone }) {
 function Settings({ config, onConfigChange, onClose }) {
 	const [inputMode, setInputMode] = useState(false);
 	const [inputValue, setInputValue] = useState("");
-	const effectiveScopes = getEffectiveUngroupScopes(config);
+	const scopes = config.groupScopes;
 	const rows = [
-		{ type: "toggle" },
+		{ type: "toggle-frequency" },
+		{ type: "toggle-group" },
+		{ type: "toggle-groups-top" },
 		{ type: "list-header" },
-		...effectiveScopes.map((_, i) => ({
+		...scopes.map((_, i) => ({
 			type: "list-item",
 			listItemIndex: i
 		}))
@@ -1638,24 +1713,16 @@ function Settings({ config, onConfigChange, onClose }) {
 	const currentRow = rows[flatCursor];
 	const addScope = (value) => {
 		const scope = value.startsWith("@") ? value : `@${value}`;
-		if (effectiveScopes.includes(scope)) return;
-		if (DEFAULT_UNGROUP_SCOPES.includes(scope)) onConfigChange({
-			...config,
-			removedDefaults: config.removedDefaults.filter((s) => s !== scope)
-		});
-		else onConfigChange({
+		if (scopes.includes(scope)) return;
+		onConfigChange({
 			...config,
-			addedScopes: [...config.addedScopes, scope]
+			groupScopes: [...scopes, scope]
 		});
 	};
 	const removeScope = (scope) => {
-		if (DEFAULT_UNGROUP_SCOPES.includes(scope)) onConfigChange({
+		onConfigChange({
 			...config,
-			removedDefaults: [...config.removedDefaults, scope]
-		});
-		else onConfigChange({
-			...config,
-			addedScopes: config.addedScopes.filter((s) => s !== scope)
+			groupScopes: scopes.filter((s) => s !== scope)
 		});
 	};
 	useInput((input, key) => {
@@ -1682,10 +1749,18 @@ function Settings({ config, onConfigChange, onClose }) {
 		if (key.upArrow) setFlatCursor((c) => Math.max(0, c - 1));
 		if (key.downArrow) setFlatCursor((c) => Math.min(rows.length - 1, c + 1));
 		if (input === " " || key.return) {
-			if (currentRow?.type === "toggle") onConfigChange({
+			if (currentRow?.type === "toggle-frequency") onConfigChange({
+				...config,
+				frequencySort: !config.frequencySort
+			});
+			else if (currentRow?.type === "toggle-group") onConfigChange({
 				...config,
 				groupByScope: !config.groupByScope
 			});
+			else if (currentRow?.type === "toggle-groups-top") onConfigChange({
+				...config,
+				groupsOnTop: !config.groupsOnTop
+			});
 			else if (currentRow?.type === "list-header") {
 				setInputMode(true);
 				setInputValue("");
@@ -1696,14 +1771,16 @@ function Settings({ config, onConfigChange, onClose }) {
 			setInputValue("");
 		}
 		if ((key.backspace || key.delete) && currentRow?.type === "list-item" && currentRow.listItemIndex !== void 0) {
-			const scope = effectiveScopes[currentRow.listItemIndex];
+			const scope = scopes[currentRow.listItemIndex];
 			removeScope(scope);
 			if (flatCursor >= rows.length - 1) setFlatCursor(Math.max(0, flatCursor - 1));
 		}
 		if (key.escape || input === "s") onClose();
 	});
-	const toggleFocused = flatCursor === 0;
-	const listHeaderFocused = flatCursor === 1;
+	const freqToggleFocused = currentRow?.type === "toggle-frequency";
+	const groupToggleFocused = currentRow?.type === "toggle-group";
+	const groupsTopFocused = currentRow?.type === "toggle-groups-top";
+	const listHeaderFocused = currentRow?.type === "list-header";
 	return /* @__PURE__ */ jsxs(Box, {
 		flexDirection: "column",
 		children: [
@@ -1731,7 +1808,39 @@ function Settings({ config, onConfigChange, onClose }) {
 					children: [
 						/* @__PURE__ */ jsx(Text, {
 							color: "greenBright",
-							children: toggleFocused ? ">" : " "
+							children: freqToggleFocused ? ">" : " "
+						}),
+						/* @__PURE__ */ jsxs(Text, {
+							color: config.frequencySort ? "greenBright" : "gray",
+							children: [
+								"[",
+								config.frequencySort ? "x" : " ",
+								"]"
+							]
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							bold: freqToggleFocused,
+							color: freqToggleFocused ? "whiteBright" : "white",
+							children: "Sort by update frequency"
+						})
+					]
+				}), /* @__PURE__ */ jsx(Box, {
+					marginLeft: 6,
+					children: /* @__PURE__ */ jsx(Text, {
+						color: "gray",
+						children: "Packages you update often appear at the top"
+					})
+				})]
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginBottom: 1,
+				children: [/* @__PURE__ */ jsxs(Box, {
+					gap: 1,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "greenBright",
+							children: groupToggleFocused ? ">" : " "
 						}),
 						/* @__PURE__ */ jsxs(Text, {
 							color: config.groupByScope ? "greenBright" : "gray",
@@ -1742,16 +1851,52 @@ function Settings({ config, onConfigChange, onClose }) {
 							]
 						}),
 						/* @__PURE__ */ jsx(Text, {
-							bold: toggleFocused,
-							color: toggleFocused ? "whiteBright" : "white",
-							children: "Group packages by scope"
+							bold: groupToggleFocused,
+							color: groupToggleFocused ? "whiteBright" : "white",
+							children: "Enable scope grouping"
 						})
 					]
 				}), /* @__PURE__ */ jsx(Box, {
 					marginLeft: 6,
 					children: /* @__PURE__ */ jsx(Text, {
 						color: "gray",
-						children: "Sub-group scoped packages (@org/pkg) under their scope prefix"
+						children: "Group scoped packages listed below under their scope prefix"
+					})
+				})]
+			}),
+			/* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginBottom: 1,
+				children: [/* @__PURE__ */ jsxs(Box, {
+					gap: 1,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: !config.groupByScope,
+							color: "greenBright",
+							children: groupsTopFocused ? ">" : " "
+						}),
+						/* @__PURE__ */ jsxs(Text, {
+							dimColor: !config.groupByScope,
+							color: config.groupsOnTop && config.groupByScope ? "greenBright" : "gray",
+							children: [
+								"[",
+								config.groupsOnTop ? "x" : " ",
+								"]"
+							]
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: !config.groupByScope,
+							bold: groupsTopFocused,
+							color: !config.groupByScope ? "gray" : groupsTopFocused ? "whiteBright" : "white",
+							children: "Show grouped scopes on top"
+						})
+					]
+				}), /* @__PURE__ */ jsx(Box, {
+					marginLeft: 6,
+					children: /* @__PURE__ */ jsx(Text, {
+						dimColor: !config.groupByScope,
+						color: "gray",
+						children: "Grouped scope packages appear before ungrouped ones"
 					})
 				})]
 			}),
@@ -1765,43 +1910,44 @@ function Settings({ config, onConfigChange, onClose }) {
 						children: [/* @__PURE__ */ jsxs(Box, {
 							gap: 1,
 							children: [/* @__PURE__ */ jsx(Text, {
+								dimColor: !config.groupByScope,
 								color: "greenBright",
 								children: listHeaderFocused ? ">" : " "
 							}), /* @__PURE__ */ jsx(Text, {
+								dimColor: !config.groupByScope,
 								bold: listHeaderFocused,
-								color: listHeaderFocused ? "whiteBright" : "white",
-								children: "Excluded scopes from grouping"
+								color: !config.groupByScope ? "gray" : listHeaderFocused ? "whiteBright" : "white",
+								children: "Grouped scopes"
 							})]
 						}), /* @__PURE__ */ jsx(Box, {
 							marginLeft: 4,
 							children: /* @__PURE__ */ jsx(Text, {
+								dimColor: !config.groupByScope,
 								color: "gray",
-								children: "Scopes listed here won't be sub-grouped (type to add, delete to remove)"
+								children: "Scoped packages (@scope/*) listed here will be sub-grouped together"
 							})
 						})]
 					}),
-					effectiveScopes.map((scope, i) => {
-						const itemFocused = flatCursor === 2 + i;
-						const isDefault = DEFAULT_UNGROUP_SCOPES.includes(scope);
+					scopes.map((scope, i) => {
+						const itemFocused = flatCursor === 4 + i;
 						return /* @__PURE__ */ jsxs(Box, {
 							marginLeft: 4,
 							gap: 1,
 							children: [
 								/* @__PURE__ */ jsx(Text, {
+									dimColor: !config.groupByScope,
 									color: "greenBright",
 									children: itemFocused ? ">" : " "
 								}),
 								/* @__PURE__ */ jsx(Text, {
-									color: itemFocused ? "whiteBright" : "white",
+									dimColor: !config.groupByScope,
+									color: !config.groupByScope ? "gray" : itemFocused ? "whiteBright" : "white",
 									children: scope
 								}),
-								isDefault && /* @__PURE__ */ jsx(Text, {
+								itemFocused && /* @__PURE__ */ jsxs(Text, {
+									dimColor: !config.groupByScope,
 									color: "gray",
-									children: "(default)"
-								}),
-								itemFocused && /* @__PURE__ */ jsx(Text, {
-									color: "gray",
-									children: " delete to remove"
+									children: [" ", "delete to remove"]
 								})
 							]
 						}, scope);
@@ -1962,6 +2108,7 @@ function App({ project, global, version, installManager }) {
 	const [selfUpdateError, setSelfUpdateError] = useState(null);
 	const [selfUpdating, setSelfUpdating] = useState(false);
 	const [config, setConfig] = useState(() => loadConfig());
+	const [frequency, setFrequency] = useState(() => loadFrequency());
 	const [packages, setPackages] = useState([]);
 	const [activeIndex, setActiveIndex] = useState(0);
 	const [results, setResults] = useState([]);
@@ -2094,8 +2241,14 @@ function App({ project, global, version, installManager }) {
 		const onLine = (line) => {
 			setOutputLines((prev) => [...prev.slice(-(MAX_TERMINAL_LINES - 1)), line]);
 		};
-		setResults(await updatePackages(project.manager, selected, project.cwd, global, onLine));
+		const res = await updatePackages(project.manager, selected, project.cwd, global, onLine);
+		setResults(res);
 		setScreen("results");
+		const successNames = res.filter((r) => r.success).map((r) => r.name);
+		if (successNames.length > 0) {
+			incrementFrequency(successNames);
+			setFrequency(loadFrequency());
+		}
 	};
 	if (screen === "self-update-check") return /* @__PURE__ */ jsxs(Box, {
 		flexDirection: "column",
@@ -2313,7 +2466,10 @@ function App({ project, global, version, installManager }) {
 				onConfirm: handleConfirm,
 				onOpenSettings: () => setScreen("settings"),
 				groupByScope: config.groupByScope,
-				ungroupScopes: getEffectiveUngroupScopes(config),
+				groupScopes: config.groupScopes,
+				groupsOnTop: config.groupsOnTop,
+				frequencySort: config.frequencySort,
+				frequency,
 				isActive: isListActive
 			})
 		})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ripencli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Interactive dependency updater for npm, pnpm, and yarn",
   "license": "MIT",
   "author": {