jvm-upgrade 0.1.0

package/dist/scan/index.js

@@ -0,0 +1,65 @@
+import { readdir } from 'node:fs/promises';
+import { basename, dirname, join, resolve, sep } from 'node:path';
+import { scanGradle } from './gradle.js';
+import { scanMaven } from './maven.js';
+const SKIP_DIRS = new Set(['build', 'node_modules', 'target', 'out', 'bin', 'intermediates']);
+const SETTINGS = new Set(['settings.gradle', 'settings.gradle.kts']);
+const BUILD_FILES = new Set(['build.gradle', 'build.gradle.kts']);
+async function walk(dir, files) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    await Promise.all(entries.map(async (entry) => {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!entry.name.startsWith('.') && !SKIP_DIRS.has(entry.name))
+                await walk(path, files);
+        }
+        else if (SETTINGS.has(entry.name) || BUILD_FILES.has(entry.name) || entry.name === 'pom.xml') {
+            files.push(path);
+        }
+    }));
+}
+function isUnder(dir, root) {
+    return dir === root || dir.startsWith(root + sep);
+}
+function depth(path) {
+    return path.split(sep).length;
+}
+export function groupGradleBuilds(files) {
+    const builds = new Map();
+    for (const file of files.filter((f) => SETTINGS.has(basename(f)))) {
+        builds.set(dirname(file), { root: dirname(file), settings: file, buildFiles: [] });
+    }
+    const buildFiles = files.filter((f) => BUILD_FILES.has(basename(f))).sort((a, b) => depth(a) - depth(b));
+    for (const file of buildFiles) {
+        const dir = dirname(file);
+        const owner = [...builds.keys()].filter((root) => isUnder(dir, root)).sort((a, b) => b.length - a.length)[0];
+        const root = owner && basename(dir) !== 'buildSrc' ? owner : dir;
+        if (!builds.has(root))
+            builds.set(root, { root, buildFiles: [] });
+        builds.get(root).buildFiles.push(file);
+    }
+    return [...builds.values()];
+}
+function dedupe(deps) {
+    const seen = new Map();
+    for (const dep of deps) {
+        const where = dep.location ? `${dep.location.file}:${dep.location.start}` : `${dep.file}:${dep.version}`;
+        const key = `${dep.kind}|${dep.group}|${dep.artifact}|${where}`;
+        if (!seen.has(key))
+            seen.set(key, dep);
+    }
+    return [...seen.values()];
+}
+export async function scanProject(root) {
+    const files = [];
+    await walk(resolve(root), files);
+    files.sort();
+    const results = await Promise.all([
+        ...groupGradleBuilds(files).map(scanGradle),
+        scanMaven(files.filter((f) => basename(f) === 'pom.xml')),
+    ]);
+    return {
+        dependencies: dedupe(results.flatMap((r) => r.dependencies)),
+        warnings: [...new Set(results.flatMap((r) => r.warnings))],
+    };
+}

package/dist/scan/maven.js

