rman 2.25.2 → 2.26.0

package/builtins/platforms/node/node-dependency-updater.d.ts

@@ -90,6 +90,15 @@ export declare class NodeDependencyUpdater implements DependencyUpdater {
     /** The in-repo packages `pkg` declares a dependency on. */
     protected siblingsOf(pkg: Package, repoPackages: ReadonlyMap<string, Package>): Package[];
     protected toEntry(d: NodeDependencyUpdater.Decision): DependencyUpdater.Entry;
+    /**
+     * The version of `name` that `pkg` resolves today: the first `node_modules/<name>/package.json`
+     * walking up from its directory, which is Node's own lookup - so a hoisted copy at a monorepo's
+     * root counts, and a nested one under the package wins over it.
+     */
+    protected installedVersion(pkg: Package, name: string): string | undefined;
+    /** The newest release `range` takes, as npm's install would pick it: no prerelease unless the
+     *  range asks for one, nothing above the `latest` tag, a deprecated one only when nothing else is. */
+    protected resolvedVersion(d: NodeDependencyUpdater.Decision, range: string): string | undefined;
     protected manifestFile(pkg: Package): string;
     /** `fn` over `items`, at most `limit` at a time. */
     protected mapConcurrent<T>(items: readonly T[], limit: number, fn: (item: T) => Promise<void>): Promise<void>;

package/builtins/platforms/node/node-dependency-updater.js

@@ -64,7 +64,15 @@ export class NodeDependencyUpdater {
         for (const d of decisions)
             this.prepare(d, registry.get(d.name));
         this.resolve(decisions, ctx);
-        return decisions.filter(d => d.wanted || d.unmovable).map(d => this.toEntry(d));
+        return decisions
+            .filter(d => d.wanted || d.unmovable)
+            .map(d => {
+            /** Set on the entry itself, never a copy: `planned` is keyed by that object. */
+            const entry = this.toEntry(d);
+            entry.installed = this.installedVersion(d.pkg, d.name);
+            entry.resolved = this.resolvedVersion(d, entry.current);
+            return entry;
+        });
     }
     async applyPlan(ctx, plan) {
         const originals = new Map();
@@ -506,6 +514,41 @@ export class NodeDependencyUpdater {
         this.planned.set(result, d);
         return result;
     }
+    /**
+     * The version of `name` that `pkg` resolves today: the first `node_modules/<name>/package.json`
+     * walking up from its directory, which is Node's own lookup - so a hoisted copy at a monorepo's
+     * root counts, and a nested one under the package wins over it.
+     */
+    installedVersion(pkg, name) {
+        let dir = pkg.dirname;
+        for (;;) {
+            const file = path.join(dir, 'node_modules', name, 'package.json');
+            if (fs.existsSync(file)) {
+                try {
+                    const version = JSON.parse(fs.readFileSync(file, 'utf-8'))?.version;
+                    return typeof version === 'string' ? version : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return undefined;
+            dir = parent;
+        }
+    }
+    /** The newest release `range` takes, as npm's install would pick it: no prerelease unless the
+     *  range asks for one, nothing above the `latest` tag, a deprecated one only when nothing else is. */
+    resolvedVersion(d, range) {
+        if (!d.releases || !semver.validRange(range))
+            return undefined;
+        const taken = [...d.releases.values()]
+            .filter(r => semver.satisfies(r.version, range))
+            .filter(r => !d.latestTag || !semver.valid(d.latestTag) || semver.lte(r.version, d.latestTag))
+            .sort((a, b) => semver.rcompare(a.version, b.version));
+        return (taken.find(r => !r.deprecated) ?? taken[0])?.version;
+    }
     manifestFile(pkg) {
         return path.join(pkg.dirname, 'package.json');
     }

package/commands/deps.command.js

@@ -182,6 +182,8 @@ function jsonPlan(entries) {
         types: e.types,
         status: e.status,
         current: e.current,
+        installed: e.installed,
+        resolved: e.resolved,
         target: e.target,
         latest: e.latest,
         available: e.available,
@@ -200,30 +202,40 @@ function jsonPlan(entries) {
  * own settings leave the newer version out) or `error`. Moves first, smallest first, then the rest. */
 function printPlan(entries, root) {
     const updated = entries.filter(e => e.status === 'update');
-    const shown = entries.filter(e => e.status !== 'up-to-date');
+    const shown = entries.filter(e => e.status !== 'up-to-date' || reinstall(e));
     /** Said first when nothing moves, so a run whose only rows are majors left behind does not read
      *  as a list of things to do. */
     if (!updated.length) {
-        console.log(colors.green('All dependencies are up to date') +
-            (shown.length ? colors.gray(' - newer versions their settings leave out, or another rule holds back:') : '.'));
+        const why = [
+            ...(shown.some(e => e.status !== 'up-to-date')
+                ? ['newer versions their settings leave out, or another rule holds back']
+                : []),
+            ...(shown.some(reinstall) ? ['installed versions that differ from what the range takes'] : []),
+        ];
+        console.log(colors.green('All dependencies are up to date') + (why.length ? colors.gray(` - ${why.join('; ')}:`) : '.'));
         if (!shown.length)
             return;
     }
-    const header = ['Dependency', 'Current', 'Upgrade', 'Latest', 'Change'];
+    /** The upgrade last before the note, so the row reads from what is there to what it would become. */
+    const header = ['Dependency', 'Current', 'Installed', 'Latest', 'Change', 'Upgrade'];
     const cells = (e) => [
         e.name,
         e.current,
-        e.status === 'update' ? (e.target ?? '') : '-',
-        e.status === 'error' ? '-' : (e.available ?? e.latest ?? ''),
+        e.installed ?? '-',
+        e.status === 'error' ? '-' : (e.available ?? e.latest ?? e.resolved ?? ''),
         changeOf(e),
+        e.status === 'update' ? (e.target ?? '') : '-',
     ];
+    const last = header.length - 1;
     const widths = header.map((h, i) => Math.max(h.length, ...shown.map(e => cells(e)[i].length)));
     /** Padded to the column, except a last value nothing follows - trailing spaces inside a colour
      *  code are past the reach of `trimEnd`. */
     const line = (values, paint = text => text) => '  ' + values.map((v, i) => paint(i === values.length - 1 ? v : v.padEnd(widths[i]), i)).join('  ');
     for (const pkg of [...new Set(shown.map(e => e.package))]) {
         const sizes = pkg.versionScheme.bumpNames;
-        const rank = (e) => e.status === 'update' ? sizes.indexOf(e.bump) : sizes.length + ['held', 'skipped', 'error'].indexOf(e.status);
+        const rank = (e) => e.status === 'update'
+            ? sizes.indexOf(e.bump)
+            : sizes.length + ['held', 'skipped', 'error', 'up-to-date'].indexOf(e.status);
         const rows = shown.filter(e => e.package === pkg).sort((x, y) => rank(x) - rank(y));
         const where = path.relative(root, pkg.dirname);
         console.log(colors.cyan(pkg.name) + (where ? colors.gray(` (${where})`) : ''));
@@ -231,16 +243,17 @@ function printPlan(entries, root) {
         for (const e of rows) {
             const paint = e.status === 'update' ? sizeColor(e.bump, sizes) : changeColor(e.status);
             const values = cells(e);
-            if (e.reason)
-                values[4] = values[4].padEnd(widths[4]);
-            const text = line(values, (v, column) => (column === 2 || column === 4 ? paint(v) : v));
-            if (!e.reason) {
+            const note = e.reason ?? (reinstall(e) ? `"${e.current}" takes ${e.resolved} - install again` : undefined);
+            if (note)
+                values[last] = values[last].padEnd(widths[last]);
+            const text = line(values, (v, column) => (column === 4 || column === 5 ? paint(v) : v));
+            if (!note) {
                 console.log(text);
                 continue;
             }
             const indent = 2 + widths.reduce((sum, w) => sum + w + 2, 0);
-            const note = wrapNote(e.reason, process.stdout.isTTY ? process.stdout.columns - indent : 0);
-            console.log(`${text}  ${note.map(l => colors.gray(l)).join('\n' + ' '.repeat(indent))}`);
+            const wrapped = wrapNote(note, process.stdout.isTTY ? process.stdout.columns - indent : 0);
+            console.log(`${text}  ${wrapped.map(l => colors.gray(l)).join('\n' + ' '.repeat(indent))}`);
         }
     }
 }
@@ -268,8 +281,18 @@ function wrapNote(note, width) {
 }
 /** What the `Change` column says: the size of the move, or why there is none. */
 function changeOf(e) {
+    if (e.status === 'up-to-date')
+        return reinstall(e) ? 'install' : e.status;
     return e.status === 'update' ? (e.bump ?? 'other') : e.status;
 }
+/**
+ * A range already at the newest version, with something else installed - a `node_modules` behind
+ * its manifest. Listed although nothing moves: hidden, it read as up to date while the code ran
+ * against the older version.
+ */
+function reinstall(e) {
+    return e.status === 'up-to-date' && !!e.installed && !!e.resolved && e.installed !== e.resolved;
+}
 /** `held` and `skipped` in yellow, an error in red - a row with no move to colour by size. */
 function changeColor(status) {
     return status === 'error' ? colors.red : colors.yellow;

package/constants.js

@@ -1 +1 @@
-export const version = '2.25.2';
+export const version = '2.26.0';

package/core/interfaces/dependency-updater.d.ts

@@ -76,6 +76,12 @@ export declare namespace DependencyUpdater {
         types: string[];
         /** The range as the manifest declares it. */
         current: string;
+        /** The version installed now, as the package would resolve it - unset when it is not
+         *  installed, or the ecosystem cannot say. */
+        installed?: string;
+        /** The newest version the declared range takes - what an install would put there. An
+         *  `'up-to-date'` entry whose `installed` differs from it is still listed. */
+        resolved?: string;
         status: 'update' | 'held' | 'skipped' | 'up-to-date' | 'error';
         /** The range it is rewritten to, on an `'update'`. */
         target?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.25.2",
+  "version": "2.26.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {