jvm-upgrade 0.1.0

package/dist/format.js

@@ -0,0 +1,93 @@
+import { relative } from 'node:path';
+import { styleText } from 'node:util';
+import { levelColor } from './rows.js';
+const LEVELS = ['patch', 'minor', 'major'];
+export function renderTable(rows, root) {
+    const header = ['Name', 'Current', 'Patch', 'Minor', 'Major'];
+    const cells = rows.map((row) => [
+        row.location ? row.name : `${row.name} (manual)`,
+        row.current,
+        ...LEVELS.map((level) => row.choices.find((c) => c.level === level)?.version ?? ''),
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...cells.map((c) => c[i].length)));
+    const lines = [header.map((h, i) => styleText('bold', h.padEnd(widths[i]))).join('  ')];
+    rows.forEach((row, r) => {
+        const selected = row.selected === undefined ? undefined : row.choices[row.selected];
+        const line = cells[r].map((text, i) => {
+            const padded = text.padEnd(widths[i]);
+            if (i === 0)
+                return row.location ? padded : styleText('gray', padded);
+            if (i === 1)
+                return padded;
+            const level = LEVELS[i - 2];
+            if (!text)
+                return padded;
+            const styles = selected?.version === text ? [levelColor(level), 'bold', 'underline'] : [levelColor(level)];
+            return styleText(styles, text) + padded.slice(text.length);
+        });
+        lines.push(line.join('  ').trimEnd());
+        const down = row.choices.find((c) => c.level === 'downgrade');
+        if (down)
+            lines.push(styleText('magenta', `  ↳ cooldown: roll back to ${down.version}`));
+        for (const error of row.errors)
+            lines.push(styleText('yellow', `  ↳ ${error}`));
+    });
+    return lines.join('\n');
+}
+export function toJson(rows, root) {
+    return rows.map((row) => {
+        const selected = row.selected === undefined ? undefined : row.choices[row.selected];
+        return {
+            name: row.name,
+            dependencies: row.deps.map((d) => ({ group: d.group, artifact: d.artifact, kind: d.kind, file: relative(root, d.file) })),
+            current: row.current,
+            patch: row.choices.find((c) => c.level === 'patch')?.version ?? null,
+            minor: row.choices.find((c) => c.level === 'minor')?.version ?? null,
+            major: row.choices.find((c) => c.level === 'major')?.version ?? null,
+            downgrade: row.choices.find((c) => c.level === 'downgrade')?.version ?? null,
+            selected: selected?.version ?? null,
+            rewritable: row.location !== undefined,
+            errors: row.errors,
+        };
+    });
+}
+export function formatChangelog(log, width) {
+    if (!log.entries.length) {
+        return log.source ? `No release notes found here. Read them at:\n${log.source}` : 'No release notes found.';
+    }
+    const out = [];
+    for (const entry of log.entries) {
+        const date = entry.date ? styleText('gray', `  ${entry.date.slice(0, 10)}`) : '';
+        out.push(styleText(['bold', 'cyan'], entry.title && entry.title !== entry.version ? `${entry.version}  ${entry.title}` : entry.version) + date);
+        if (entry.url)
+            out.push(styleText('gray', entry.url));
+        out.push('');
+        for (const line of entry.body.replace(/\r/g, '').trim().split('\n'))
+            out.push(...wrap(line, width));
+        out.push('');
+    }
+    if (log.source)
+        out.push(styleText('gray', `Source: ${log.source}`));
+    return out.join('\n');
+}
+function wrap(line, width) {
+    if (line.length <= width || width < 20)
+        return [line];
+    const indent = /^\s*([-*+]\s+|\d+\.\s+)?/.exec(line)[0].length;
+    const pad = ' '.repeat(Math.min(indent, 8));
+    const words = line.split(' ');
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        if (current && current.length + word.length + 1 > width) {
+            lines.push(current);
+            current = pad + word;
+        }
+        else {
+            current = current ? `${current} ${word}` : word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines;
+}

package/dist/http.js

@@ -0,0 +1,226 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const DEFAULT_TTL = 60 * 60 * 1000;
+const MAX_REDIRECTS = 5;
+export function defaultCacheDir() {
+    const env = process.env;
+    if (env.XDG_CACHE_HOME)
+        return join(env.XDG_CACHE_HOME, 'jvm-upgrade');
+    if (process.platform === 'darwin')
+        return join(homedir(), 'Library', 'Caches', 'jvm-upgrade');
+    if (process.platform === 'win32') {
+        return join(env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'jvm-upgrade', 'cache');
+    }
+    return join(homedir(), '.cache', 'jvm-upgrade');
+}
+export async function clearCache(dir) {
+    await rm(dir, { recursive: true, force: true });
+}
+export function authHeader(url, credentials) {
+    const match = credentials
+        .filter((c) => url.startsWith(c.url) && sameOrigin(url, c.url))
+        .sort((a, b) => b.url.length - a.url.length)[0];
+    if (match?.token)
+        return `Bearer ${match.token}`;
+    if (match?.username !== undefined && match.password !== undefined) {
+        return `Basic ${Buffer.from(`${match.username}:${match.password}`).toString('base64')}`;
+    }
+    const gh = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (gh && hostOf(url) === 'api.github.com')
+        return `Bearer ${gh}`;
+    return undefined;
+}
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameOrigin(a, b) {
+    try {
+        return new URL(a).origin === new URL(b).origin;
+    }
+    catch {
+        return false;
+    }
+}
+function limiter(max) {
+    let active = 0;
+    const waiting = [];
+    return async (fn) => {
+        if (active >= max)
+            await new Promise((r) => waiting.push(r));
+        else
+            active++;
+        try {
+            return await fn();
+        }
+        finally {
+            const next = waiting.shift();
+            if (next)
+                next();
+            else
+                active--;
+        }
+    };
+}
+async function readLocal(url) {
+    try {
+        const body = await readFile(fileURLToPath(url), 'utf8');
+        return { status: 200, headers: {}, body };
+    }
+    catch {
+        return { status: 404, headers: {}, body: '' };
+    }
+}
+async function atomicWrite(file, data) {
+    const tmp = `${file}.${randomBytes(6).toString('hex')}.tmp`;
+    try {
+        await writeFile(tmp, data);
+        await rename(tmp, file);
+    }
+    catch (err) {
+        await rm(tmp, { force: true });
+        throw err;
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export function createHttp(opts) {
+    const ttl = opts.ttlMs ?? DEFAULT_TTL;
+    const timeoutMs = opts.timeoutMs ?? 15_000;
+    const cacheDir = opts.noCache ? undefined : opts.cacheDir;
+    const limit = limiter(Math.max(1, opts.concurrency));
+    const inflight = new Map();
+    let dirReady;
+    const cacheFile = (url) => join(cacheDir, `${createHash('sha256').update(url).digest('hex')}.json`);
+    async function readCache(url) {
+        if (!cacheDir)
+            return undefined;
+        const file = cacheFile(url);
+        try {
+            const entry = JSON.parse(await readFile(file, 'utf8'));
+            if (Date.now() - entry.time <= ttl) {
+                return { status: entry.status, headers: entry.headers, body: entry.body };
+            }
+            await rm(file, { force: true });
+        }
+        catch {
+            // missing or corrupt entry
+        }
+        return undefined;
+    }
+    async function writeCache(url, res) {
+        if (!cacheDir || (res.status !== 200 && res.status !== 404))
+            return;
+        try {
+            dirReady ??= mkdir(cacheDir, { recursive: true });
+            await dirReady;
+            await atomicWrite(cacheFile(url), JSON.stringify({ ...res, time: Date.now() }));
+        }
+        catch {
+            // cache is best effort
+        }
+    }
+    async function fetchOnce(method, url) {
+        const auth = authHeader(url, opts.credentials);
+        let current = url;
+        for (let i = 0; i <= MAX_REDIRECTS; i++) {
+            const headers = { 'user-agent': opts.userAgent ?? 'jvm-upgrade' };
+            if (auth && sameOrigin(current, url))
+                headers.authorization = auth;
+            const res = await fetch(current, {
+                method,
+                headers,
+                redirect: 'manual',
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            const location = res.headers.get('location');
+            if (res.status >= 300 && res.status < 400 && location) {
+                await res.body?.cancel();
+                current = new URL(location, current).toString();
+                continue;
+            }
+            return {
+                status: res.status,
+                headers: Object.fromEntries(res.headers),
+                body: method === 'HEAD' ? '' : await res.text(),
+            };
+        }
+        throw new Error(`Too many redirects: ${url}`);
+    }
+    async function network(method, url) {
+        return limit(async () => {
+            opts.onRequest?.();
+            try {
+                try {
+                    const res = await fetchOnce(method, url);
+                    if (res.status < 500 && res.status !== 429)
+                        return res;
+                }
+                catch {
+                    // retried below
+                }
+                await sleep(300);
+                return await fetchOnce(method, url);
+            }
+            finally {
+                opts.onResponse?.();
+            }
+        });
+    }
+    async function get(url) {
+        if (url.startsWith('file:'))
+            return readLocal(url);
+        const authed = authHeader(url, opts.credentials) !== undefined;
+        const cached = authed ? undefined : await readCache(url);
+        if (cached)
+            return cached;
+        const res = await network('GET', url);
+        if (!authed)
+            await writeCache(url, res);
+        return res;
+    }
+    return {
+        get(url) {
+            let p = inflight.get(url);
+            if (!p) {
+                p = get(url);
+                inflight.set(url, p);
+                p.catch(() => inflight.delete(url));
+            }
+            return p;
+        },
+        async head(url) {
+            if (url.startsWith('file:'))
+                return readLocal(url);
+            return network('HEAD', url);
+        },
+        async close() {
+            if (!cacheDir)
+                return;
+            const files = await readdir(cacheDir).catch(() => []);
+            const ours = files.filter((f) => f.endsWith('.json') || f.endsWith('.tmp'));
+            await Promise.all(ours.map((f) => pruneFile(join(cacheDir, f), ttl)));
+        },
+    };
+}
+async function pruneFile(file, ttl) {
+    try {
+        if (file.endsWith('.tmp')) {
+            if (Date.now() - (await stat(file)).mtimeMs > ttl)
+                await rm(file, { force: true });
+            return;
+        }
+        const entry = JSON.parse(await readFile(file, 'utf8'));
+        if (Date.now() - entry.time > ttl)
+            await rm(file, { force: true });
+    }
+    catch {
+        await rm(file, { force: true });
+    }
+}

package/dist/main.js

@@ -0,0 +1,279 @@
+import { readFileSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+import { parseArgs, styleText } from 'node:util';
+import { applyEdits, EditConflictError } from './apply.js';
+import { getChangelog } from './changelog.js';
+import { ConfigError, loadCredentials, loadUserConfig, projectConfigResolver, splitPatterns } from './config.js';
+import { formatChangelog, renderTable, toJson } from './format.js';
+import { clearCache, createHttp, defaultCacheDir } from './http.js';
+import { createProgress } from './progress.js';
+import { buildRows } from './rows.js';
+import { scanProject } from './scan/index.js';
+import { TARGETS } from './types.js';
+import { compareVersions } from './version.js';
+export const EXIT = { ok: 0, outdated: 1, usage: 2, parse: 3, network: 4, conflict: 5 };
+const HELP = `Usage: jvm-upgrade [directory] [options]
+
+Find outdated libraries in Gradle and Maven projects and upgrade them.
+
+Actions
+  -u, --upgrade            Write the selected upgrades to the build files
+  -i, --interactive        Pick upgrades (and read changelogs) in a terminal UI
+  -l, --changelog          Print the changelog of every selected upgrade
+
+Policy
+  -t, --target <level>     Highest jump allowed: major, minor or patch (default: major)
+  -c, --cooldown <days>    Skip versions published less than <days> days ago
+      --allow-downgrade    With --cooldown, roll back versions that are too new
+      --pre                Allow prereleases (alpha, beta, rc, ...)
+      --include <pattern>  Only check matching deps, e.g. "com.google.*,org.jetbrains:*"
+      --exclude <pattern>  Skip matching deps
+      --repo <url>         Extra Maven repository to query (repeatable)
+
+Output
+      --format <format>    text or json (default: text)
+      --error-on-outdated  Exit with code 1 when upgrades are available
+      --verbose            Also list dependencies that are up to date
+      --no-progress        Hide progress bars
+
+Network
+      --concurrency <n>    Parallel HTTP requests (default: 8)
+      --no-cache           Do not use the metadata cache
+      --clear-cache        Delete the metadata cache first
+
+  -h, --help               Show this help
+  -v, --version            Show the version
+`;
+export function fail(code, message) {
+    process.stderr.write(`${styleText('red', 'error')} ${message}\n`);
+    process.exit(code);
+}
+function parseCli(argv) {
+    try {
+        return parseArgs({
+            args: argv,
+            allowPositionals: true,
+            allowNegative: true,
+            options: {
+                upgrade: { type: 'boolean', short: 'u' },
+                interactive: { type: 'boolean', short: 'i' },
+                changelog: { type: 'boolean', short: 'l' },
+                target: { type: 'string', short: 't' },
+                cooldown: { type: 'string', short: 'c' },
+                'allow-downgrade': { type: 'boolean' },
+                pre: { type: 'boolean' },
+                include: { type: 'string', multiple: true },
+                exclude: { type: 'string', multiple: true },
+                repo: { type: 'string', multiple: true },
+                format: { type: 'string' },
+                'error-on-outdated': { type: 'boolean' },
+                verbose: { type: 'boolean' },
+                progress: { type: 'boolean', default: true },
+                concurrency: { type: 'string' },
+                cache: { type: 'boolean', default: true },
+                'clear-cache': { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+                version: { type: 'boolean', short: 'v' },
+            },
+        });
+    }
+    catch (e) {
+        fail(EXIT.usage, `${e.message}\nRun jvm-upgrade --help for usage.`);
+    }
+}
+function parseInteger(name, value, min) {
+    if (value === undefined)
+        return undefined;
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < min)
+        fail(EXIT.usage, `--${name} must be an integer >= ${min}`);
+    return n;
+}
+export async function main(argv = process.argv.slice(2)) {
+    const { values: flags, positionals } = parseCli(argv);
+    if (flags.help) {
+        process.stdout.write(HELP);
+        return EXIT.ok;
+    }
+    if (flags.version) {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        process.stdout.write(`${pkg.version}\n`);
+        return EXIT.ok;
+    }
+    if (positionals.length > 1)
+        fail(EXIT.usage, 'only one directory can be given');
+    if (flags.target && !TARGETS.includes(flags.target))
+        fail(EXIT.usage, '--target must be major, minor or patch');
+    if (flags.format && flags.format !== 'text' && flags.format !== 'json')
+        fail(EXIT.usage, '--format must be text or json');
+    const json = flags.format === 'json';
+    if (json && flags.interactive)
+        fail(EXIT.usage, '--interactive cannot be used with --format json');
+    if (flags.interactive && !(process.stdin.isTTY && process.stdout.isTTY))
+        fail(EXIT.usage, '--interactive needs a terminal');
+    const root = resolve(positionals[0] ?? '.');
+    if (!(await stat(root).catch(() => undefined))?.isDirectory())
+        fail(EXIT.usage, `${root} is not a directory`);
+    let user;
+    let credentials;
+    try {
+        user = await loadUserConfig();
+        credentials = await loadCredentials();
+    }
+    catch (e) {
+        if (e instanceof ConfigError)
+            fail(EXIT.usage, e.message);
+        throw e;
+    }
+    const cooldown = parseInteger('cooldown', flags.cooldown, 0);
+    const concurrency = parseInteger('concurrency', flags.concurrency, 1) ?? user.concurrency;
+    const cli = {
+        ...(flags.target && { target: flags.target }),
+        ...(cooldown !== undefined && { cooldown }),
+        ...(flags['allow-downgrade'] !== undefined && { allowDowngrade: flags['allow-downgrade'] }),
+        ...(flags.pre !== undefined && { pre: flags.pre }),
+        ...(flags.include && { include: splitPatterns(flags.include) }),
+        ...(flags.exclude && { exclude: splitPatterns(flags.exclude) }),
+    };
+    const resolveBase = projectConfigResolver(root, user);
+    const optionsFor = async (file) => ({ ...(await resolveBase(file)), ...cli });
+    const rootOptions = await optionsFor(resolve(root, 'build.gradle')).catch((e) => {
+        if (e instanceof ConfigError)
+            fail(EXIT.usage, e.message);
+        throw e;
+    });
+    if (rootOptions.allowDowngrade && !rootOptions.cooldown)
+        fail(EXIT.usage, '--allow-downgrade needs --cooldown');
+    const cacheDir = user.cacheDir ?? defaultCacheDir();
+    if (flags['clear-cache'])
+        await clearCache(cacheDir);
+    const showProgress = flags.progress && process.stderr.isTTY;
+    const log = (text) => process.stderr.write(`${text}\n`);
+    let scan;
+    try {
+        scan = await scanProject(root);
+    }
+    catch (e) {
+        fail(EXIT.parse, `could not read the project: ${e.message}`);
+    }
+    for (const warning of scan.warnings)
+        log(styleText('yellow', `warning: ${warning}`));
+    if (!scan.dependencies.length) {
+        log('No Gradle or Maven dependencies found.');
+        if (json)
+            process.stdout.write('[]\n');
+        return EXIT.ok;
+    }
+    const progress = createProgress('Checking versions', process.stderr, showProgress);
+    const http = createHttp({ credentials, concurrency, cacheDir, noCache: !flags.cache || user.noCache });
+    try {
+        let rows;
+        try {
+            rows = await buildRows(scan.dependencies, {
+                http,
+                optionsFor,
+                extraRepositories: flags.repo ?? [],
+                progress,
+                now: new Date(),
+            });
+        }
+        catch (e) {
+            if (e instanceof ConfigError)
+                fail(EXIT.usage, e.message);
+            throw e;
+        }
+        finally {
+            progress.done();
+        }
+        rows.sort((a, b) => a.name.localeCompare(b.name));
+        const nameCount = new Map();
+        for (const row of rows)
+            nameCount.set(row.name, (nameCount.get(row.name) ?? 0) + 1);
+        for (const row of rows)
+            if (nameCount.get(row.name) > 1)
+                row.name += `  (${relative(root, row.deps[0].file)})`;
+        const outdated = rows.filter((r) => r.choices.length);
+        const failed = rows.filter((r) => !r.choices.length && r.errors.length);
+        const failedAll = rows.length > 0 && failed.length === rows.length;
+        const visible = flags.verbose ? rows : [...outdated, ...failed];
+        if (json) {
+            process.stdout.write(`${JSON.stringify(toJson(visible, root), null, 2)}\n`);
+        }
+        else if (!flags.interactive) {
+            if (visible.length)
+                log(renderTable(visible, root));
+            if (!outdated.length)
+                log(styleText('green', `All ${rows.length - failed.length} dependencies are up to date.`));
+        }
+        if (failedAll)
+            return EXIT.network;
+        if (!outdated.length)
+            return EXIT.ok;
+        let chosen;
+        if (flags.interactive) {
+            const picked = await (await import('./tui.js')).pick(outdated, (row, choice) => loadChangelog(http, row, choice));
+            if (!picked) {
+                log('Cancelled. Nothing was changed.');
+                return EXIT.ok;
+            }
+            chosen = picked;
+        }
+        else {
+            chosen = new Map();
+            for (const row of outdated) {
+                const choice = row.selected === undefined ? undefined : row.choices[row.selected];
+                if (choice)
+                    chosen.set(row, choice);
+            }
+        }
+        if (flags.changelog && !json)
+            await printChangelogs(http, chosen, showProgress);
+        const writable = [...chosen].filter(([row]) => row.location);
+        if (flags.upgrade || flags.interactive) {
+            if (!writable.length) {
+                log('Nothing to upgrade.');
+                return EXIT.ok;
+            }
+            const edits = writable.map(([row, choice]) => ({ location: row.location, from: row.current, to: choice.version }));
+            try {
+                await applyEdits(edits);
+            }
+            catch (e) {
+                if (e instanceof EditConflictError)
+                    fail(EXIT.conflict, e.message);
+                throw e;
+            }
+            for (const [row, choice] of writable)
+                log(`${styleText('green', '✔')} ${row.name} ${row.current} → ${choice.version}`);
+            log(styleText('gray', 'Build files updated. Run your build and tests to check the upgrades.'));
+            return EXIT.ok;
+        }
+        if (!json) {
+            const target = rootOptions.target;
+            log(styleText('gray', `\nRun ${styleText('cyan', 'jvm-upgrade -u')} to apply the underlined versions (target: ${target}), or ${styleText('cyan', 'jvm-upgrade -i')} to pick.`));
+        }
+        return flags['error-on-outdated'] ? EXIT.outdated : EXIT.ok;
+    }
+    finally {
+        await http.close();
+    }
+}
+function loadChangelog(http, row, choice) {
+    const dep = row.deps[0];
+    return getChangelog(http, dep, row.current, choice.version, row.repoOf.get(choice.version), compareVersions);
+}
+async function printChangelogs(http, chosen, showProgress) {
+    const entries = [...chosen];
+    const progress = createProgress('Loading changelogs', process.stderr, showProgress);
+    progress.total(entries.length);
+    const logs = await Promise.all(entries.map(([row, choice]) => loadChangelog(http, row, choice)
+        .catch((e) => ({ entries: [], source: `could not load: ${e.message}` }))
+        .finally(() => progress.tick())));
+    progress.done();
+    const width = Math.min(process.stdout.columns ?? 100, 120) - 2;
+    entries.forEach(([row, choice], i) => {
+        process.stdout.write(`\n${styleText(['bold', 'underline'], `${row.name}  ${row.current} → ${choice.version}`)}\n\n`);
+        process.stdout.write(`${formatChangelog(logs[i], width)}\n`);
+    });
+}

package/dist/policy.js

@@ -0,0 +1,58 @@
+import { compareVersions, isPrerelease, isSnapshot, upgradeLevel } from './version.js';
+const DAY_MS = 86_400_000;
+const RANK = { patch: 0, minor: 1, major: 2 };
+export async function selectCandidates(current, versions, opts, publishedAt) {
+    const allowSnapshot = isSnapshot(current);
+    const allowPre = opts.pre || isPrerelease(current);
+    const allowed = [...new Set(versions)]
+        .filter((v) => (allowSnapshot || !isSnapshot(v)) && (allowPre || !isPrerelease(v)))
+        .sort((a, b) => compareVersions(b, a));
+    const memo = new Map();
+    const cutoff = opts.now.getTime() - opts.cooldownDays * DAY_MS;
+    const passes = (v) => {
+        if (opts.cooldownDays <= 0)
+            return Promise.resolve(true);
+        let p = memo.get(v);
+        if (!p) {
+            p = publishedAt(v).then((d) => !d || d.getTime() <= cutoff);
+            memo.set(v, p);
+        }
+        return p;
+    };
+    const firstPassing = async (list) => {
+        for (const v of list)
+            if (await passes(v))
+                return v;
+        return undefined;
+    };
+    const upgrades = allowed
+        .map((v) => ({ v, level: upgradeLevel(current, v) }))
+        .filter((c) => c.level !== undefined);
+    const upTo = (t) => upgrades.filter((c) => RANK[c.level] <= RANK[t]).map((c) => c.v);
+    const result = {};
+    for (const t of ['major', 'minor', 'patch']) {
+        const v = await firstPassing(upTo(t));
+        if (v)
+            result[t] = v;
+    }
+    if (opts.allowDowngrade && opts.cooldownDays > 0 && !result.major && !(await passes(current))) {
+        const v = await firstPassing(allowed.filter((x) => compareVersions(x, current) < 0));
+        if (v)
+            result.downgrade = v;
+    }
+    return result;
+}
+export function pick(c, target) {
+    if (target === 'major')
+        return c.major ?? c.minor ?? c.patch;
+    if (target === 'minor')
+        return c.minor ?? c.patch;
+    return c.patch;
+}
+export function intersectVersions(lists) {
+    const [first, ...rest] = lists;
+    if (!first)
+        return [];
+    const sets = rest.map((l) => new Set(l));
+    return [...new Set(first)].filter((v) => sets.every((s) => s.has(v)));
+}

package/dist/progress.js

@@ -0,0 +1,37 @@
+import { styleText } from 'node:util';
+const WIDTH = 28;
+const FRAME_MS = 80;
+export function createProgress(label, stream = process.stderr, enabled = stream.isTTY) {
+    if (!enabled)
+        return { total() { }, tick() { }, done() { } };
+    let total = 0;
+    let count = 0;
+    let last = 0;
+    let finished = false;
+    const draw = (force = false) => {
+        const now = Date.now();
+        if (!force && now - last < FRAME_MS)
+            return;
+        last = now;
+        const ratio = total ? Math.min(count / total, 1) : 0;
+        const filled = Math.round(ratio * WIDTH);
+        const bar = styleText('cyan', '█'.repeat(filled)) + styleText('gray', '░'.repeat(WIDTH - filled));
+        stream.write(`\r\x1b[2K${label} ${bar} ${count}/${total}`);
+    };
+    return {
+        total(n) {
+            total += n;
+            draw();
+        },
+        tick() {
+            count++;
+            draw(count === total);
+        },
+        done() {
+            if (finished)
+                return;
+            finished = true;
+            stream.write('\r\x1b[2K');
+        },
+    };
+}