@bobfrankston/npmglobalize 1.0.149 → 1.0.151

package/README.md

@@ -94,6 +94,28 @@ Errors abort (unless `--force`); warnings prompt to continue.
 
 Skip the prescan with `-no-prescan` / `-nps`.
 
+#### Workspace skip prescan
+
+In workspace mode, before processing begins, each package is also checked to decide whether it actually needs work. A package is **skipped** (no rebuild, no version bump, no publish) only if **all** of these are true:
+
+1. **Working tree clean** — `git status --porcelain .` reports no uncommitted changes for that package's directory.
+2. **Version already on npm** — the version in its `package.json` is published to the registry, and no non-bookkeeping commit (anything outside "Pre-release commit" / "Restore file: dependencies" / "Pre-version cleanup" / "Untrack node_modules") is newer than that version's publish timestamp.
+3. **Build is fresh** — every `.ts` source file (excluding `.d.ts`) has a sibling `.js` whose mtime is ≥ the `.ts` mtime. A missing `.js` or an older `.js` counts as stale.
+4. **No sibling workspace `file:` dep flagged for work** — if another workspace package depends on this one via `file:`, and that dep is being updated in this run, this one is also processed (propagates through the graph in topological order).
+
+If any condition fails, the package is processed. The prescan prints one line per package with `⟳` for "will process" (and the reason) or `✓` for "skip". Example:
+
+```
+⟳ mlproc     — uncommitted changes
+⟳ pzip       — stale build (index.ts newer than index.js)
+⟳ stage      — dep pzip is being updated
+✓ puller     — skip (clean, published, build fresh)
+```
+
+The summary row for a skipped package shows `– name v1.0.0 (skipped — already up to date)`.
+
+Use `--force` or `--force-publish` to bypass the skip prescan and process every package.
+
 **Force republish** all file: dependencies even if versions exist:
 ```bash
 npmglobalize --force-publish

package/ignorepatterns.json5

@@ -59,7 +59,7 @@
             "package-lock.json",
             "*.ts",
             "!*.d.ts",
-            "*.map",
+            // "*.map",  // keep source maps in published packages for debugging
             "tsconfig.json",
             ".vscode/",
             ".globalize.json5"

package/lib/diagnose.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Diagnose failures of npm commands run by npmglobalize.
+ *
+ * Pulls out common error shapes — especially ones whose root cause lives in
+ * a referenced (file:) module, not the current package — and turns them into
+ * a short summary + actionable hint instead of a raw arborist stack trace.
+ *
+ * Leaf module: no dependencies on lib.ts or other internal modules. Keeps
+ * the main publish flow in lib.ts readable.
+ */
+export interface DiagnosedError {
+    /** Short one-liner suitable for the Issues Summary. */
+    summary: string;
+    /** Multi-line block to print to console.error (without color). */
+    details: string[];
+    /** If the root cause is a file: sibling, its package name. */
+    referencedModule?: string;
+    /** One concrete next step the user can take. */
+    hint?: string;
+}
+/** Diagnose an `npm pack` failure. */
+export declare function diagnoseNpmPackFailure(cwd: string, output: string, stderr: string, pkg: any): DiagnosedError;
+/** Given a nested-node_modules path like
+ *    `node_modules/@scope/sibling/node_modules/transitive`
+ *  or `../sibling/node_modules/transitive`,
+ *  find the outermost dep name and resolve it to a file: sibling declared
+ *  in pkg.dependencies / pkg['.dependencies'] / etc. */
+declare function resolveSiblingFromNestedPath(nestedPath: string, cwd: string, pkg: any): {
+    name: string;
+    filePath: string;
+} | undefined;
+/** Scan pkg deps for a file: entry whose resolved absolute path equals absTarget. */
+declare function findFileDepByPath(pkg: any, cwd: string, absTarget: string): {
+    name: string;
+    filePath: string;
+} | undefined;
+/** Exposed for ad-hoc testing — not used by the main flow. */
+export declare const _test: {
+    resolveSiblingFromNestedPath: typeof resolveSiblingFromNestedPath;
+    findFileDepByPath: typeof findFileDepByPath;
+};
+export {};
+//# sourceMappingURL=diagnose.d.ts.map

package/lib/diagnose.js

@@ -0,0 +1,141 @@
+/**
+ * Diagnose failures of npm commands run by npmglobalize.
+ *
+ * Pulls out common error shapes — especially ones whose root cause lives in
+ * a referenced (file:) module, not the current package — and turns them into
+ * a short summary + actionable hint instead of a raw arborist stack trace.
+ *
+ * Leaf module: no dependencies on lib.ts or other internal modules. Keeps
+ * the main publish flow in lib.ts readable.
+ */
+import path from 'path';
+/** Diagnose an `npm pack` failure. */
+export function diagnoseNpmPackFailure(cwd, output, stderr, pkg) {
+    const blob = `${output}\n${stderr}`;
+    const lower = blob.toLowerCase();
+    // Pattern 1: arborist "missing from lockfile: <path>" + null-`package` TypeError.
+    // Root cause: a file: sibling has its own populated node_modules/<transitive>
+    // that is not in the current package's lockfile. See notes.md §TODO:
+    // "Isolate npm pack from sibling file: dep junctions".
+    const missingMatch = blob.match(/missing from lockfile:\s*(\S+)/i);
+    const hasNullPackage = /cannot read propert(y|ies) of null \(reading 'package'\)/i.test(blob);
+    if (missingMatch && (hasNullPackage || /shrinkwrap failed to load/i.test(blob))) {
+        const nestedPath = missingMatch[1];
+        const sibling = resolveSiblingFromNestedPath(nestedPath, cwd, pkg);
+        const details = [
+            `npm arborist crashed walking a nested node_modules tree.`,
+            `Missing from lockfile: ${nestedPath}`,
+        ];
+        if (sibling) {
+            return {
+                summary: `npm pack failed — arborist crashed on sibling's node_modules`,
+                details,
+                referencedModule: sibling.name,
+                hint: `sibling ${sibling.name} has its own populated node_modules; see notes.md §TODO: Isolate npm pack from sibling file: dep junctions`,
+            };
+        }
+        return {
+            summary: `npm pack failed — arborist crashed on a nested node_modules`,
+            details,
+            hint: `likely a file: dep whose target has its own node_modules; see notes.md §TODO: Isolate npm pack from sibling file: dep junctions`,
+        };
+    }
+    // Pattern 2: arborist null-`package` without an obvious path — same class,
+    // no identifiable referenced module.
+    if (hasNullPackage) {
+        return {
+            summary: `npm pack failed — arborist internal error`,
+            details: [extractArboristFrame(blob) || 'Cannot read properties of null (reading \'package\')'],
+            hint: `likely a symlinked file: dep with its own node_modules; try renaming node_modules/ and running \`npm pack --dry-run\``,
+        };
+    }
+    // Pattern 3: shrinkwrap / lockfile parsing without the arborist crash.
+    if (/enolock|shrinkwrap failed to load|eresolve/i.test(lower)) {
+        return {
+            summary: `npm pack failed — lockfile problem`,
+            details: [extractFirstNpmError(blob) || blob.trim().slice(0, 400)],
+            hint: `run \`npm install\` in ${cwd}, then retry`,
+        };
+    }
+    // Pattern 4: file-locking on the tarball (AV, editor, explorer preview).
+    if (/\be(acces|busy|perm)\b/i.test(blob) && /\.tgz\b/i.test(blob)) {
+        return {
+            summary: `npm pack failed — tarball file locked`,
+            details: [extractFirstNpmError(blob) || blob.trim().slice(0, 400)],
+            hint: `close editors / antivirus holding the .tgz, then retry`,
+        };
+    }
+    // Fallthrough: raw output.
+    return {
+        summary: `npm pack failed`,
+        details: [
+            output.trim() ? `Output: ${output.trim()}` : '',
+            stderr.trim() ? `Error: ${stderr.trim()}` : '',
+        ].filter(Boolean),
+    };
+}
+/** Given a nested-node_modules path like
+ *    `node_modules/@scope/sibling/node_modules/transitive`
+ *  or `../sibling/node_modules/transitive`,
+ *  find the outermost dep name and resolve it to a file: sibling declared
+ *  in pkg.dependencies / pkg['.dependencies'] / etc. */
+function resolveSiblingFromNestedPath(nestedPath, cwd, pkg) {
+    const normalized = nestedPath.replace(/\\/g, '/');
+    // Prefer the sibling-relative shape first: `../iflow-direct/node_modules/undici-types`.
+    // The *outermost* thing is the sibling dir, not the nested transitive.
+    const siblingMatch = normalized.match(/^(?:\.\.\/)+((?:@[^/]+\/)?[^/]+)\/node_modules\//);
+    if (siblingMatch) {
+        const absSibling = path.resolve(cwd, normalized.split('/node_modules/')[0]);
+        const resolved = findFileDepByPath(pkg, cwd, absSibling);
+        if (resolved)
+            return resolved;
+        return { name: siblingMatch[1], filePath: absSibling };
+    }
+    // Otherwise use the first `node_modules/<name>` segment.
+    const nmMatch = normalized.match(/(?:^|\/)node_modules\/((?:@[^/]+\/)?[^/]+)/);
+    const candidateName = nmMatch?.[1];
+    if (!candidateName)
+        return undefined;
+    // Try to confirm it's a file: dep by checking pkg.dependencies and .dependencies.
+    const allDeps = {};
+    for (const key of ['dependencies', '.dependencies', 'devDependencies', '.devDependencies']) {
+        if (pkg && pkg[key] && typeof pkg[key] === 'object')
+            Object.assign(allDeps, pkg[key]);
+    }
+    const spec = allDeps[candidateName];
+    if (spec && spec.startsWith('file:')) {
+        return { name: candidateName, filePath: path.resolve(cwd, spec.slice('file:'.length)) };
+    }
+    // Even if not explicitly file:, still useful to name it.
+    return { name: candidateName, filePath: path.resolve(cwd, 'node_modules', candidateName) };
+}
+/** Scan pkg deps for a file: entry whose resolved absolute path equals absTarget. */
+function findFileDepByPath(pkg, cwd, absTarget) {
+    const target = path.resolve(absTarget).toLowerCase();
+    for (const key of ['dependencies', '.dependencies', 'devDependencies', '.devDependencies']) {
+        const deps = pkg && pkg[key];
+        if (!deps || typeof deps !== 'object')
+            continue;
+        for (const [name, spec] of Object.entries(deps)) {
+            if (typeof spec !== 'string' || !spec.startsWith('file:'))
+                continue;
+            const abs = path.resolve(cwd, spec.slice('file:'.length)).toLowerCase();
+            if (abs === target)
+                return { name, filePath: abs };
+        }
+    }
+    return undefined;
+}
+/** Pull out the first arborist stack frame for display. */
+function extractArboristFrame(blob) {
+    const m = blob.match(/at [^\n]*arborist[^\n]*/i);
+    return m ? m[0].trim() : undefined;
+}
+/** Pull out the first `npm error <message>` line. */
+function extractFirstNpmError(blob) {
+    const m = blob.match(/npm error [^\n]+/i);
+    return m ? m[0].trim() : undefined;
+}
+/** Exposed for ad-hoc testing — not used by the main flow. */
+export const _test = { resolveSiblingFromNestedPath, findFileDepByPath };
+//# sourceMappingURL=diagnose.js.map

package/lib.d.ts

@@ -115,6 +115,7 @@ interface WorkspacePackageResult {
     success: boolean;
     version?: string;
     error?: string;
+    skipped?: boolean;
 }
 /** Aggregate result from workspace orchestration */
 export interface WorkspaceResult {

package/lib.js

@@ -31,6 +31,7 @@ import libversion from 'libnpmversion';
 import JSON5 from 'json5';
 import { fileURLToPath } from 'url';
 import { themeColors } from '@bobfrankston/themecolors';
+import { diagnoseNpmPackFailure } from './lib/diagnose.js';
 /** Semantic color functions — adapts to terminal light/dark theme */
 const colors = themeColors();
 const _buildIssues = [];
@@ -810,6 +811,49 @@ function hasUnpublishedTransitiveDeps(packageName, pkg, baseDir, verbose) {
     }
     return false;
 }
+/** Walk a dir and return true if any `.ts` source has mtime newer than its sibling `.js`
+ *  (or the `.js` is missing). Skips node_modules/prev/cruft/.git and declaration files. */
+function hasStaleBuild(rootDir) {
+    const SKIP = new Set(['node_modules', 'prev', 'cruft', '.git']);
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return { stale: false };
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (SKIP.has(e.name.toLowerCase()))
+                    continue;
+                const sub = walk(full);
+                if (sub.stale)
+                    return sub;
+            }
+            else if (e.isFile() && e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) {
+                const jsPath = full.slice(0, -3) + '.js';
+                try {
+                    const tsStat = fs.statSync(full);
+                    let jsStat;
+                    try {
+                        jsStat = fs.statSync(jsPath);
+                    }
+                    catch {
+                        return { stale: true, example: `${e.name} (no .js)` };
+                    }
+                    if (tsStat.mtimeMs > jsStat.mtimeMs) {
+                        return { stale: true, example: `${e.name} newer than ${path.basename(jsPath)}` };
+                    }
+                }
+                catch { /* unreadable — ignore */ }
+            }
+        }
+        return { stale: false };
+    }
+    return walk(rootDir);
+}
 /** Check if local package directory has changes newer than the npm-published version.
  *  Detects uncommitted changes or commits made after the version was published. */
 function hasLocalChanges(packageName, version, targetPath, verbose) {
@@ -2933,7 +2977,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         console.log(colors.yellow('Local branch is behind remote.'));
         if (rebase) {
             console.log('Rebasing local changes (--rebase)...');
-            const rebaseResult = runCommand('git', ['pull', '--rebase'], { cwd, silent: false });
+            const rebaseResult = runCommand('git', ['pull', '--rebase', 'origin', currentGitStatus.currentBranch], { cwd, silent: false });
             if (!rebaseResult.success) {
                 console.error(colors.red('ERROR: Rebase failed.'));
                 console.error('You may need to resolve conflicts manually.');
@@ -3143,9 +3187,6 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         }
         // Don't set "private": true in package.json - that blocks all publishing
         console.log(`Package '${pkg.name}' will publish as PRIVATE (restricted access).`);
-        if (!currentAccess) {
-            console.log(colors.dim(`  First publish - requires paid npm account`));
-        }
     }
     else if (effectiveNpmVisibility === 'public') {
         // User explicitly wants public (or confirmed via prompt)
@@ -3832,7 +3873,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     }
     // Pull latest from remote before version bump to avoid push rejection
     if (currentGitStatus.hasRemote && !dryRun) {
-        const pullResult = runCommand('git', ['pull', '--rebase'], { cwd, silent: true });
+        const pullResult = runCommand('git', ['pull', '--rebase', 'origin', currentGitStatus.currentBranch], { cwd, silent: true });
         if (!pullResult.success) {
             console.error(colors.yellow('Warning: git pull --rebase failed before version bump'));
             if (verbose) {
@@ -3908,7 +3949,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         }
         catch (error) {
             let autoFixed = false;
-            console.error(colors.red('ERROR: Version bump failed:'), error.message);
+            console.error(colors.red(`ERROR: Version bump failed in ${cwd} (${pkg.name || '<unnamed>'}):`), error.message);
             // Show additional error details if available
             if (error.stderr || error.stdout || error.code) {
                 if (error.stderr)
@@ -3933,7 +3974,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 // Version bump + tag succeeded locally; only the push failed.
                 // Auto-pull --rebase and retry the push.
                 console.log(colors.yellow('\nLocal branch is behind remote — pulling with rebase...'));
-                const pullResult = runCommand('git', ['pull', '--rebase'], { cwd });
+                const pullResult = runCommand('git', ['pull', '--rebase', 'origin', currentGitStatus.currentBranch], { cwd });
                 if (pullResult.success) {
                     console.log(colors.green('  ✓ Rebased onto remote'));
                     const pushResult = runCommand('git', ['push'], { cwd });
@@ -4065,8 +4106,39 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                     return false;
                 }
             }
+            else if (/paths are ignored by one of your \.gitignore files/i.test(combinedOutput)) {
+                // git add refused to stage files (usually package.json) because a
+                // .gitignore rule matches. Ask git which exact line is to blame.
+                const ignoredMatch = combinedOutput.match(/paths are ignored by one of your \.gitignore files:\s*\n([\s\S]*?)(?:hint:|$)/i);
+                const ignoredFiles = (ignoredMatch ? ignoredMatch[1] : '')
+                    .split('\n').map(s => s.trim()).filter(Boolean);
+                console.error(colors.red(`\n.gitignore in ${cwd} is blocking required file(s):`));
+                for (const f of ignoredFiles) {
+                    const chk = spawnSafe('git', ['-C', cwd, 'check-ignore', '-v', f], { encoding: 'utf-8', stdio: 'pipe' });
+                    if (chk.status === 0 && chk.stdout?.trim()) {
+                        // Output format: "<source>:<line>:<pattern>\t<file>"
+                        const m = chk.stdout.trim().match(/^(.+?):(\d+):(.+?)\t(.+)$/);
+                        if (m) {
+                            const [, src, line, pattern, file] = m;
+                            console.error(colors.red(`  ${file}  —  matched by ${src}:${line}  pattern: ${pattern}`));
+                            if (pattern.trim() === '*') {
+                                console.error(colors.yellow(`    → Line ${line} is a bare "*" which ignores EVERY file. Delete it.`));
+                            }
+                        }
+                        else {
+                            console.error(colors.red(`  ${f}`));
+                            console.error(colors.dim(`    ${chk.stdout.trim()}`));
+                        }
+                    }
+                    else {
+                        console.error(colors.red(`  ${f}`));
+                    }
+                }
+                console.error(colors.yellow(`\nEdit ${path.join(cwd, '.gitignore')} to remove/narrow the blocking pattern,`));
+                console.error(colors.yellow(`or exempt with an explicit negation, e.g.:  !package.json`));
+            }
             else if (error.message?.includes('unknown git error')) {
-                console.error(colors.yellow('Unknown git error — check git hooks, signing, or permissions'));
+                console.error(colors.yellow(`Unknown git error in ${cwd} — check git hooks, signing, or permissions`));
             }
             else if (combinedOutput.includes('gh013') || combinedOutput.includes('push protection') || combinedOutput.includes('push declined due to repository rule')) {
                 // GitHub push protection blocked a push (from postversion script)
@@ -4168,10 +4240,15 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         // Create tarball first
         const packResult = runCommand('npm', ['pack'], { cwd, silent: true });
         if (!packResult.success) {
-            console.error(colors.red('ERROR: Failed to create package tarball'));
-            console.error(colors.yellow('Output:'), packResult.output);
-            console.error(colors.yellow('Error:'), packResult.stderr);
-            recordBuildIssue(pkg.name || path.basename(cwd), 'error', 'npm pack failed');
+            const d = diagnoseNpmPackFailure(cwd, packResult.output, packResult.stderr, pkg);
+            console.error(colors.red(`ERROR: ${d.summary}`));
+            for (const line of d.details)
+                console.error(colors.yellow('  ' + line));
+            if (d.referencedModule)
+                console.error(colors.yellow(`  Caused by referenced module: ${d.referencedModule}`));
+            if (d.hint)
+                console.error(colors.yellow(`  Hint: ${d.hint}`));
+            recordBuildIssue(pkg.name || path.basename(cwd), 'error', d.referencedModule ? `${d.summary} (via ${d.referencedModule})` : d.summary);
             return false;
         }
         // Get the tarball filename from npm pack output
@@ -4637,9 +4714,84 @@ export async function globalizeWorkspace(rootDir, options = {}, configOptions =
             }
         }
     }
+    // Prescan: decide which packages actually need processing so we don't waste
+    // time rebuilding+republishing ones with no relevant changes.
+    // A package is SKIPPED only if ALL of:
+    //   - working tree clean (no uncommitted changes)
+    //   - current version is on npm AND no commits newer than its publish time
+    //   - build not stale (every .ts source has a .js no older than it)
+    //   - no sibling workspace file: dep was itself flagged for processing
+    const flaggedForWork = new Set();
+    const skipReasons = new Map();
+    if (!options.force && !options.forcePublish) {
+        console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(`  Prescan: checking ${filteredOrder.length} package(s)...`);
+        console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        const wsDeps = new Map(); // pkg → workspace-sibling file: deps
+        for (const pkgInfo of packages) {
+            const sibs = new Set();
+            const deps = { ...pkgInfo.pkg.dependencies, ...pkgInfo.pkg.devDependencies };
+            for (const [dn, dv] of Object.entries(deps)) {
+                if (typeof dv === 'string' && dv.startsWith('file:') && wsNameSet.has(dn)) {
+                    sibs.add(dn);
+                }
+            }
+            wsDeps.set(pkgInfo.name, sibs);
+        }
+        for (const pkgName of filteredOrder) {
+            const pkgInfo = packages.find(p => p.name === pkgName);
+            if (!pkgInfo)
+                continue;
+            let reason;
+            const status = spawnSafe('git', ['-C', pkgInfo.dir, 'status', '--porcelain', '.'], { encoding: 'utf-8', stdio: 'pipe', shell: true });
+            if (status.status === 0 && status.stdout.trim()) {
+                reason = 'uncommitted changes';
+            }
+            else {
+                const version = pkgInfo.pkg.version;
+                if (!checkVersionExists(pkgInfo.name, version)) {
+                    reason = `v${version} not on npm`;
+                }
+                else if (hasLocalChanges(pkgInfo.name, version, pkgInfo.dir, false)) {
+                    reason = 'commits since last publish';
+                }
+                else {
+                    const stale = hasStaleBuild(pkgInfo.dir);
+                    if (stale.stale) {
+                        reason = `stale build (${stale.example})`;
+                    }
+                    else {
+                        const flaggedSib = [...(wsDeps.get(pkgName) || [])].find(s => flaggedForWork.has(s));
+                        if (flaggedSib)
+                            reason = `dep ${flaggedSib} is being updated`;
+                    }
+                }
+            }
+            if (reason) {
+                flaggedForWork.add(pkgName);
+                console.log(`  ${colors.yellow('⟳')} ${pkgName}  — ${reason}`);
+            }
+            else {
+                skipReasons.set(pkgName, 'clean, published, build fresh');
+                console.log(`  ${colors.green('✓')} ${pkgName}  — skip (clean, published, build fresh)`);
+            }
+        }
+        console.log('');
+        if (flaggedForWork.size === 0) {
+            console.log(colors.green('Nothing to do — all packages up to date.'));
+            console.log('');
+            return { success: true, packages: [], publishOrder };
+        }
+        console.log(colors.dim(`Prescan: ${flaggedForWork.size} to process, ${skipReasons.size} skip. (Use --force to process all.)`));
+        console.log('');
+    }
     // Process each package in dependency order
     const results = [];
     for (const pkgName of filteredOrder) {
+        if (skipReasons.has(pkgName)) {
+            results.push({ name: pkgName, dir: packages.find(p => p.name === pkgName).dir, success: true, version: packages.find(p => p.name === pkgName).pkg.version, skipped: true });
+            continue;
+        }
         const pkgInfo = packages.find(p => p.name === pkgName);
         if (!pkgInfo)
             continue;
@@ -4692,10 +4844,11 @@ export async function globalizeWorkspace(rootDir, options = {}, configOptions =
     console.log(allSuccess ? colors.green('✓ Workspace Summary') : colors.red('✗ Workspace Summary'));
     console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
     for (const r of results) {
-        const status = r.success ? colors.green('✓') : colors.red('✗');
+        const status = r.skipped ? colors.dim('–') : (r.success ? colors.green('✓') : colors.red('✗'));
         const ver = r.version ? ` v${r.version}` : '';
         const err = r.error ? colors.red(` (${r.error})`) : '';
-        console.log(`  ${status} ${r.name}${ver}${err}`);
+        const tag = r.skipped ? colors.dim(' (skipped — already up to date)') : '';
+        console.log(`  ${status} ${r.name}${ver}${err}${tag}`);
     }
     console.log(colors.green('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
     console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.149",
+  "version": "1.0.151",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",