@bobfrankston/npmglobalize 1.0.139 → 1.0.141

package/lib/types.d.ts

@@ -6,16 +6,8 @@ import { type SpawnSyncOptions, type SpawnSyncReturns } from 'child_process';
 /** Wrapper for spawnSync that avoids DEP0190 (args + shell: true).
  *  When shell is true, joins cmd+args into a single command string. */
 export declare function spawnSafe(cmd: string, args: string[], options?: SpawnSyncOptions): SpawnSyncReturns<string>;
-/** Color/style helpers using Node.js styleText (Node 24+) */
-export declare const colors: {
-    red: (text: string) => string;
-    yellow: (text: string) => string;
-    green: (text: string) => string;
-    italic: (text: string) => string;
-    blue: (text: string) => string;
-    cyan: (text: string) => string;
-    dim: (text: string) => string;
-};
+/** Semantic color functions — adapts to terminal light/dark theme */
+export declare const colors: import("@bobfrankston/themecolors").SemanticColors;
 /** Get npm command for current platform (npm.cmd on Windows, npm elsewhere) */
 export declare function getNpmCommand(): string;
 /** Options for the globalize operation */

package/lib/types.js

@@ -3,7 +3,7 @@
  * Leaf module — no internal dependencies.
  */
 import { spawnSync } from 'child_process';
-import { styleText } from 'util';
+import { themeColors } from '@bobfrankston/themecolors';
 import readline from 'readline';
 /** Wrapper for spawnSync that avoids DEP0190 (args + shell: true).
  *  When shell is true, joins cmd+args into a single command string. */
@@ -16,16 +16,8 @@ export function spawnSafe(cmd, args, options = {}) {
     }
     return spawnSync(cmd, args, opts);
 }