@@ -0,0 +1,201 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { isDynamic } from './gradle.js';
+import { dedupeRepos, MAVEN_CENTRAL } from './repos.js';
+const TAG_RE = /<(\/?)([\w.\-:]+)(?:\s[^>]*?)?(\/?)>/g;
+const SELF_VERSION_RE = /\$\{(?:project\.|pom\.)?(?:parent\.)?version\}/;
+export function stripXmlComments(src) {
+    return src.replace(/<!--[\s\S]*?-->/g, (c) => c.replace(/[^\n]/g, ' '));
+}
+export function parseXml(code) {
+    const root = { name: '#root', children: [], textStart: 0, textEnd: code.length };
+    const stack = [root];
+    for (const m of code.matchAll(TAG_RE)) {
+        const [tag, closing, name, selfClosing] = m;
+        const top = stack[stack.length - 1];
+        if (closing) {
+            const idx = stack.map((n) => n.name).lastIndexOf(name);
+            if (idx > 0) {
+                stack[idx].textEnd = m.index;
+                stack.length = idx;
+            }
+            continue;
+        }
+        const start = m.index + tag.length;
+        const node = { name: name, parent: top, children: [], textStart: start, textEnd: start };
+        top.children.push(node);
+        if (!selfClosing)
+            stack.push(node);
+    }
+    return root;
+}
+function child(node, name) {
+    return node?.children.find((c) => c.name === name);
+}
+function findAll(node, name, parentName) {
+    const out = [];
+    const visit = (n) => {
+        for (const c of n.children) {
+            if (c.name === name && n.name === parentName)
+                out.push(c);
+            visit(c);
+        }
+    };
+    visit(node);
+    return out;
+}
+function textOf(pom, node) {
+    if (!node || node.children.length)
+        return undefined;
+    const raw = pom.code.slice(node.textStart, node.textEnd);
+    const value = raw.trim();
+    if (!value)
+        return undefined;
+    const start = node.textStart + raw.indexOf(value);
+    return { value, loc: { file: pom.file, start, end: start + value.length } };
+}
+function childText(pom, node, name) {
+    return textOf(pom, child(node, name))?.value;
+}
+async function loadPom(file) {
+    let content;
+    try {
+        content = await readFile(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const code = stripXmlComments(content);
+    const project = child(parseXml(code), 'project');
+    if (!project)
+        return undefined;
+    const pom = { file, code, project, props: new Map(), parent: child(project, 'parent') };
+    pom.artifactId = childText(pom, project, 'artifactId');
+    pom.groupId = childText(pom, project, 'groupId') ?? childText(pom, pom.parent, 'groupId');
+    pom.version = childText(pom, project, 'version') ?? childText(pom, pom.parent, 'version');
+    for (const prop of child(project, 'properties')?.children ?? []) {
+        const value = textOf(pom, prop);
+        if (value)
+            pom.props.set(prop.name, value);
+    }
+    return pom;
+}
+class PomTree {
+    cache = new Map();
+    load(file) {
+        let pom = this.cache.get(file);
+        if (!pom)
+            this.cache.set(file, (pom = loadPom(file)));
+        return pom;
+    }
+    async chain(pom) {
+        const chain = [pom];
+        for (let current = pom; current.parent;) {
+            const relative = child(current.parent, 'relativePath');
+            const rel = relative ? (textOf(current, relative)?.value ?? '') : '../pom.xml';
+            if (!rel)
+                break;
+            const path = resolve(dirname(current.file), rel);
+            const parent = await this.load(path.endsWith('.xml') ? path : join(path, 'pom.xml'));
+            if (!parent || chain.includes(parent) || parent.artifactId !== childText(current, current.parent, 'artifactId'))
+                break;
+            chain.push(parent);
+            current = parent;
+        }
+        return chain;
+    }
+}
+function lookup(chain, key) {
+    const pom = chain[0];
+    if (/^(?:project|pom)\.groupId$/.test(key) && pom.groupId)
+        return { value: pom.groupId };
+    if (/^(?:project|pom)\.artifactId$/.test(key) && pom.artifactId)
+        return { value: pom.artifactId };
+    for (const p of chain) {
+        const value = p.props.get(key);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function resolveValue(raw, loc, chain, depth = 0) {
+    if (depth > 5 || SELF_VERSION_RE.test(raw))
+        return undefined;
+    const whole = /^\$\{([^}]+)\}$/.exec(raw);
+    if (whole) {
+        const found = lookup(chain, whole[1]);
+        if (!found)
+            return undefined;
+        return found.value.includes('${') ? resolveValue(found.value, undefined, chain, depth + 1) : found;
+    }
+    if (!raw.includes('${'))
+        return { value: raw, loc };
+    let ok = true;
+    const value = raw.replace(/\$\{([^}]+)\}/g, (_, key) => {
+        const found = resolveValue(`\${${key}}`, undefined, chain, depth + 1);
+        if (!found)
+            ok = false;
+        return found?.value ?? '';
+    });
+    return ok ? { value } : undefined;
+}
+function repoUrls(pom, chain, name, parentName) {
+    return findAll(pom.project, name, parentName)
+        .map((repo) => childText(pom, repo, 'url'))
+        .map((url) => url && resolveValue(url, undefined, chain)?.value)
+        .filter((url) => !!url && !url.includes('${'));
+}
+function coordinates(pom) {
+    return [
+        ...findAll(pom.project, 'dependency', 'dependencies').map((node) => ({ node, kind: 'library' })),
+        ...findAll(pom.project, 'plugin', 'plugins').map((node) => ({
+            node,
+            kind: 'plugin',
+            defaultGroup: 'org.apache.maven.plugins',
+        })),
+        ...findAll(pom.project, 'extension', 'extensions').map((node) => ({ node, kind: 'plugin' })),
+        ...(pom.parent ? [{ node: pom.parent, kind: 'library' }] : []),
+    ];
+}
+export async function scanMaven(pomFiles) {
+    const tree = new PomTree();
+    const poms = (await Promise.all(pomFiles.map((f) => tree.load(f)))).filter((p) => !!p);
+    const modules = new Set(poms.map((p) => `${p.groupId}:${p.artifactId}`));
+    const warnings = [];
+    const dependencies = [];
+    for (const pom of poms) {
+        const chain = await tree.chain(pom);
+        const libraryRepos = dedupeRepos([...chain.flatMap((p) => repoUrls(p, chain, 'repository', 'repositories')), MAVEN_CENTRAL]);
+        const pluginRepos = dedupeRepos([
+            ...chain.flatMap((p) => repoUrls(p, chain, 'pluginRepository', 'pluginRepositories')),
+            MAVEN_CENTRAL,
+        ]);
+        for (const { node, kind, defaultGroup } of coordinates(pom)) {
+            const rawGroup = childText(pom, node, 'groupId') ?? defaultGroup;
+            const rawArtifact = childText(pom, node, 'artifactId');
+            const versionText = textOf(pom, child(node, 'version'));
+            if (!rawGroup || !rawArtifact || !versionText)
+                continue;
+            const group = resolveValue(rawGroup, undefined, chain)?.value;
+            const artifact = resolveValue(rawArtifact, undefined, chain)?.value;
+            if (!group || !artifact || modules.has(`${group}:${artifact}`) || SELF_VERSION_RE.test(versionText.value))
+                continue;
+            const version = resolveValue(versionText.value, versionText.loc, chain);
+            if (!version) {
+                warnings.push(`${pom.file}: cannot resolve version "${versionText.value}" of ${group}:${artifact}`);
+                continue;
+            }
+            const location = version.loc && !isDynamic(version.value) ? version.loc : undefined;
+            dependencies.push({
+                group,
+                artifact,
+                kind,
+                version: version.value,
+                file: pom.file,
+                repositories: kind === 'plugin' ? pluginRepos : libraryRepos,
+                ...(location && { location }),
+            });
+        }
+    }
+    return { dependencies, warnings };
+}

package/dist/scan/repos.js

@@ -0,0 +1,30 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+export const MAVEN_CENTRAL = 'https://repo.maven.apache.org/maven2/';
+export const GOOGLE = 'https://dl.google.com/dl/android/maven2/';
+export const GRADLE_PLUGIN_PORTAL = 'https://plugins.gradle.org/m2/';
+export const JITPACK = 'https://jitpack.io/';
+export const JCENTER = 'https://jcenter.bintray.com/';
+export function mavenLocal() {
+    return withSlash(pathToFileURL(join(homedir(), '.m2', 'repository')).href);
+}
+export const NAMED_REPOS = {
+    mavenCentral: () => MAVEN_CENTRAL,
+    google: () => GOOGLE,
+    gradlePluginPortal: () => GRADLE_PLUGIN_PORTAL,
+    jcenter: () => JCENTER,
+    mavenLocal,
+};
+export function withSlash(url) {
+    return url.endsWith('/') ? url : `${url}/`;
+}
+export function dedupeRepos(urls) {
+    const out = new Set();
+    for (const url of urls) {
+        const normalized = withSlash(url.trim());
+        if (normalized !== JCENTER)
+            out.add(normalized);
+    }
+    return [...out];
+}

package/dist/tui.js

@@ -0,0 +1,165 @@
+import { emitKeypressEvents } from 'node:readline';
+import { styleText } from 'node:util';
+import { formatChangelog } from './format.js';
+import { levelColor } from './rows.js';
+export function initialState(rows) {
+    return { cursor: 0, choice: rows.map((r) => (r.selected === undefined ? null : r.selected)) };
+}
+/** Pure key handling so the picker logic is testable without a terminal. */
+export function reduce(state, rows, key) {
+    const { cursor } = state;
+    const row = rows[cursor];
+    const choice = [...state.choice];
+    const n = row?.choices.length ?? 0;
+    switch (key) {
+        case 'up':
+            return { ...state, cursor: Math.max(0, cursor - 1) };
+        case 'down':
+            return { ...state, cursor: Math.min(rows.length - 1, cursor + 1) };
+        case 'left':
+            if (!row?.location || n === 0)
+                return state;
+            choice[cursor] = choice[cursor] === null ? n - 1 : choice[cursor] - 1 < 0 ? null : choice[cursor] - 1;
+            return { ...state, choice };
+        case 'right':
+            if (!row?.location || n === 0)
+                return state;
+            choice[cursor] = choice[cursor] === null ? 0 : choice[cursor] + 1 >= n ? null : choice[cursor] + 1;
+            return { ...state, choice };
+        case 'space':
+            if (!row?.location || n === 0)
+                return state;
+            choice[cursor] = choice[cursor] === null ? (row.selected ?? n - 1) : null;
+            return { ...state, choice };
+        case 'all': {
+            const anySelected = choice.some((c) => c !== null);
+            return { ...state, choice: rows.map((r) => (anySelected || !r.location || !r.choices.length ? null : (r.selected ?? r.choices.length - 1))) };
+        }
+        case 'enter':
+            return 'submit';
+        case 'cancel':
+            return 'cancel';
+        default:
+            return state;
+    }
+}
+const KEYMAP = {
+    up: 'up', k: 'up', down: 'down', j: 'down', left: 'left', h: 'left', right: 'right', l: 'right',
+    space: 'space', a: 'all', return: 'enter', enter: 'enter', escape: 'cancel', q: 'cancel', c: 'changelog',
+    pageup: 'pageup', pagedown: 'pagedown',
+};
+export async function pick(rows, loadChangelog) {
+    const input = process.stdin;
+    const out = process.stdout;
+    let state = initialState(rows);
+    let view;
+    let busy = false;
+    emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    out.write('\x1b[?1049h\x1b[?25l');
+    const render = () => {
+        const height = out.rows ?? 24;
+        const width = out.columns ?? 80;
+        const body = view ? renderView(view, height, width) : renderList(rows, state, height, width, busy);
+        out.write(`\x1b[H\x1b[2J${body}`);
+    };
+    const onResize = () => render();
+    out.on('resize', onResize);
+    return new Promise((resolvePick) => {
+        const finish = (result) => {
+            input.off('keypress', onKey);
+            out.off('resize', onResize);
+            input.setRawMode(false);
+            input.pause();
+            out.write('\x1b[?25h\x1b[?1049l');
+            resolvePick(result);
+        };
+        const onKey = (_, key) => {
+            if (key.ctrl && key.name === 'c')
+                return finish(undefined);
+            const action = KEYMAP[key.name ?? key.sequence ?? ''];
+            if (!action)
+                return;
+            if (view) {
+                const page = Math.max(1, (out.rows ?? 24) - 3);
+                if (action === 'up')
+                    view.top = Math.max(0, view.top - 1);
+                else if (action === 'down')
+                    view.top = Math.min(Math.max(0, view.lines.length - page), view.top + 1);
+                else if (action === 'pageup')
+                    view.top = Math.max(0, view.top - page);
+                else if (action === 'pagedown')
+                    view.top = Math.min(Math.max(0, view.lines.length - page), view.top + page);
+                else if (action === 'cancel' || action === 'left' || action === 'changelog')
+                    view = undefined;
+                return render();
+            }
+            if (action === 'changelog') {
+                const row = rows[state.cursor];
+                const index = state.choice[state.cursor] ?? row?.selected ?? (row ? row.choices.length - 1 : -1);
+                const choice = row?.choices[index];
+                if (!row || !choice || busy)
+                    return;
+                busy = true;
+                render();
+                loadChangelog(row, choice)
+                    .then((log) => formatChangelog(log, (out.columns ?? 80) - 2).split('\n'))
+                    .catch((e) => [`Could not load the changelog: ${e.message}`])
+                    .then((lines) => {
+                    busy = false;
+                    view = { lines, top: 0, title: `${row.name}  ${row.current} → ${choice.version}` };
+                    render();
+                });
+                return;
+            }
+            const next = reduce(state, rows, action);
+            if (next === 'cancel')
+                return finish(undefined);
+            if (next === 'submit') {
+                const result = new Map();
+                state.choice.forEach((c, i) => {
+                    const row = rows[i];
+                    const choice = c === null ? undefined : row?.choices[c];
+                    if (row && choice)
+                        result.set(row, choice);
+                });
+                return finish(result);
+            }
+            state = next;
+            render();
+        };
+        input.on('keypress', onKey);
+        render();
+    });
+}
+function renderList(rows, state, height, width, busy) {
+    const header = styleText('bold', 'Choose upgrades') + styleText('gray', '  ↑↓ move  ←→ version  space toggle  a all  c changelog  enter apply  q quit');
+    const visible = Math.max(1, height - 3);
+    const top = Math.min(Math.max(0, state.cursor - Math.floor(visible / 2)), Math.max(0, rows.length - visible));
+    const nameWidth = Math.min(Math.max(...rows.map((r) => r.name.length), 4), Math.max(20, width - 40));
+    const lines = rows.slice(top, top + visible).map((row, i) => {
+        const index = top + i;
+        const active = index === state.cursor;
+        const c = state.choice[index] ?? null;
+        const mark = c === null ? '○' : styleText('green', '●');
+        const name = truncate(row.name, nameWidth).padEnd(nameWidth);
+        const options = row.location
+            ? row.choices.map((ch, j) => (j === c ? styleText(['inverse', levelColor(ch.level)], ` ${ch.version} `) : styleText(levelColor(ch.level), ` ${ch.version} `))).join(' ')
+            : styleText('gray', `${row.choices.at(-1)?.version ?? ''} (not rewritable)`);
+        const line = `${active ? styleText('cyan', '❯') : ' '} ${mark} ${active ? styleText('bold', name) : name}  ${row.current.padEnd(12)} ${options}`;
+        return line;
+    });
+    const footer = busy ? styleText('yellow', 'Loading changelog…') : styleText('gray', `${state.choice.filter((c) => c !== null).length} of ${rows.length} selected`);
+    return [header, '', ...lines, footer].join('\n');
+}
+function renderView(view, height, width) {
+    const page = Math.max(1, height - 3);
+    const header = styleText('bold', truncate(view.title, width - 30)) + styleText('gray', '  ↑↓ scroll  q back');
+    const body = view.lines.slice(view.top, view.top + page);
+    const footer = styleText('gray', `${Math.min(view.top + page, view.lines.length)}/${view.lines.length}`);
+    return [header, '', ...body, footer].join('\n');
+}
+function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 1))}…`;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export const TARGETS = ['patch', 'minor', 'major'];

package/dist/version.js

@@ -0,0 +1,73 @@
+const SPECIAL = { dev: -1, rc: 1, snapshot: 2, final: 3, ga: 4, release: 5, sp: 6 };
+const PRERELEASE = new Set([
+    'alpha', 'a', 'beta', 'b', 'milestone', 'm', 'rc', 'cr', 'eap', 'dev', 'snapshot', 'preview', 'pre',
+    'canary', 'incubating', 'ea', 'nightly', 'experimental',
+]);
+const isNum = (s) => /^\d+$/.test(s);
+export function tokenize(v) {
+    return v.toLowerCase().replace(/^v(?=\d)/, '').match(/\d+|[^\d._\-+]+/g) ?? [];
+}
+function compareNumeric(a, b) {
+    const x = a.replace(/^0+(?=\d)/, '');
+    const y = b.replace(/^0+(?=\d)/, '');
+    return x.length - y.length || (x < y ? -1 : x > y ? 1 : 0);
+}
+function compareParts(a, b) {
+    const an = isNum(a);
+    const bn = isNum(b);
+    if (an && bn)
+        return compareNumeric(a, b);
+    if (an !== bn)
+        return an ? 1 : -1;
+    const sa = SPECIAL[a] ?? 0;
+    const sb = SPECIAL[b] ?? 0;
+    if (sa !== sb)
+        return sa - sb;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export function compareVersions(a, b) {
+    const pa = tokenize(a);
+    const pb = tokenize(b);
+    for (let i = 0; i < Math.min(pa.length, pb.length); i++) {
+        const c = compareParts(pa[i], pb[i]);
+        if (c !== 0)
+            return Math.sign(c);
+    }
+    if (pa.length === pb.length)
+        return 0;
+    const [extra, sign] = pa.length > pb.length ? [pa[pb.length], 1] : [pb[pa.length], -1];
+    return isNum(extra) ? sign : -sign;
+}
+export function isSnapshot(v) {
+    return tokenize(v).includes('snapshot');
+}
+export function isPrerelease(v) {
+    return tokenize(v).some((t) => PRERELEASE.has(t));
+}
+export function isDynamic(v) {
+    const s = v.trim();
+    return /^[[(]/.test(s) || /[\])]$/.test(s) || s.endsWith('+') || /^latest\./i.test(s) || /^(LATEST|RELEASE)$/.test(s);
+}
+export function upgradeLevel(from, to) {
+    if (compareVersions(to, from) <= 0)
+        return undefined;
+    const f = tokenize(from);
+    const t = tokenize(to);
+    const part = (p, i) => p[i] ?? '0';
+    if (compareParts(part(f, 0), part(t, 0)) !== 0)
+        return 'major';
+    if (compareParts(part(f, 1), part(t, 1)) !== 0)
+        return 'minor';
+    return 'patch';
+}
+/** JitPack often has both "v1.2" and "1.2" for one tag. Keep the style the project already uses. */
+export function preferStyle(current, versions) {
+    const prefixed = /^v\d/i.test(current);
+    const all = new Set(versions);
+    return versions.filter((v) => {
+        const hasV = /^v\d/i.test(v);
+        if (hasV === prefixed)
+            return true;
+        return !all.has(hasV ? v.slice(1) : `v${v}`);
+    });
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "jvm-upgrade",
+  "version": "0.1.0",
+  "description": "Find and apply library upgrades in Java, Kotlin and Android projects (Gradle and Maven), with changelogs.",
+  "type": "module",
+  "bin": {
+    "jvm-upgrade": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.12"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "keywords": [
+    "gradle",
+    "maven",
+    "android",
+    "kotlin",
+    "java",
+    "dependencies",
+    "upgrade",
+    "outdated",
+    "version-catalog",
+    "changelog",
+    "jitpack",
+    "cli"
+  ],
+  "author": "Theofilos Chamalis",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Theofilos-Chamalis/jvm-upgrade.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Theofilos-Chamalis/jvm-upgrade/issues"
+  },
+  "homepage": "https://github.com/Theofilos-Chamalis/jvm-upgrade#readme",
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.2"
+  }
+}