@bobfrankston/npmglobalize 1.0.12 → 1.0.18

package/lib.js

@@ -6,11 +6,13 @@ import path from 'path';
 import { execSync, spawnSync } from 'child_process';
 import readline from 'readline';
 import libversion from 'libnpmversion';
+import JSON5 from 'json5';
 /** ANSI color codes */
 const colors = {
     red: (text) => `\x1b[31m${text}\x1b[0m`,
     yellow: (text) => `\x1b[33m${text}\x1b[0m`,
     green: (text) => `\x1b[32m${text}\x1b[0m`,
+    italic: (text) => `\x1b[3m${text}\x1b[0m`,
 };
 const DEP_KEYS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
 /** Read and parse package.json from a directory */
@@ -21,54 +23,100 @@ export function readPackageJson(dir) {
     }
     return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 }
-/** Read .globalize.jsonc config file */
+/** Read .globalize.json5 config file */
 export function readConfig(dir) {
-    const configPath = path.join(dir, '.globalize.jsonc');
+    const configPath = path.join(dir, '.globalize.json5');
     if (!fs.existsSync(configPath)) {
         return {};
     }
     try {
         const content = fs.readFileSync(configPath, 'utf-8');
-        // Strip comments for JSON parsing (simple implementation)
-        const jsonContent = content
-            .split('\n')
-            .map(line => line.replace(/\/\/.*$/, '').trim())
-            .filter(line => line.length > 0)
-            .join('\n');
-        return JSON.parse(jsonContent);
+        return JSON5.parse(content);
     }
     catch (error) {
-        console.warn(`Warning: Could not parse .globalize.jsonc config: ${error.message}`);
+        console.warn(`Warning: Could not parse .globalize.json5 config: ${error.message}`);
         return {};
     }
 }