-/** Color/style helpers using Node.js styleText (Node 24+) */
-export const colors = {
-    red: (text) => styleText('red', text),
-    yellow: (text) => styleText('yellow', text),
-    green: (text) => styleText('green', text),
-    italic: (text) => styleText('italic', text),
-    blue: (text) => styleText('blue', text),
-    cyan: (text) => styleText('cyan', text),
-    dim: (text) => styleText('dim', text),
-};
+/** Semantic color functions — adapts to terminal light/dark theme */
+export const colors = themeColors();
 /** Get npm command for current platform (npm.cmd on Windows, npm elsewhere) */
 export function getNpmCommand() {
     return process.platform === 'win32' ? 'npm.cmd' : 'npm';

package/lib.js

@@ -137,6 +137,10 @@ function getNpmCommand() {
     return process.platform === 'win32' ? 'npm.cmd' : 'npm';
 }
 const DEP_KEYS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+/** Format current time as HH:MM:SS for progress timestamps */
+function timestamp() {
+    return colors.dim(new Date().toLocaleTimeString('en-US', { hour12: false }));
+}
 /** Read and parse package.json from a directory */
 export function readPackageJson(dir) {
     const pkgPath = path.join(dir, 'package.json');
@@ -1003,7 +1007,7 @@ export function fixVersionTagMismatch(cwd, pkg, verbose = false) {
 function waitForNpmVersion(pkgName, version, maxWaitMs = 90000) {
     const interval = 3000;
     const maxAttempts = Math.ceil(maxWaitMs / interval);
-    process.stdout.write(`Waiting for ${pkgName}@${version} on npm registry`);
+    process.stdout.write(`${timestamp()} Waiting for ${pkgName}@${version} on npm registry`);
     for (let i = 0; i < maxAttempts; i++) {
         const result = spawnSafe('npm', ['view', `${pkgName}@${version}`, 'version'], {
             shell: process.platform === 'win32',
@@ -1068,6 +1072,96 @@ export function runCommand(cmd, args, options = {}) {
         return { success: false, output: '', stderr: error.message };
     }
 }
+/** Diagnose common build/version failure patterns and print actionable hints.
+ *  Returns true if a diagnosis was printed. */
+function diagnoseBuildFailure(errorText, cwd) {
+    let diagnosed = false;
+    // Pattern: missing module / package not found
+    const missingPkg = errorText.match(/Cannot find (?:package|module) ['"](@?[^'"\/]+(?:\/[^'"\/]+)?)/);
+    if (missingPkg) {
+        const pkgName = missingPkg[1];
+        console.error(colors.yellow(`\n  Hint: missing package "${pkgName}"`));
+        // Check for broken symlinks in node_modules tree
+        const searchDirs = [cwd];
+        try {
+            for (const entry of fs.readdirSync(cwd, { withFileTypes: true })) {
+                if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git' && entry.name !== 'prev') {
+                    searchDirs.push(path.join(cwd, entry.name));
+                }
+            }
+        }
+        catch { /* ignore */ }
+        for (const dir of searchDirs) {
+            const nmPath = path.join(dir, 'node_modules', ...pkgName.split('/'));
+            try {
+                const stat = fs.lstatSync(nmPath);
+                if (stat.isSymbolicLink()) {
+                    const target = fs.readlinkSync(nmPath);
+                    const resolved = path.resolve(path.dirname(nmPath), target);
+                    if (!fs.existsSync(resolved)) {
+                        console.error(colors.yellow(`  Broken symlink: ${nmPath}`));
+                        console.error(colors.yellow(`    → ${resolved} (target missing)`));
+                        console.error(colors.yellow(`  Fix: cd "${dir}" && npm install`));
+                        diagnosed = true;
+                    }
+                    else {
+                        console.error(colors.yellow(`  Symlink exists at ${nmPath} but module still failed to load.`));
+                        console.error(colors.yellow(`  Check that the target package has been built (has .js files).`));
+                        diagnosed = true;
+                    }
+                }
+            }
+            catch {
+                // No symlink found at this location — check if it should exist
+                const subPkgPath = path.join(dir, 'package.json');
+                if (fs.existsSync(subPkgPath)) {
+                    try {
+                        const subPkg = JSON.parse(fs.readFileSync(subPkgPath, 'utf-8'));
+                        const allDeps = { ...subPkg.dependencies, ...subPkg.devDependencies };
+                        if (allDeps[pkgName]) {
+                            const depValue = allDeps[pkgName];
+                            if (typeof depValue === 'string' && depValue.startsWith('file:')) {
+                                const target = path.resolve(dir, depValue.replace('file:', ''));
+                                console.error(colors.yellow(`  "${pkgName}" is a file: dep in ${path.relative(cwd, subPkgPath) || 'package.json'}`));
+                                console.error(colors.yellow(`    → ${target}`));
+                                if (!fs.existsSync(target)) {
+                                    console.error(colors.yellow(`    Target directory does not exist!`));
+                                }
+                                else {
+                                    console.error(colors.yellow(`  Fix: cd "${dir}" && npm install`));
+                                }
+                                diagnosed = true;
+                            }
+                            else {
+                                console.error(colors.yellow(`  "${pkgName}" is listed in ${path.relative(cwd, subPkgPath) || 'package.json'} but not installed.`));
+                                console.error(colors.yellow(`  Fix: cd "${dir}" && npm install`));
+                                diagnosed = true;
+                            }
+                        }
+                    }
+                    catch { /* ignore parse errors */ }
+                }
+            }
+        }
+        if (!diagnosed) {
+            console.error(colors.yellow(`  "${pkgName}" is not installed and not listed as a dependency.`));
+            console.error(colors.yellow(`  If needed, add it: npm install ${pkgName}`));
+            diagnosed = true;
+        }
+    }
+    // Pattern: permission denied
+    if (!diagnosed && /permission denied|EPERM|EACCES/.test(errorText)) {
+        console.error(colors.yellow('\n  Hint: permission error during build.'));
+        console.error(colors.yellow('  Check file ownership and that no other process has files locked.'));
+        diagnosed = true;
+    }
+    // Pattern: TypeScript compilation error
+    if (!diagnosed && /error TS\d+/.test(errorText)) {
+        console.error(colors.yellow('\n  Hint: TypeScript compilation errors. Fix the type errors above before publishing.'));
+        diagnosed = true;
+    }
+    return diagnosed;
+}
 /** Run git commit silently and print a compact summary (no per-file create/delete mode lines). */
 function gitCommit(msg, cwd) {
     const result = runCommand('git', ['commit', '-m', msg], { cwd, silent: true });
@@ -2637,18 +2731,19 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     const pkg = readPackageJson(cwd);
     // Run build step if package.json has a build script (skip if CLI already built)
     if (pkg.scripts?.build && !options._fromCli) {
-        console.log('Running build...');
+        console.log(`${timestamp()} Running build...`);
         if (!dryRun) {
             const buildResult = runCommand('npm', ['run', 'build'], { cwd, silent: !verbose });
             if (!buildResult.success) {
                 console.error(colors.red('ERROR: Build failed:'), buildResult.stderr || buildResult.output);
+                diagnoseBuildFailure(buildResult.stderr || buildResult.output || '', cwd);
                 if (!force) {
                     return false;
                 }
                 console.log(colors.yellow('Continuing with --force despite build failure...'));
             }
             else {
-                console.log(colors.green('✓ Build succeeded'));
+                console.log(`${timestamp()} ${colors.green('✓ Build succeeded')}`);
             }
         }
         else {
@@ -3392,7 +3487,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     // Git operations
     if (currentGitStatus.hasUncommitted) {
         const commitMsg = message || 'Pre-release commit';
-        console.log(`Committing changes: ${commitMsg}`);
+        console.log(`${timestamp()} Committing changes: ${commitMsg}`);
         if (!dryRun) {
             // Remove 'nul' files that break git on Windows
             const nulCount = removeNulFiles(cwd);
@@ -3490,7 +3585,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         console.log(`Skipping version bump — ${pkg.version} already set locally.`);
     }
     else {
-        console.log(`Bumping version (${bump})...`);
+        console.log(`${timestamp()} Bumping version (${bump})...`);
     }
     if (!dryRun && !skipVersionBump) {
         // Temporarily disable postversion hook to prevent double-publishing or push
@@ -3547,6 +3642,9 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 if (error.code)
                     console.error('  exit code:', error.code);
             }
+            // Diagnose common failures (missing modules, permissions, TS errors)
+            const versionErrorText = [error.message, error.stderr, error.stdout].filter(Boolean).join('\n');
+            diagnoseBuildFailure(versionErrorText, cwd);
             // Show the full error stack in verbose mode
             if (verbose && error.stack) {
                 console.error('  Stack trace:', error.stack);
@@ -3734,38 +3832,51 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     else if (!skipVersionBump) {
         console.log(`  [dry-run] Would run: npm version ${bump}`);
     }
-    // Check for public package depending on private dependencies
+    // Check for public package depending on private/unpublished scoped dependencies
+    // Only scoped deps can be private — unscoped are always public on npm.
+    // Use a single fast `npm view` per dep instead of the full checkNpmAccess.
     const publishAccess = effectiveNpmVisibility || currentAccess || (isScoped ? 'restricted' : 'public');
     if (publishAccess === 'public') {
-        const privateDeps = [];
+        const scopedDeps = [];
         for (const depKey of ['dependencies', 'peerDependencies']) {
             const deps = pkg[depKey];
             if (!deps)
                 continue;
             for (const depName of Object.keys(deps)) {
-                const depAccess = checkNpmAccess(depName);
-                if (depAccess === 'restricted') {
-                    privateDeps.push(depName);
-                }
-                else if (depAccess === null && depName.startsWith('@')) {
-                    // Scoped package not on npm — will be private by default
-                    privateDeps.push(`${depName} (not yet published)`);
-                }
+                if (depName.startsWith('@'))
+                    scopedDeps.push(depName);
             }
         }
-        if (privateDeps.length > 0) {
-            console.log('');
-            console.error(colors.red('WARNING: Public package depends on PRIVATE dependencies:'));
-            for (const d of privateDeps) {
-                console.error(colors.red(`  ${d}`));
+        if (scopedDeps.length > 0) {
+            const privateDeps = [];
+            for (const depName of scopedDeps) {
+                const viewResult = spawnSafe('npm', ['view', depName, 'name'], {
+                    encoding: 'utf-8', stdio: 'pipe', shell: true
+                });
+                if (viewResult.status !== 0) {
+                    const stderr = viewResult.stderr || '';
+                    if (stderr.includes('404') || stderr.includes('not found')) {
+                        privateDeps.push(`${depName} (not on npm)`);
+                    }
+                    else {
+                        privateDeps.push(`${depName} (restricted)`);
+                    }
+                }
+            }
+            if (privateDeps.length > 0) {
+                console.log('');
+                console.error(colors.red('WARNING: Public package depends on PRIVATE/missing dependencies:'));
+                for (const d of privateDeps) {
+                    console.error(colors.red(`  ${d}`));
+                }
+                console.error(colors.yellow('Consumers will get E404 when installing this package.'));
+                console.error(colors.yellow('Fix: publish those deps as public, or make this package private.'));
+                console.log('');
             }
-            console.error(colors.yellow('Consumers will get E404 when installing this package.'));
-            console.error(colors.yellow('Fix: publish those deps as public, or make this package private.'));
-            console.log('');
         }
     }
     // Publish
-    console.log('Publishing to npm...');
+    console.log(`${timestamp()} Publishing to npm...`);
     if (!dryRun) {
         // Check npm authentication right before publishing
         const authStatus = checkNpmAuth();
@@ -3929,7 +4040,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
         // Determine what was published
         const finalAccess = effectiveNpmVisibility || currentAccess || (isScoped ? 'restricted' : 'public');
         const accessLabel = (finalAccess === 'restricted' || finalAccess === 'private') ? 'PRIVATE' : 'PUBLIC';
-        console.log(colors.green(`✓ Published to npm as ${accessLabel}`));
+        console.log(`${timestamp()} ${colors.green(`✓ Published to npm as ${accessLabel}`)}`);
     }
     else {
         console.log(`  [dry-run] Would run: npm publish ${quiet ? '--quiet' : ''}`);
@@ -3937,7 +4048,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     // Push to git (with push-protection detection and auto-bypass)
     if (currentGitStatus.hasRemote) {
         if (verbose) {
-            console.log('Pushing to git...');
+            console.log(`${timestamp()} Pushing to git...`);
         }
         if (!dryRun) {
             if (pushWithProtection(cwd, verbose)) {
@@ -4001,7 +4112,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 }
             }
             else {
-                console.log(`Installing globally from registry: ${pkgName}@${pkgVersion}...`);
+                console.log(`${timestamp()} Installing globally from registry: ${pkgName}@${pkgVersion}...`);
                 if (!dryRun) {
                     waitForNpmVersion(pkgName, pkgVersion);
                     const installResult = installGlobalWithRetry(`${pkgName}@${pkgVersion}`, cwd);
@@ -4072,7 +4183,7 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     else if (!files) {
         console.log('Keeping npm versions (--nofiles mode).');
     }
-    console.log('Done!');
+    console.log(`${timestamp()} Done!`);
     // Run final audit report if not already run
     const auditAlreadyRun = (fix || updateDeps) && (transformResult.transformed || alreadyTransformed || updateDeps);
     if (!auditAlreadyRun && (fix || updateDeps || transformResult.transformed) && !dryRun) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.139",
+  "version": "1.0.141",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",
@@ -33,7 +33,7 @@
   "dependencies": {
     "@bobfrankston/freezepak": "^0.1.6",
     "@bobfrankston/importgen": "^0.1.32",
-    "@bobfrankston/themecolors": "^0.1.2",
+    "@bobfrankston/themecolors": "^0.1.4",
     "@bobfrankston/userconfig": "^1.0.6",
     "@npmcli/package-json": "^7.0.4",
     "json5": "^2.2.3",