-/** Write .globalize.jsonc config file */
-export function writeConfig(dir, config) {
-    const configPath = path.join(dir, '.globalize.jsonc');
+/** Write .globalize.json5 config file */
+export function writeConfig(dir, config, explicitKeys) {
+    const configPath = path.join(dir, '.globalize.json5');
+    // Define defaults to omit
+    const defaults = {
+        bump: 'patch',
+        files: true,
+        quiet: true,
+        gitVisibility: 'private',
+        npmVisibility: 'public',
+        install: false,
+        wsl: false,
+        force: false,
+        verbose: false
+    };
+    // Read existing config to preserve values
+    const existing = readConfig(dir);
+    // Filter out temporary flags and default values (unless explicitly set)
+    const filtered = {};
+    const omitKeys = new Set(['applyOnly', 'cleanup', 'init', 'dryRun', 'message', 'conform', 'asis', 'help', 'error']);
+    for (const [key, value] of Object.entries(config)) {
+        if (omitKeys.has(key))
+            continue;
+        // Keep if: already in config, explicitly set via CLI, or differs from default
+        const isExplicit = explicitKeys?.has(key);
+        const wasInConfig = key in existing;
+        const differsFromDefault = defaults[key] !== value;
+        if (isExplicit || wasInConfig || differsFromDefault) {
+            filtered[key] = value;
+        }
+    }
     // Build content with comments
     const lines = [
         '{',
-        '  // Only set options that differ from defaults',
-        '  // Defaults: bump=patch, files=true, quiet=true, gitVisibility=private, npmVisibility=public',
+        '  // npmglobalize configuration (JSON5 format - trailing commas OK)',
+        '  // Explicitly set values are preserved here',
         ''
     ];
     // Add configured values
-    for (const [key, value] of Object.entries(config)) {
-        const jsonValue = typeof value === 'string' ? `"${value}"` : JSON.stringify(value);
-        lines.push(`  "${key}": ${jsonValue},`);
-    }
-    // Add commented examples for other options
-    lines.push('');
-    lines.push('  // Available options:');
-    lines.push('  // "bump": "patch" | "minor" | "major"');
-    lines.push('  // "install": true | false  // Auto-install globally after publish');
-    lines.push('  // "wsl": true | false      // Also install in WSL');
-    lines.push('  // "files": true | false    // Keep file: paths after publish');
-    lines.push('  // "force": true | false    // Continue despite git errors');
-    lines.push('  // "quiet": true | false    // Suppress npm warnings');
-    lines.push('  // "verbose": true | false  // Show detailed output');
-    lines.push('  // "gitVisibility": "private" | "public"');
-    lines.push('  // "npmVisibility": "private" | "public"');
+    const entries = Object.entries(filtered);
+    if (entries.length > 0) {
+        entries.forEach(([key, value]) => {
+            const jsonValue = typeof value === 'string' ? `"${value}"` : JSON.stringify(value);
+            const comma = ','; // JSON5 allows trailing commas
+            // Add inline comment for clarity
+            let comment = '';
+            if (key === 'install')
+                comment = '  // Auto-install globally after publish';
+            else if (key === 'wsl')
+                comment = '  // Also install in WSL';
+            else if (key === 'files')
+                comment = '  // Keep file: paths after publish';
+            else if (key === 'force')
+                comment = '  // Continue despite git errors';
+            else if (key === 'quiet')
+                comment = '  // Suppress npm warnings';
+            else if (key === 'verbose')
+                comment = '  // Show detailed output';
+            else if (key === 'gitVisibility')
+                comment = '  // private (default) or public';
+            else if (key === 'npmVisibility')
+                comment = '  // private or public (default)';
+            else if (key === 'bump')
+                comment = '  // patch (default), minor, or major';
+            lines.push(`  "${key}": ${jsonValue}${comma}${comment}`);
+        });
+        lines.push('');
+    }
+    // Add commented reference for all options
+    lines.push('  // Defaults (omitted above):');
+    lines.push('  // "bump": "patch"              // Version bump: patch, minor, major');
+    lines.push('  // "install": false             // Auto-install globally after publish');
+    lines.push('  // "wsl": false                 // Also install in WSL');
+    lines.push('  // "files": true                // Keep file: paths after publish');
+    lines.push('  // "force": false               // Continue despite git errors');
+    lines.push('  // "quiet": true                // Suppress npm warnings');
+    lines.push('  // "verbose": false             // Show detailed output');
+    lines.push('  // "gitVisibility": "private"   // Git repo: private or public');
+    lines.push('  // "npmVisibility": "public"    // npm package: private or public');
     lines.push('}');
     fs.writeFileSync(configPath, lines.join('\n') + '\n');
 }
@@ -165,13 +213,13 @@ export function hasBackup(pkg) {
 }
 /** Run a command and return success status */
 export function runCommand(cmd, args, options = {}) {
-    const { silent = false, cwd } = options;
+    const { silent = false, cwd, shell = false } = options;
     try {
         const result = spawnSync(cmd, args, {
             encoding: 'utf-8',
             stdio: silent ? 'pipe' : 'inherit',
             cwd,
-            shell: true // Use shell for better Windows compatibility and output capture
+            shell // Use shell when explicitly requested (e.g., for npm publish on Windows)
         });
         // For non-silent commands, we can't capture output when using 'inherit'
         // So we return empty string for output, but the user sees it in the terminal
@@ -379,9 +427,155 @@ Authentication Options:
    - Run: ${colors.green('npm login')}
    - Follow interactive prompts
 
+${colors.italic('Note: y:\\dev\\utils\\npmglobalize has set-npm-token.ps1 that may help fix token')}
+${colors.italic('      problems, but no promises.')}
+
 Note: npm now requires either 2FA or a granular token with bypass enabled.
 `;
 }
+/** Recommended .gitignore patterns */
+const RECOMMENDED_GITIGNORE = [
+    'node_modules/',
+    '.env*',
+    '*cert*/',
+    '*.pem',
+    '*.key',
+    '*.p12',
+    '*.pfx',
+    'token',
+    'tokens',
+    '*.token',
+    '.globalize.json5',
+    '*.log',
+    '.DS_Store',
+    'Thumbs.db'
+];
+/** Recommended .npmignore patterns */
+const RECOMMENDED_NPMIGNORE = [
+    '.git/',
+    '.gitignore',
+    '.gitattributes',
+    'certs/',
+    '*cert*/',
+    '.env*',
+    'token*',
+    'cruft/',
+    'prev/',
+    'tests/',
+    '*.md',
+    '!README.md',
+    '*.log',
+    '.DS_Store',
+    'Thumbs.db',
+    'package-lock.json',
+    '*.ts',
+    '!*.d.ts',
+    '*.map',
+    'tsconfig.json',
+    '.vscode/',
+    '.globalize.json5'
+];
+/** Check if ignore files need updates */
+function checkIgnoreFiles(cwd, options) {
+    const changes = [];
+    // Check if asis is set in config or passed as option
+    if (options.asis) {
+        if (options.verbose) {
+            console.log(colors.yellow('  Skipping ignore file checks (--asis or asis in config)'));
+        }
+        return { needsUpdate: false, changes: [] };
+    }
+    // Check .gitignore
+    const gitignorePath = path.join(cwd, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        const lines = content.split('\n').map(l => l.trim());
+        for (const pattern of RECOMMENDED_GITIGNORE) {
+            if (!lines.some(line => line === pattern || line === pattern.replace('/', ''))) {
+                changes.push(`  .gitignore missing: ${pattern}`);
+            }
+        }
+    }
+    // Check .npmignore
+    const npmignorePath = path.join(cwd, '.npmignore');
+    if (fs.existsSync(npmignorePath)) {
+        const content = fs.readFileSync(npmignorePath, 'utf-8');
+        const lines = content.split('\n').map(l => l.trim());
+        // Check for missing TypeScript exclusions
+        const hasMapExclusion = lines.some(line => line === '*.map');
+        const hasTsExclusion = lines.some(line => line === '*.ts');
+        const hasDtsInclude = lines.some(line => line === '!*.d.ts');
+        if (!hasMapExclusion) {
+            changes.push('  .npmignore missing: *.map');
+        }
+        if (!hasTsExclusion) {
+            changes.push('  .npmignore missing: *.ts');
+        }
+        if (!hasDtsInclude && hasTsExclusion) {
+            changes.push('  .npmignore missing: !*.d.ts (to keep type definitions)');
+        }
+        // Check for token files
+        if (!lines.some(line => line.includes('token'))) {
+            changes.push('  .npmignore missing: token* (security)');
+        }
+    }
+    return { needsUpdate: changes.length > 0, changes };
+}
+/** Update ignore files to conform to best practices */
+function conformIgnoreFiles(cwd) {
+    // Update .gitignore
+    const gitignorePath = path.join(cwd, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        const lines = new Set(content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#')));
+        let updated = false;
+        for (const pattern of RECOMMENDED_GITIGNORE) {
+            const normalized = pattern.replace('/', '');
+            if (!lines.has(pattern) && !lines.has(normalized)) {
+                lines.add(pattern);
+                updated = true;
+            }
+        }
+        if (updated) {
+            const newContent = Array.from(lines).sort().join('\n') + '\n';
+            fs.writeFileSync(gitignorePath, newContent);
+            console.log(colors.green('  ✓ Updated .gitignore'));
+        }
+    }
+    // Update .npmignore
+    const npmignorePath = path.join(cwd, '.npmignore');
+    if (fs.existsSync(npmignorePath)) {
+        const content = fs.readFileSync(npmignorePath, 'utf-8');
+        const lines = content.split('\n').map(l => l.trim());
+        const newLines = new Set(lines.filter(l => l));
+        let updated = false;
+        // Add TypeScript exclusions
+        if (!newLines.has('*.ts')) {
+            newLines.add('*.ts');
+            updated = true;
+        }
+        if (!newLines.has('!*.d.ts')) {
+            newLines.add('!*.d.ts');
+            updated = true;
+        }
+        if (!newLines.has('*.map')) {
+            newLines.add('*.map');
+            updated = true;
+        }
+        // Add other missing patterns
+        for (const pattern of RECOMMENDED_NPMIGNORE) {
+            if (!newLines.has(pattern)) {
+                newLines.add(pattern);
+                updated = true;
+            }
+        }
+        if (updated) {
+            const newContent = Array.from(newLines).join('\n') + '\n';
+            fs.writeFileSync(npmignorePath, newContent);
+            console.log(colors.green('  ✓ Updated .npmignore'));
+        }
+    }
+}
 /** Ensure .gitignore exists and includes node_modules */
 function ensureGitignore(cwd) {
     const gitignorePath = path.join(cwd, '.gitignore');
@@ -487,7 +681,37 @@ export async function initGit(cwd, visibility, dryRun) {
 }
 /** Main globalize function */
 export async function globalize(cwd, options = {}) {
-    const { bump = 'patch', applyOnly = false, cleanup = false, install = false, wsl = false, force = false, files = true, dryRun = false, quiet = true, verbose = false, init = false, gitVisibility = 'private', npmVisibility = 'public', message } = options;
+    const { bump = 'patch', applyOnly = false, cleanup = false, install = false, wsl = false, force = false, files = true, dryRun = false, quiet = true, verbose = false, init = false, gitVisibility = 'private', npmVisibility = 'public', message, conform = false, asis = false } = options;
+    // Check ignore files first (unless cleanup mode)
+    if (!cleanup && !asis) {
+        const checkResult = checkIgnoreFiles(cwd, { conform, asis, verbose });
+        if (checkResult.needsUpdate) {
+            console.log(colors.yellow('\nIgnore file recommendations:'));
+            for (const change of checkResult.changes) {
+                console.log(colors.yellow(change));
+            }
+            console.log('');
+            if (conform) {
+                console.log('Updating ignore files (--conform)...');
+                conformIgnoreFiles(cwd);
+                console.log('');
+            }
+            else {
+                console.log(colors.yellow('Run with --conform to apply these changes'));
+                console.log(colors.yellow('Or set "asis": true in .globalize.json5 to suppress checks'));
+                console.log(colors.yellow('Or use --asis flag to skip this check'));
+                console.log('');
+                const shouldContinue = await confirm('Continue anyway?', true);
+                if (!shouldContinue) {
+                    return false;
+                }
+            }
+        }
+        else if (verbose) {
+            console.log(colors.green('✓ Ignore files look good'));
+            console.log('');
+        }
+    }
     // Handle cleanup mode
     if (cleanup) {
         console.log('Restoring dependencies from backup...');
@@ -659,6 +883,60 @@ export async function globalize(cwd, options = {}) {
     if (!currentGitStatus.hasUncommitted && !message) {
         console.log('');
         console.log('No changes to commit and no custom message specified.');
+        // If install flag is set, verify/install even without publishing
+        if (install || wsl) {
+            console.log('');
+            console.log('Checking global installation...');
+            const pkgName = pkg.name;
+            if (install) {
+                const verifyResult = runCommand('npm', ['list', '-g', '--depth=0', pkgName], { cwd, silent: true });
+                if (verifyResult.success) {
+                    console.log(colors.green(`✓ Already installed globally: ${pkgName}`));
+                }
+                else {
+                    console.log(colors.yellow(`Package not installed globally. Installing latest version...`));
+                    const installResult = runCommand('npm', ['install', '-g', `${pkgName}@latest`], { cwd, silent: false });
+                    if (installResult.success) {
+                        const reVerify = runCommand('npm', ['list', '-g', '--depth=0', pkgName], { cwd, silent: true });
+                        if (reVerify.success) {
+                            const version = pkg.version;
+                            console.log(colors.green(`✓ Installed and verified globally: ${pkgName}@${version}`));
+                        }
+                        else {
+                            console.log(colors.yellow(`⚠ Install appeared successful but verification failed`));
+                        }
+                    }
+                    else {
+                        console.error(colors.red(`✗ Global install failed`));
+                    }
+                }
+            }
+            if (wsl) {
+                const verifyResult = runCommand('wsl', ['npm', 'list', '-g', '--depth=0', pkgName], { cwd, silent: true });
+                if (verifyResult.success) {
+                    console.log(colors.green(`✓ Already installed in WSL: ${pkgName}`));
+                }
+                else {
+                    console.log(colors.yellow(`Package not installed in WSL. Installing latest version...`));
+                    const wslInstallResult = runCommand('wsl', ['npm', 'install', '-g', `${pkgName}@latest`], { cwd, silent: false });
+                    if (wslInstallResult.success) {
+                        const reVerify = runCommand('wsl', ['npm', 'list', '-g', '--depth=0', pkgName], { cwd, silent: true });
+                        if (reVerify.success) {
+                            const version = pkg.version;
+                            console.log(colors.green(`✓ Installed and verified in WSL: ${pkgName}@${version}`));
+                        }
+                        else {
+                            console.log(colors.yellow(`⚠ WSL install appeared successful but verification failed`));
+                        }
+                    }
+                    else {
+                        console.error(colors.yellow('✗ WSL install failed (is npm installed in WSL?)'));
+                    }
+                }
+            }
+            console.log('');
+            return true;
+        }
         console.log('Nothing to release. Use -m "message" to force a release.');
         return true;
     }
@@ -671,8 +949,22 @@ export async function globalize(cwd, options = {}) {
         const commitMsg = message || 'Pre-release commit';
         console.log(`Committing changes: ${commitMsg}`);
         if (!dryRun) {
-            runCommand('git', ['add', '-A'], { cwd });
-            runCommand('git', ['commit', '-m', commitMsg], { cwd });
+            const addResult = runCommand('git', ['add', '-A'], { cwd });
+            if (!addResult.success) {
+                console.error(colors.red('ERROR: Failed to add files to git:'), addResult.stderr);
+                if (!force) {
+                    return false;
+                }
+                console.log(colors.yellow('Continuing with --force...'));
+            }
+            const commitResult = runCommand('git', ['commit', '-m', commitMsg], { cwd });
+            if (!commitResult.success) {
+                console.error(colors.red('ERROR: Failed to commit changes:'), commitResult.stderr);
+                if (!force) {
+                    return false;
+                }
+                console.log(colors.yellow('Continuing with --force...'));
+            }
         }
         else {
             console.log('  [dry-run] Would commit changes');
@@ -701,69 +993,85 @@ export async function globalize(cwd, options = {}) {
     }
     // Publish
     console.log('Publishing to npm...');
-    const npmArgs = ['publish'];
-    if (quiet) {
-        npmArgs.push('--quiet');
-    }
     if (!dryRun) {
-        // Run with silent:true to capture the error message
-        const publishResult = runCommand('npm', npmArgs, { cwd, silent: true });
-        if (!publishResult.success) {
-            console.error(colors.red('\nERROR: npm publish failed\n'));
-            // Combine stdout and stderr for error analysis
-            const errorOutput = (publishResult.output + '\n' + publishResult.stderr).toLowerCase();
-            // Check for specific error types
-            if (errorOutput.includes('e403') && (errorOutput.includes('two-factor') || errorOutput.includes('2fa'))) {
-                console.error(colors.red('⚠ 2FA Required'));
-                console.error('');
-                console.error('Your npm account requires two-factor authentication or a');
-                console.error('granular access token with "bypass 2FA" enabled.');
-                console.error('');
-                console.error(colors.yellow('Your options:'));
-                console.error('');
-                console.error('1. Enable 2FA on your npm account:');
-                console.error(colors.green('   https://www.npmjs.com/settings/[username]/tfa'));
-                console.error('');
-                console.error('2. Create a granular access token:');
-                console.error(colors.green('   https://www.npmjs.com/settings/[username]/tokens'));
-                console.error('   - Select "Granular Access Token"');
-                console.error('   - Set permissions: Read and write');
-                console.error('   - Enable "Bypass 2FA requirement"');
-                console.error('   - Then set via environment variable or .npmrc:');
-                console.error(colors.green('     $env:NPM_TOKEN="npm_xxx..."'));
-                console.error('   Or add to ~/.npmrc:');
-                console.error(colors.green('     //registry.npmjs.org/:_authToken=npm_xxx...'));
-                console.error('');
+        // Create tarball first
+        const packResult = runCommand('npm', ['pack'], { cwd, silent: true, shell: true });
+        if (!packResult.success) {
+            console.error(colors.red('ERROR: Failed to create package tarball'));
+            if (packResult.stderr)
+                console.error(packResult.stderr);
+            return false;
+        }
+        // Get the tarball filename from npm pack output
+        const tarballName = packResult.output.trim().split('\n').pop()?.trim();
+        if (!tarballName) {
+            console.error(colors.red('ERROR: Could not determine tarball filename'));
+            return false;
+        }
+        const tarballPath = path.join(cwd, tarballName);
+        if (verbose) {
+            console.log(`Created tarball: ${tarballName}`);
+        }
+        // Publish the tarball
+        const npmArgs = ['publish', tarballName];
+        if (npmVisibility === 'public') {
+            npmArgs.push('--access', 'public');
+        }
+        if (quiet) {
+            npmArgs.push('--quiet');
+        }
+        // Retry logic for E409 conflicts (publishing too fast)
+        const maxRetries = 12; // 12 attempts * 5 seconds = 60 seconds total
+        const retryDelay = 5; // 5 seconds between attempts
+        let publishResult;
+        let attempt = 0;
+        while (attempt < maxRetries) {
+            if (attempt > 0) {
+                console.log(colors.yellow(`⏱ Waiting ${retryDelay} seconds before retry (attempt ${attempt + 1}/${maxRetries})...`));
+                await new Promise(resolve => setTimeout(resolve, retryDelay * 1000));
             }
-            else if (errorOutput.includes('e404') || errorOutput.includes('not found')) {
-                console.error(colors.yellow('Package not found or access denied.'));
-                console.error('');
-                console.error('Possible causes:');
-                console.error('  • Package name is not available');
-                console.error('  • You don\'t have permission to publish to this package');
-                console.error('  • Scope (@username/) requires organization access');
-                console.error('');
+            publishResult = runCommand('npm', npmArgs, { cwd, silent: true, shell: true });
+            if (publishResult.success) {
+                break; // Success!
+            }
+            // Check if it's an E409 error
+            const output = (publishResult.output + '\n' + publishResult.stderr).toLowerCase();
+            const isE409 = output.includes('e409') || output.includes('409 conflict');
+            if (!isE409) {
+                break; // Not an E409, don't retry
+            }
+            if (attempt === 0) {
+                console.log(colors.yellow('⚠ npm is still processing the previous version, retrying...'));
             }
-            else if (errorOutput.includes('e402') || errorOutput.includes('payment required')) {
-                console.error(colors.yellow('Payment required for private packages.'));
+            attempt++;
+        }
+        // Clean up tarball
+        try {
+            fs.unlinkSync(tarballPath);
+            if (verbose) {
+                console.log(`Cleaned up tarball: ${tarballName}`);
+            }
+        }
+        catch (e) {
+            // Ignore cleanup errors
+        }
+        if (!publishResult.success) {
+            console.error(colors.red('\nERROR: npm publish failed\n'));
+            // Check for E409 conflict (publishing too fast)
+            const output = (publishResult.output + '\n' + publishResult.stderr).toLowerCase();
+            if (output.includes('e409') || output.includes('409 conflict')) {
+                console.error(colors.yellow('⚠ Publishing too quickly'));
                 console.error('');
-                console.error('Private scoped packages require a paid npm account.');
-                console.error('Either upgrade your account or make the package public.');
+                console.error('npm is still processing the previous version after multiple retries.');
+                console.error(colors.green('Solution: Wait a few more minutes and try again'));
                 console.error('');
             }
             else {
-                // Show the actual error output
-                if (publishResult.stderr) {
-                    console.error(publishResult.stderr);
-                }
-                if (publishResult.output) {
-                    console.error(publishResult.output);
-                }
-                console.error('');
                 console.error(colors.yellow('Common causes:'));
                 console.error(colors.yellow('  1. Not logged in - run: npm login'));
                 console.error(colors.yellow('  2. Version already published'));
                 console.error(colors.yellow('  3. Authentication token expired'));
+                console.error('');
             }
             if (transformed) {
                 console.log('Run --cleanup to restore file: dependencies');
@@ -788,21 +1096,46 @@ export async function globalize(cwd, options = {}) {
     }
     // Global install
     const pkgName = pkg.name;
+    const pkgVersion = pkg.version;
     if (install) {
-        console.log(`Installing globally: ${pkgName}...`);
+        console.log(`Installing globally: ${pkgName}@${pkgVersion}...`);
         if (!dryRun) {
-            runCommand('npm', ['install', '-g', pkgName], { cwd });
+            const installResult = runCommand('npm', ['install', '-g', `${pkgName}@latest`], { cwd, silent: false });
+            if (installResult.success) {
+                // Verify installation by checking if command exists
+                const verifyResult = runCommand('npm', ['list', '-g', '--depth=0', pkgName], { cwd, silent: true });
+                if (verifyResult.success) {
+                    console.log(colors.green(`✓ Installed and verified globally: ${pkgName}@${pkgVersion}`));
+                }
+                else {
+                    console.log(colors.yellow(`⚠ Install appeared successful but verification failed`));
+                }
+            }
+            else {
+                console.error(colors.red(`✗ Global install failed`));
+                console.error(colors.yellow('  Try running manually: npm install -g ' + pkgName));
+            }
         }
         else {
             console.log(`  [dry-run] Would run: npm install -g ${pkgName}`);
         }
     }
     if (wsl) {
-        console.log(`Installing in WSL: ${pkgName}...`);
+        console.log(`Installing in WSL: ${pkgName}@${pkgVersion}...`);
         if (!dryRun) {
-            const wslResult = runCommand('wsl', ['npm', 'install', '-g', pkgName], { cwd });
-            if (!wslResult.success) {
-                console.log('  Warning: WSL install failed (is npm installed in WSL?)');
+            const wslResult = runCommand('wsl', ['npm', 'install', '-g', `${pkgName}@latest`], { cwd, silent: false });
+            if (wslResult.success) {
+                // Verify WSL installation
+                const verifyResult = runCommand('wsl', ['npm', 'list', '-g', '--depth=0', pkgName], { cwd, silent: true });
+                if (verifyResult.success) {
+                    console.log(colors.green(`✓ Installed and verified in WSL: ${pkgName}@${pkgVersion}`));
+                }
+                else {
+                    console.log(colors.yellow(`⚠ WSL install appeared successful but verification failed`));
+                }
+            }
+            else {
+                console.error(colors.yellow('  ✗ WSL install failed (is npm installed in WSL?)'));
             }
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.12",
+  "version": "1.0.18",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",
@@ -27,6 +27,7 @@
     "url": "https://github.com/BobFrankston/npmglobalize.git"
   },
   "dependencies": {
+    "json5": "^2.2.3",
     "libnpmversion": "^8.0.3"
   }
 }

package/.gitattributes

@@ -1,10 +0,0 @@
-# Force LF line endings for all text files
-* text=auto eol=lf
-
-# Ensure these are always LF
-*.ts text eol=lf
-*.js text eol=lf
-*.json text eol=lf
-*.md text eol=lf
-*.yml text eol=lf
-*.yaml text eol=lf